From f615474fed06e1825f6c2c2ed8819a1781afc030 Mon Sep 17 00:00:00 2001 From: "Pedro J. Molina" Date: Mon, 9 Oct 2017 18:18:54 +0200 Subject: [PATCH 01/55] Provision sample for ASP.NET on azure_rm_app_service --- examples/app-service-asp-net/README.md | 23 +++++++ examples/app-service-asp-net/app.tf | 65 +++++++++++++++++++ examples/app-service-asp-net/variables.tf | 45 +++++++++++++ examples/app-service-asp-net/web-package.zip | Bin 0 -> 378 bytes 4 files changed, 133 insertions(+) create mode 100644 examples/app-service-asp-net/README.md create mode 100644 examples/app-service-asp-net/app.tf create mode 100644 examples/app-service-asp-net/variables.tf create mode 100644 examples/app-service-asp-net/web-package.zip diff --git a/examples/app-service-asp-net/README.md b/examples/app-service-asp-net/README.md new file mode 100644 index 000000000000..d0190b8b7a23 --- /dev/null +++ b/examples/app-service-asp-net/README.md @@ -0,0 +1,23 @@ +# ASP.NET App-Service Sample + +Sample to deploy an ASP.NET application into Azure App-Services. + +## Creates + +1. A Resource Group +2. An App Service Plan +3. An App Service for usage with .NET +4. Deploy a simple app into (3). + +## Usage + +- Provide values to all variables (credentials and names). +- Create with `terraform apply` +- Destroy all with `terraform destroy --force` + + +## Prerequisites + +- Uses `curl` for application publication. Preinstall curl in your system and add it to the system path. + +**Note:** The Sample uses a local provisioner prepared for a DOS shell (trivial changes needed for a bash shell). \ No newline at end of file diff --git a/examples/app-service-asp-net/app.tf b/examples/app-service-asp-net/app.tf new file mode 100644 index 000000000000..f22515c6dcd2 --- /dev/null +++ b/examples/app-service-asp-net/app.tf @@ -0,0 +1,65 @@ +# Configure the Microsoft Azure Provider +provider "azurerm" { + subscription_id = "${var.subscription_id}" + client_id = "${var.client_id}" + client_secret = "${var.client_secret}" + tenant_id = "${var.tenant_id}" +} + +resource "azurerm_resource_group" "g1" { + name = "{$var.groupName}" + location = "${var.location}" +} + +resource "azurerm_app_service_plan" "plan0" { + name = "service-plan0" + location = "${var.location}" + resource_group_name = "${azurerm_resource_group.g1.name}" + + sku { + tier = "Basic" # Basic | Standard | ... + size = "B1" # B1 | S1 | ... + } +} + +# underscores not supported as app_service name -> if not: you will receive error 400 + +resource "azurerm_app_service" "common_service" { + name = "${var.webName}" + location = "${var.location}" + resource_group_name = "${azurerm_resource_group.g1.name}" + app_service_plan_id = "${azurerm_app_service_plan.plan0.id}" + + site_config { + dotnet_framework_version = "v4.0" + remote_debugging_enabled = true + remote_debugging_version = "VS2015" + } + + # app_settings { + # "SOME_KEY" = "some-value" + # } + # connection_string { + # name = "Database" + # type = "SQLServer" + # value = "Server=some-server.mydomain.com;Integrated Security=SSPI" + # } + + provisioner "local-exec" { + command = "curl -k -u ${var.deploy_user}:${var.deploy_pass} -X PUT --data-binary @${var.deployZipFile} https://${azurerm_app_service.common_service.name}.scm.azurewebsites.net/api/zip/site/wwwroot/" + + # interpreter = ["cmd"] + } +} + +output "service" { + value = "${azurerm_app_service.common_service.name}" +} + +output "serviceUrl" { + value = "https://${azurerm_app_service.common_service.name}.azurewebsites.net" +} + +output "adminUrl" { + value = "https://${azurerm_app_service.common_service.name}.scm.azurewebsites.net" +} diff --git a/examples/app-service-asp-net/variables.tf b/examples/app-service-asp-net/variables.tf new file mode 100644 index 000000000000..be7ddb061782 --- /dev/null +++ b/examples/app-service-asp-net/variables.tf @@ -0,0 +1,45 @@ +variable "groupName" { + type = "string" + default = "yourGroupName" +} + +variable "location" { + type = "string" + default = "westeurope" +} + +variable "webName" { + type = "string" + + # will create -> mySite123456.azurewebsites.net #should be unique + # default = "mySite123456" +} + +variable "subscription_id" { + type = "string" +} + +variable "client_id" { + type = "string" +} + +variable "client_secret" { + type = "string" +} + +variable "tenant_id" { + type = "string" +} + +variable "deploy_user" { + type = "string" +} + +variable "deploy_pass" { + type = "string" +} + +variable "deployZipFile" { + type = "string" + default = "web-package.zip" +} diff --git a/examples/app-service-asp-net/web-package.zip b/examples/app-service-asp-net/web-package.zip new file mode 100644 index 0000000000000000000000000000000000000000..2291a451f720284b27924254f1867e79bd2e5e68 GIT binary patch literal 378 zcmWIWW@Zs#U|`^2_%XrL`|CZ29CIMg4T!mbI5RILwL&kWBsXXCNsW_dH$Hy)Xp845 z|CKC;A|g3PJa27+iiGYQ-f2^X8b Date: Mon, 30 Oct 2017 13:05:53 -0700 Subject: [PATCH 02/55] Added vnet datasource --- azurerm/data_source_vnet.go | 104 ++++++++++++++++++++++++++++++ azurerm/data_source_vnet_test.go | 105 +++++++++++++++++++++++++++++++ azurerm/provider.go | 1 + 3 files changed, 210 insertions(+) create mode 100644 azurerm/data_source_vnet.go create mode 100644 azurerm/data_source_vnet_test.go diff --git a/azurerm/data_source_vnet.go b/azurerm/data_source_vnet.go new file mode 100644 index 000000000000..4b480d407491 --- /dev/null +++ b/azurerm/data_source_vnet.go @@ -0,0 +1,104 @@ +package azurerm + +import ( + "fmt" + "net/http" + + "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/hashicorp/terraform/helper/schema" + //"github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" +) + +func dataSourceArmVnet() *schema.Resource { + return &schema.Resource{ + Read: dataSourceArmVnetRead, + Schema: map[string]*schema.Schema{ + "name": { + Type: schema.TypeString, + Required: true, + }, + + "resource_group_name": resourceGroupNameForDataSourceSchema(), + + "address_spaces": { + Type: schema.TypeList, + Computed: true, + Elem: &schema.Schema{ + Type: schema.TypeString, + }, + }, + + "dns_servers": { + Type: schema.TypeList, + Computed: true, + Elem: &schema.Schema{ + Type: schema.TypeString, + }, + }, + + "subnets": { + Type: schema.TypeList, + Computed: true, + Elem: &schema.Schema{ + Type: schema.TypeString, + }, + }, + }, + } +} + +func dataSourceArmVnetRead(d *schema.ResourceData, meta interface{}) error { + vnetClient := meta.(*ArmClient).vnetClient + + resGroup := d.Get("resource_group_name").(string) + name := d.Get("name").(string) + + resp, err := vnetClient.Get(resGroup, name, "") + if err != nil { + if resp.StatusCode == http.StatusNotFound { + d.SetId("") + } + return fmt.Errorf("Error making Read request on Azure public ip %s: %s", name, err) + } + + d.SetId(*resp.ID) + + if props := resp.VirtualNetworkPropertiesFormat; props != nil { + address_spaces := flattenVnetAddressPrefixes(props.AddressSpace.AddressPrefixes) + if err := d.Set("address_spaces", address_spaces); err != nil { + return err + } + + dns_servers := flattenVnetAddressPrefixes(props.DhcpOptions.DNSServers) + if err := d.Set("dns_servers", dns_servers); err != nil { + return err + } + + subnets := flattenVnetSubnetsAddressSpace(props.Subnets) + if err := d.Set("subnets", subnets); err != nil { + return err + } + } + + return nil +} + +func flattenVnetAddressPrefixes(input *[]string) []interface{} { + prefixes := make([]interface{}, 0) + + for _, prefix := range *input { + prefixes = append(prefixes, prefix) + } + + return prefixes +} + +func flattenVnetSubnetsAddressSpace(input *[]network.Subnet) []interface{} { + subnets := make([]interface{}, 0) + + for _, subnet := range *input { + subnets = append(subnets, *subnet.Name) + } + + return subnets +} diff --git a/azurerm/data_source_vnet_test.go b/azurerm/data_source_vnet_test.go new file mode 100644 index 000000000000..f4a7406b02a9 --- /dev/null +++ b/azurerm/data_source_vnet_test.go @@ -0,0 +1,105 @@ +package azurerm + +import ( + "fmt" + "testing" + + "github.com/hashicorp/terraform/helper/acctest" + "github.com/hashicorp/terraform/helper/resource" +) + +func TestAccDataSourceAzureRMVnet_basic(t *testing.T) { + dataSourceName := "data.azurerm_vnet.test" + ri := acctest.RandInt() + + name := fmt.Sprintf("acctestvnet-%d", ri) + config := testAccDataSourceAzureRMVnet_basic(ri, testLocation()) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMVirtualNetworkDestroy, + Steps: []resource.TestStep{ + { + Config: config, + Check: resource.ComposeTestCheckFunc( + resource.TestCheckResourceAttr(dataSourceName, "name", name), + resource.TestCheckResourceAttr(dataSourceName, "dns_servers.0", "10.0.0.10"), + resource.TestCheckResourceAttr(dataSourceName, "address_spaces.0", "10.0.0.0/16"), + ), + }, + }, + }) +} + +// func TestAccDataSourceAzureRMVnet_Subnets(t *testing.T) { +// dataSourceName := "data.azurerm_vnet.test" +// ri := acctest.RandInt() + +// name := fmt.Sprintf("acctestvnet-%d", ri) +// //resourceGroupName := fmt.Sprintf("acctestRG-%d", ri) + +// config := testAccDataSourceAzureRMVnet_basic(ri, testLocation()) + +// resource.Test(t, resource.TestCase{ +// PreCheck: func() { testAccPreCheck(t) }, +// Providers: testAccProviders, +// CheckDestroy: testCheckAzureRMPublicIpDestroy, +// Steps: []resource.TestStep{ +// { +// Config: config, +// Check: resource.ComposeTestCheckFunc( +// resource.TestCheckResourceAttr(dataSourceName, "name", name), +// resource.TestCheckResourceAttr(dataSourceName, "dns_servers", `["10.0.0.10","10.0.0.11"]`), +// ), +// }, +// }, +// }) +// } + +func testAccDataSourceAzureRMVnet_basic(rInt int, location string) string { + return fmt.Sprintf(` + resource "azurerm_resource_group" "test" { + name = "acctest%d-rg" + location = "%s" + } + + resource "azurerm_virtual_network" "test" { + name = "acctestvnet-%d" + address_space = ["10.0.0.0/16"] + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" + dns_servers = ["10.0.0.10"] + } + + data "azurerm_vnet" "test" { + resource_group_name = "${azurerm_resource_group.test.name}" + name = "${azurerm_virtual_network.test.name}" + } + + `, rInt, location, rInt) +} + +// func testAccDataSourceAzureRMVnet_Subnets(rInt int, location string) string { +// return fmt.Sprintf(` +// resource "azurerm_resource_group" "test" { +// name = "acctest%d-rg" +// location = "%s" +// } + +// resource "azurerm_virtual_network" "test" { +// name = "acctestvnet-%d" +// address_space = ["10.0.0.0/16"] +// location = "${azurerm_resource_group.test.location}" +// resource_group_name = "${azurerm_resource_group.test.name}" +// dns_servers = ["10.0.0.10","10.0.0.11"] +// } + +// data "azurerm_vnet" "test" { +// resource_group_name = "${azurerm_resource_group.test.name}" +// name = "${azurerm_virtual_network.test.name}" +// dns_servers = "${azurerm_virtual_network.test.dns_servers}" +// } + +// `, rInt, location, rInt) +// } diff --git a/azurerm/provider.go b/azurerm/provider.go index 8bf452d849a3..6ef55769d068 100644 --- a/azurerm/provider.go +++ b/azurerm/provider.go @@ -80,6 +80,7 @@ func Provider() terraform.ResourceProvider { "azurerm_snapshot": dataSourceArmSnapshot(), "azurerm_subnet": dataSourceArmSubnet(), "azurerm_subscription": dataSourceArmSubscription(), + "azurerm_vnet": dataSourceArmVnet(), }, ResourcesMap: map[string]*schema.Resource{ From d3072dd81dc77a2b0aad17609792bbbb834b9624 Mon Sep 17 00:00:00 2001 From: Henry Buckle Date: Wed, 1 Nov 2017 09:15:14 +0000 Subject: [PATCH 03/55] add identity property to vm --- azurerm/resource_arm_virtual_machine.go | 43 +++++++++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/azurerm/resource_arm_virtual_machine.go b/azurerm/resource_arm_virtual_machine.go index 3cb883856a92..574ae4132a7d 100644 --- a/azurerm/resource_arm_virtual_machine.go +++ b/azurerm/resource_arm_virtual_machine.go @@ -71,6 +71,25 @@ func resourceArmVirtualMachine() *schema.Resource { }, }, + "identity": { + Type: schema.TypeSet, + Optional: true, + Computed: true, + MaxItems: 1, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "type": { + Type: schema.TypeString, + Optional: true, + }, + "principal_id": { + Type: schema.TypeString, + Computed: true, + }, + }, + }, + }, + "license_type": { Type: schema.TypeString, Optional: true, @@ -589,6 +608,16 @@ func resourceArmVirtualMachineCreate(d *schema.ResourceData, meta interface{}) e Tags: expandedTags, } + if v, ok := d.GetOk("identity"); ok { + identities := v.(*schema.Set).List() + identity := identities[0].(map[string]interface{}) + identityType := identity["type"].(string) + vmIdentity := compute.VirtualMachineIdentity{ + Type: compute.ResourceIdentityType(identityType), + } + vm.Identity = &vmIdentity + } + if _, ok := d.GetOk("plan"); ok { plan, err := expandAzureRmVirtualMachinePlan(d) if err != nil { @@ -647,6 +676,10 @@ func resourceArmVirtualMachineRead(d *schema.ResourceData, meta interface{}) err } } + if resp.Identity != nil { + d.Set("identity", flattenAzureRmVirtualMachineIdentity(resp.Identity)) + } + if resp.VirtualMachineProperties.AvailabilitySet != nil { d.Set("availability_set_id", strings.ToLower(*resp.VirtualMachineProperties.AvailabilitySet.ID)) } @@ -875,6 +908,16 @@ func flattenAzureRmVirtualMachineImageReference(image *compute.ImageReference) [ return []interface{}{result} } +func flattenAzureRmVirtualMachineIdentity(identity *compute.VirtualMachineIdentity) []interface{} { + result := make(map[string]interface{}) + result["type"] = string(identity.Type) + if identity.PrincipalID != nil { + result["principal_id"] = *identity.PrincipalID + } + + return []interface{}{result} +} + func flattenAzureRmVirtualMachineDiagnosticsProfile(profile *compute.BootDiagnostics) []interface{} { result := make(map[string]interface{}) From e363abd11e14753cdb4a8df79005e21b2a2bb6c7 Mon Sep 17 00:00:00 2001 From: Henry Buckle Date: Wed, 1 Nov 2017 21:15:26 +0000 Subject: [PATCH 04/55] refactor, tests and docs --- azurerm/resource_arm_virtual_machine.go | 25 +++-- ..._arm_virtual_machine_managed_disks_test.go | 104 ++++++++++++++++++ website/docs/r/virtual_machine.html.markdown | 31 ++++++ 3 files changed, 150 insertions(+), 10 deletions(-) diff --git a/azurerm/resource_arm_virtual_machine.go b/azurerm/resource_arm_virtual_machine.go index 574ae4132a7d..59f68fd8603a 100644 --- a/azurerm/resource_arm_virtual_machine.go +++ b/azurerm/resource_arm_virtual_machine.go @@ -72,7 +72,7 @@ func resourceArmVirtualMachine() *schema.Resource { }, "identity": { - Type: schema.TypeSet, + Type: schema.TypeList, Optional: true, Computed: true, MaxItems: 1, @@ -80,7 +80,7 @@ func resourceArmVirtualMachine() *schema.Resource { Schema: map[string]*schema.Schema{ "type": { Type: schema.TypeString, - Optional: true, + Required: true, }, "principal_id": { Type: schema.TypeString, @@ -608,14 +608,9 @@ func resourceArmVirtualMachineCreate(d *schema.ResourceData, meta interface{}) e Tags: expandedTags, } - if v, ok := d.GetOk("identity"); ok { - identities := v.(*schema.Set).List() - identity := identities[0].(map[string]interface{}) - identityType := identity["type"].(string) - vmIdentity := compute.VirtualMachineIdentity{ - Type: compute.ResourceIdentityType(identityType), - } - vm.Identity = &vmIdentity + if _, ok := d.GetOk("identity"); ok { + vmIdentity := expandAzureRmVirtualMachineIdentity(d) + vm.Identity = vmIdentity } if _, ok := d.GetOk("plan"); ok { @@ -1110,6 +1105,16 @@ func expandAzureRmVirtualMachinePlan(d *schema.ResourceData) (*compute.Plan, err }, nil } +func expandAzureRmVirtualMachineIdentity(d *schema.ResourceData) *compute.VirtualMachineIdentity { + v := d.Get("identity") + identities := v.([]interface{}) + identity := identities[0].(map[string]interface{}) + identityType := identity["type"].(string) + return &compute.VirtualMachineIdentity{ + Type: compute.ResourceIdentityType(identityType), + } +} + func expandAzureRmVirtualMachineOsProfile(d *schema.ResourceData) (*compute.OSProfile, error) { osProfiles := d.Get("os_profile").(*schema.Set).List() diff --git a/azurerm/resource_arm_virtual_machine_managed_disks_test.go b/azurerm/resource_arm_virtual_machine_managed_disks_test.go index b9cbb0679ca2..04e76c25a218 100644 --- a/azurerm/resource_arm_virtual_machine_managed_disks_test.go +++ b/azurerm/resource_arm_virtual_machine_managed_disks_test.go @@ -317,6 +317,110 @@ func TestAccAzureRMVirtualMachine_multipleNICs(t *testing.T) { }) } +func TestAccAzureRMVirtualMachine_managedServiceIdentity(t *testing.T) { + var vm compute.VirtualMachine + match := regexp.MustCompile("^(\\{{0,1}([0-9a-fA-F]){8}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){12}\\}{0,1})$") + resourceName := "azurerm_virtual_machine.test" + ri := acctest.RandInt() + config := testAccAzureRMVirtualMachine_withManagedServiceIdentity(ri, testLocation()) + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMVirtualMachineDestroy, + Steps: []resource.TestStep{ + { + Config: config, + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMVirtualMachineExists(resourceName, &vm), + resource.TestCheckResourceAttr(resourceName, "identity.0.type", "SystemAssigned"), + resource.TestMatchResourceAttr(resourceName, "identity.0.principal_id", match), + resource.TestMatchOutput("principal_id", match), + ), + }, + }, + }) +} + +func testAccAzureRMVirtualMachine_withManagedServiceIdentity(rInt int, location string) string { + return fmt.Sprintf(` +resource "azurerm_resource_group" "test" { + name = "acctestRG-%d" + location = "%s" +} + +resource "azurerm_virtual_network" "test" { + name = "acctvn-%d" + address_space = ["10.0.0.0/16"] + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" +} + +resource "azurerm_subnet" "test" { + name = "acctsub-%d" + resource_group_name = "${azurerm_resource_group.test.name}" + virtual_network_name = "${azurerm_virtual_network.test.name}" + address_prefix = "10.0.2.0/24" +} + +resource "azurerm_network_interface" "test" { + name = "acctni-%d" + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" + + ip_configuration { + name = "testconfiguration1" + subnet_id = "${azurerm_subnet.test.id}" + private_ip_address_allocation = "dynamic" + } +} + +resource "azurerm_virtual_machine" "test" { + name = "acctvm-%d" + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" + network_interface_ids = ["${azurerm_network_interface.test.id}"] + vm_size = "Standard_D1_v2" + + identity = { + type = "SystemAssigned" + } + + storage_image_reference { + publisher = "Canonical" + offer = "UbuntuServer" + sku = "16.04-LTS" + version = "latest" + } + + storage_os_disk { + name = "osd-%d" + caching = "ReadWrite" + create_option = "FromImage" + disk_size_gb = "50" + managed_disk_type = "Standard_LRS" + } + + os_profile { + computer_name = "hn%d" + admin_username = "testadmin" + admin_password = "Password1234!" + } + + os_profile_linux_config { + disable_password_authentication = false + } + + tags { + environment = "Production" + cost-center = "Ops" + } +} +output "principal_id" { + value = "${lookup(azurerm_virtual_machine.test.identity[0], "principal_id")}" +} +`, rInt, location, rInt, rInt, rInt, rInt, rInt, rInt) +} + func testAccAzureRMVirtualMachine_basicLinuxMachine_managedDisk_explicit(rInt int, location string) string { return fmt.Sprintf(` resource "azurerm_resource_group" "test" { diff --git a/website/docs/r/virtual_machine.html.markdown b/website/docs/r/virtual_machine.html.markdown index fa0104dfc2e5..fe6c21546092 100644 --- a/website/docs/r/virtual_machine.html.markdown +++ b/website/docs/r/virtual_machine.html.markdown @@ -237,6 +237,7 @@ The following arguments are supported: * `storage_data_disk` - (Optional) A list of Storage Data disk blocks as referenced below. * `delete_data_disks_on_termination` - (Optional) Flag to enable deletion of storage data disk VHD blobs or managed disks when the VM is deleted, defaults to `false` * `os_profile` - (Optional) An OS Profile block as documented below. Required when `create_option` in the `storage_os_disk` block is set to `FromImage`. +* `identity` - (Optional) An identity block as documented below. * `license_type` - (Optional, when a Windows machine) Specifies the Windows OS license type. The only allowable value, if supplied, is `Windows_Server`. * `os_profile_windows_config` - (Required, when a Windows machine) A Windows config block as documented below. @@ -323,6 +324,36 @@ resource "azurerm_virtual_machine" "test" { 3. Contains a numeric digit 4. Contains a special character +`identity` supports the following: + +* `type` - (Required) Specifies the identity type of the virtual machine. The only allowable value is `SystemAssigned`. To enable Managed Service Identity the ManagedIdentityExtension must also be added to the virtual machine. The Principal ID can be retrieved after the virtual machine has been created, e.g. + +```hcl +resource "azurerm_virtual_machine" "test" { + name = "test" + + identity = { + type = "SystemAssigned" + } +} +resource "azurerm_virtual_machine_extension" "test" { + name = "test" + virtual_machine_name = "${azurerm_virtual_machine.test.name}" + publisher = "Microsoft.ManagedIdentity" + type = "ManagedIdentityExtensionForWindows" + type_handler_version = "1.0" + + settings = < Date: Wed, 1 Nov 2017 14:52:43 -0700 Subject: [PATCH 05/55] added vnet_peering --- azurerm/data_source_vnet.go | 34 +++++++-- azurerm/data_source_vnet_test.go | 120 +++++++++++++++++-------------- 2 files changed, 96 insertions(+), 58 deletions(-) diff --git a/azurerm/data_source_vnet.go b/azurerm/data_source_vnet.go index 4b480d407491..bdbf358f2dbf 100644 --- a/azurerm/data_source_vnet.go +++ b/azurerm/data_source_vnet.go @@ -43,6 +43,17 @@ func dataSourceArmVnet() *schema.Resource { Type: schema.TypeString, }, }, + + "vnet_peerings": { + Type: schema.TypeList, + Computed: true, + Elem: &schema.Schema{ + Type: schema.TypeList, + Elem: &schema.Schema{ + Type: schema.TypeString, + }, + }, + }, }, } } @@ -58,7 +69,7 @@ func dataSourceArmVnetRead(d *schema.ResourceData, meta interface{}) error { if resp.StatusCode == http.StatusNotFound { d.SetId("") } - return fmt.Errorf("Error making Read request on Azure public ip %s: %s", name, err) + return fmt.Errorf("Error making Read request on Azure virtual network %s: %s", name, err) } d.SetId(*resp.ID) @@ -74,12 +85,16 @@ func dataSourceArmVnetRead(d *schema.ResourceData, meta interface{}) error { return err } - subnets := flattenVnetSubnetsAddressSpace(props.Subnets) + subnets := flattenVnetSubnetsNames(props.Subnets) if err := d.Set("subnets", subnets); err != nil { return err } - } + vnet_peerings := flattenVnetPeerings(props.VirtualNetworkPeerings) + if err := d.Set("vnet_peerings", vnet_peerings); err != nil { + return err + } + } return nil } @@ -89,16 +104,23 @@ func flattenVnetAddressPrefixes(input *[]string) []interface{} { for _, prefix := range *input { prefixes = append(prefixes, prefix) } - return prefixes } -func flattenVnetSubnetsAddressSpace(input *[]network.Subnet) []interface{} { +func flattenVnetSubnetsNames(input *[]network.Subnet) []interface{} { subnets := make([]interface{}, 0) for _, subnet := range *input { subnets = append(subnets, *subnet.Name) } - return subnets } + +func flattenVnetPeerings(input *[]network.VirtualNetworkPeering) []interface{} { + vnetpeerings := make([]interface{}, 0) + + for _, vnetpeering := range *input { + vnetpeerings = append(vnetpeerings, []string{*vnetpeering.Name, *vnetpeering.RemoteVirtualNetwork.ID}) + } + return vnetpeerings +} diff --git a/azurerm/data_source_vnet_test.go b/azurerm/data_source_vnet_test.go index f4a7406b02a9..afaef34e675a 100644 --- a/azurerm/data_source_vnet_test.go +++ b/azurerm/data_source_vnet_test.go @@ -16,46 +16,46 @@ func TestAccDataSourceAzureRMVnet_basic(t *testing.T) { config := testAccDataSourceAzureRMVnet_basic(ri, testLocation()) resource.Test(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, - Providers: testAccProviders, - CheckDestroy: testCheckAzureRMVirtualNetworkDestroy, + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, Steps: []resource.TestStep{ { Config: config, Check: resource.ComposeTestCheckFunc( resource.TestCheckResourceAttr(dataSourceName, "name", name), - resource.TestCheckResourceAttr(dataSourceName, "dns_servers.0", "10.0.0.10"), + resource.TestCheckResourceAttr(dataSourceName, "dns_servers.0", "10.0.0.4"), resource.TestCheckResourceAttr(dataSourceName, "address_spaces.0", "10.0.0.0/16"), + resource.TestCheckResourceAttr(dataSourceName, "subnets.0", "subnet1"), ), }, }, }) } -// func TestAccDataSourceAzureRMVnet_Subnets(t *testing.T) { -// dataSourceName := "data.azurerm_vnet.test" -// ri := acctest.RandInt() - -// name := fmt.Sprintf("acctestvnet-%d", ri) -// //resourceGroupName := fmt.Sprintf("acctestRG-%d", ri) - -// config := testAccDataSourceAzureRMVnet_basic(ri, testLocation()) - -// resource.Test(t, resource.TestCase{ -// PreCheck: func() { testAccPreCheck(t) }, -// Providers: testAccProviders, -// CheckDestroy: testCheckAzureRMPublicIpDestroy, -// Steps: []resource.TestStep{ -// { -// Config: config, -// Check: resource.ComposeTestCheckFunc( -// resource.TestCheckResourceAttr(dataSourceName, "name", name), -// resource.TestCheckResourceAttr(dataSourceName, "dns_servers", `["10.0.0.10","10.0.0.11"]`), -// ), -// }, -// }, -// }) -// } +func TestAccDataSourceAzureRMVnet_peering(t *testing.T) { + firstDataSourceName := "data.azurerm_vnet.test" + ri := acctest.RandInt() + + name_vnet_1 := fmt.Sprintf("acctestvnet-1-%d", ri) + //name_peer := fmt.Sprintf("acctestpeer-1-%d", ri) + config := testAccDataSourceAzureRMVnet_peering(ri, testLocation()) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + Steps: []resource.TestStep{ + { + Config: config, + Check: resource.ComposeTestCheckFunc( + resource.TestCheckResourceAttr(firstDataSourceName, "name", name_vnet_1), + resource.TestCheckResourceAttr(firstDataSourceName, "address_spaces.0", "10.0.1.0/24"), + resource.TestCheckResourceAttr(firstDataSourceName, "vnet_peerings.#", "1"), + //resource.TestCheckResourceAttr(firstDataSourceName, "vnet_peerings.0.0", "peer-1to2"), + ), + }, + }, + }) +} func testAccDataSourceAzureRMVnet_basic(rInt int, location string) string { return fmt.Sprintf(` @@ -69,7 +69,12 @@ func testAccDataSourceAzureRMVnet_basic(rInt int, location string) string { address_space = ["10.0.0.0/16"] location = "${azurerm_resource_group.test.location}" resource_group_name = "${azurerm_resource_group.test.name}" - dns_servers = ["10.0.0.10"] + dns_servers = ["10.0.0.4"] + + subnet { + name = "subnet1" + address_prefix = "10.0.1.0/24" + } } data "azurerm_vnet" "test" { @@ -80,26 +85,37 @@ func testAccDataSourceAzureRMVnet_basic(rInt int, location string) string { `, rInt, location, rInt) } -// func testAccDataSourceAzureRMVnet_Subnets(rInt int, location string) string { -// return fmt.Sprintf(` -// resource "azurerm_resource_group" "test" { -// name = "acctest%d-rg" -// location = "%s" -// } - -// resource "azurerm_virtual_network" "test" { -// name = "acctestvnet-%d" -// address_space = ["10.0.0.0/16"] -// location = "${azurerm_resource_group.test.location}" -// resource_group_name = "${azurerm_resource_group.test.name}" -// dns_servers = ["10.0.0.10","10.0.0.11"] -// } - -// data "azurerm_vnet" "test" { -// resource_group_name = "${azurerm_resource_group.test.name}" -// name = "${azurerm_virtual_network.test.name}" -// dns_servers = "${azurerm_virtual_network.test.dns_servers}" -// } - -// `, rInt, location, rInt) -// } +func testAccDataSourceAzureRMVnet_peering(rInt int, location string) string { + return fmt.Sprintf(` + resource "azurerm_resource_group" "test" { + name = "acctest%d-rg" + location = "%s" + } + + resource "azurerm_virtual_network" "test1" { + name = "acctestvnet-1-%d" + address_space = ["10.0.1.0/24"] + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" + } + + resource "azurerm_virtual_network" "test2" { + name = "acctestvnet-2-%d" + address_space = ["10.0.2.0/24"] + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" + } + + resource "azurerm_virtual_network_peering" "test1" { + name = "peer-1to2" + resource_group_name = "${azurerm_resource_group.test.name}" + virtual_network_name = "${azurerm_virtual_network.test1.name}" + remote_virtual_network_id = "${azurerm_virtual_network.test2.id}" + } + + data "azurerm_vnet" "test" { + resource_group_name = "${azurerm_resource_group.test.name}" + name = "${azurerm_virtual_network.test1.name}" + } + `, rInt, location, rInt, rInt) +} From 054102aa26f04a9fcb72c1fc9c04a32870ea8acc Mon Sep 17 00:00:00 2001 From: Damien Caro Date: Thu, 2 Nov 2017 16:42:19 -0700 Subject: [PATCH 06/55] changing to TypeMap --- azurerm/data_source_vnet.go | 25 +++++++++++++------------ azurerm/data_source_vnet_test.go | 10 ++++------ 2 files changed, 17 insertions(+), 18 deletions(-) diff --git a/azurerm/data_source_vnet.go b/azurerm/data_source_vnet.go index bdbf358f2dbf..2e94ce5a52c8 100644 --- a/azurerm/data_source_vnet.go +++ b/azurerm/data_source_vnet.go @@ -18,7 +18,10 @@ func dataSourceArmVnet() *schema.Resource { Required: true, }, - "resource_group_name": resourceGroupNameForDataSourceSchema(), + "resource_group_name": { + Type: schema.TypeString, + Required: true, + }, "address_spaces": { Type: schema.TypeList, @@ -45,14 +48,8 @@ func dataSourceArmVnet() *schema.Resource { }, "vnet_peerings": { - Type: schema.TypeList, + Type: schema.TypeMap, Computed: true, - Elem: &schema.Schema{ - Type: schema.TypeList, - Elem: &schema.Schema{ - Type: schema.TypeString, - }, - }, }, }, } @@ -116,11 +113,15 @@ func flattenVnetSubnetsNames(input *[]network.Subnet) []interface{} { return subnets } -func flattenVnetPeerings(input *[]network.VirtualNetworkPeering) []interface{} { - vnetpeerings := make([]interface{}, 0) +func flattenVnetPeerings(input *[]network.VirtualNetworkPeering) map[string]interface{} { + output := make(map[string]interface{}, 0) for _, vnetpeering := range *input { - vnetpeerings = append(vnetpeerings, []string{*vnetpeering.Name, *vnetpeering.RemoteVirtualNetwork.ID}) + key := *vnetpeering.Name + value := *vnetpeering.RemoteVirtualNetwork.ID + + output[key] = value + } - return vnetpeerings + return output } diff --git a/azurerm/data_source_vnet_test.go b/azurerm/data_source_vnet_test.go index afaef34e675a..2c568b93814e 100644 --- a/azurerm/data_source_vnet_test.go +++ b/azurerm/data_source_vnet_test.go @@ -33,11 +33,10 @@ func TestAccDataSourceAzureRMVnet_basic(t *testing.T) { } func TestAccDataSourceAzureRMVnet_peering(t *testing.T) { - firstDataSourceName := "data.azurerm_vnet.test" + dataSourceName := "data.azurerm_vnet.test" ri := acctest.RandInt() name_vnet_1 := fmt.Sprintf("acctestvnet-1-%d", ri) - //name_peer := fmt.Sprintf("acctestpeer-1-%d", ri) config := testAccDataSourceAzureRMVnet_peering(ri, testLocation()) resource.Test(t, resource.TestCase{ @@ -47,10 +46,9 @@ func TestAccDataSourceAzureRMVnet_peering(t *testing.T) { { Config: config, Check: resource.ComposeTestCheckFunc( - resource.TestCheckResourceAttr(firstDataSourceName, "name", name_vnet_1), - resource.TestCheckResourceAttr(firstDataSourceName, "address_spaces.0", "10.0.1.0/24"), - resource.TestCheckResourceAttr(firstDataSourceName, "vnet_peerings.#", "1"), - //resource.TestCheckResourceAttr(firstDataSourceName, "vnet_peerings.0.0", "peer-1to2"), + resource.TestCheckResourceAttr(dataSourceName, "name", name_vnet_1), + resource.TestCheckResourceAttr(dataSourceName, "address_spaces.0", "10.0.1.0/24"), + resource.TestCheckResourceAttr(dataSourceName, "vnet_peerings.%", "1"), ), }, }, From 5c16837a8df65cc7a18937fcebab6c1ef01cb66b Mon Sep 17 00:00:00 2001 From: Tom Harvey Date: Sat, 4 Nov 2017 13:49:39 +0000 Subject: [PATCH 07/55] Updating the Provider block --- examples/app-service-asp-net/app.tf | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/examples/app-service-asp-net/app.tf b/examples/app-service-asp-net/app.tf index f22515c6dcd2..1ba51ae510fd 100644 --- a/examples/app-service-asp-net/app.tf +++ b/examples/app-service-asp-net/app.tf @@ -1,13 +1,14 @@ # Configure the Microsoft Azure Provider provider "azurerm" { - subscription_id = "${var.subscription_id}" - client_id = "${var.client_id}" - client_secret = "${var.client_secret}" - tenant_id = "${var.tenant_id}" + # if you're using a Service Principal (shared account) then either set the environment variables, or fill these in: + # subscription_id = "..." + # client_id = "..." + # client_secret = "..." + # tenant_id = "..." } resource "azurerm_resource_group" "g1" { - name = "{$var.groupName}" + name = "${var.resource_group_name}" location = "${var.location}" } @@ -25,7 +26,7 @@ resource "azurerm_app_service_plan" "plan0" { # underscores not supported as app_service name -> if not: you will receive error 400 resource "azurerm_app_service" "common_service" { - name = "${var.webName}" + name = "${var.app_service_name}" location = "${var.location}" resource_group_name = "${azurerm_resource_group.g1.name}" app_service_plan_id = "${azurerm_app_service_plan.plan0.id}" @@ -56,10 +57,10 @@ output "service" { value = "${azurerm_app_service.common_service.name}" } -output "serviceUrl" { +output "service_url" { value = "https://${azurerm_app_service.common_service.name}.azurewebsites.net" } -output "adminUrl" { +output "admin_url" { value = "https://${azurerm_app_service.common_service.name}.scm.azurewebsites.net" } From 65805ab297a5057f70eb30891be12bc097c9a50f Mon Sep 17 00:00:00 2001 From: Tom Harvey Date: Sat, 4 Nov 2017 13:50:21 +0000 Subject: [PATCH 08/55] Variable consistency and removing unused variables --- examples/app-service-asp-net/variables.tf | 20 ++------------------ 1 file changed, 2 insertions(+), 18 deletions(-) diff --git a/examples/app-service-asp-net/variables.tf b/examples/app-service-asp-net/variables.tf index be7ddb061782..78abf98e6a59 100644 --- a/examples/app-service-asp-net/variables.tf +++ b/examples/app-service-asp-net/variables.tf @@ -1,4 +1,4 @@ -variable "groupName" { +variable "resource_group_name" { type = "string" default = "yourGroupName" } @@ -8,29 +8,13 @@ variable "location" { default = "westeurope" } -variable "webName" { +variable "app_service_name" { type = "string" # will create -> mySite123456.azurewebsites.net #should be unique # default = "mySite123456" } -variable "subscription_id" { - type = "string" -} - -variable "client_id" { - type = "string" -} - -variable "client_secret" { - type = "string" -} - -variable "tenant_id" { - type = "string" -} - variable "deploy_user" { type = "string" } From c32a560ca8d20a18b68d792fcea7eb67616d0491 Mon Sep 17 00:00:00 2001 From: Damien Caro Date: Wed, 15 Nov 2017 00:25:06 -0600 Subject: [PATCH 09/55] Changed to azure_virtual_network, added crash control and added documentation. --- ...vnet.go => data_source_virtual_network.go} | 33 ++++++++++------- ...go => data_source_virtual_network_test.go} | 20 +++++----- azurerm/provider.go | 2 +- website/docs/d/virtual_network.html.markdown | 37 +++++++++++++++++++ 4 files changed, 67 insertions(+), 25 deletions(-) rename azurerm/{data_source_vnet.go => data_source_virtual_network.go} (75%) rename azurerm/{data_source_vnet_test.go => data_source_virtual_network_test.go} (82%) create mode 100644 website/docs/d/virtual_network.html.markdown diff --git a/azurerm/data_source_vnet.go b/azurerm/data_source_virtual_network.go similarity index 75% rename from azurerm/data_source_vnet.go rename to azurerm/data_source_virtual_network.go index 2e94ce5a52c8..8fa68d5061b9 100644 --- a/azurerm/data_source_vnet.go +++ b/azurerm/data_source_virtual_network.go @@ -2,14 +2,13 @@ package azurerm import ( "fmt" - "net/http" "github.com/Azure/azure-sdk-for-go/arm/network" "github.com/hashicorp/terraform/helper/schema" - //"github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" ) -func dataSourceArmVnet() *schema.Resource { +func dataSourceArmVirtualNetwork() *schema.Resource { return &schema.Resource{ Read: dataSourceArmVnetRead, Schema: map[string]*schema.Schema{ @@ -63,10 +62,10 @@ func dataSourceArmVnetRead(d *schema.ResourceData, meta interface{}) error { resp, err := vnetClient.Get(resGroup, name, "") if err != nil { - if resp.StatusCode == http.StatusNotFound { - d.SetId("") + if utils.ResponseWasNotFound(resp.Response) { + return fmt.Errorf("Error making Read request on Azure virtual network %s: %+v", name, err) } - return fmt.Errorf("Error making Read request on Azure virtual network %s: %s", name, err) + return err } d.SetId(*resp.ID) @@ -98,8 +97,10 @@ func dataSourceArmVnetRead(d *schema.ResourceData, meta interface{}) error { func flattenVnetAddressPrefixes(input *[]string) []interface{} { prefixes := make([]interface{}, 0) - for _, prefix := range *input { - prefixes = append(prefixes, prefix) + if myprefixes := input; myprefixes != nil { + for _, prefix := range *myprefixes { + prefixes = append(prefixes, prefix) + } } return prefixes } @@ -107,8 +108,10 @@ func flattenVnetAddressPrefixes(input *[]string) []interface{} { func flattenVnetSubnetsNames(input *[]network.Subnet) []interface{} { subnets := make([]interface{}, 0) - for _, subnet := range *input { - subnets = append(subnets, *subnet.Name) + if mysubnets := input; mysubnets != nil { + for _, subnet := range *mysubnets { + subnets = append(subnets, *subnet.Name) + } } return subnets } @@ -116,12 +119,14 @@ func flattenVnetSubnetsNames(input *[]network.Subnet) []interface{} { func flattenVnetPeerings(input *[]network.VirtualNetworkPeering) map[string]interface{} { output := make(map[string]interface{}, 0) - for _, vnetpeering := range *input { - key := *vnetpeering.Name - value := *vnetpeering.RemoteVirtualNetwork.ID + if peerings := input; peerings != nil { + for _, vnetpeering := range *peerings { + key := *vnetpeering.Name + value := *vnetpeering.RemoteVirtualNetwork.ID - output[key] = value + output[key] = value + } } return output } diff --git a/azurerm/data_source_vnet_test.go b/azurerm/data_source_virtual_network_test.go similarity index 82% rename from azurerm/data_source_vnet_test.go rename to azurerm/data_source_virtual_network_test.go index 2c568b93814e..e218579f87f3 100644 --- a/azurerm/data_source_vnet_test.go +++ b/azurerm/data_source_virtual_network_test.go @@ -8,12 +8,12 @@ import ( "github.com/hashicorp/terraform/helper/resource" ) -func TestAccDataSourceAzureRMVnet_basic(t *testing.T) { - dataSourceName := "data.azurerm_vnet.test" +func TestAccDataSourceArmVirtualNetwork_basic(t *testing.T) { + dataSourceName := "data.azurerm_virtual_network.test" ri := acctest.RandInt() name := fmt.Sprintf("acctestvnet-%d", ri) - config := testAccDataSourceAzureRMVnet_basic(ri, testLocation()) + config := testAccDataSourceArmVirtualNetwork_basic(ri, testLocation()) resource.Test(t, resource.TestCase{ PreCheck: func() { testAccPreCheck(t) }, @@ -32,12 +32,12 @@ func TestAccDataSourceAzureRMVnet_basic(t *testing.T) { }) } -func TestAccDataSourceAzureRMVnet_peering(t *testing.T) { - dataSourceName := "data.azurerm_vnet.test" +func TestAccDataSourceArmVirtualNetwork_peering(t *testing.T) { + dataSourceName := "data.azurerm_virtual_network.test" ri := acctest.RandInt() name_vnet_1 := fmt.Sprintf("acctestvnet-1-%d", ri) - config := testAccDataSourceAzureRMVnet_peering(ri, testLocation()) + config := testAccDataSourceArmVirtualNetwork_peering(ri, testLocation()) resource.Test(t, resource.TestCase{ PreCheck: func() { testAccPreCheck(t) }, @@ -55,7 +55,7 @@ func TestAccDataSourceAzureRMVnet_peering(t *testing.T) { }) } -func testAccDataSourceAzureRMVnet_basic(rInt int, location string) string { +func testAccDataSourceArmVirtualNetwork_basic(rInt int, location string) string { return fmt.Sprintf(` resource "azurerm_resource_group" "test" { name = "acctest%d-rg" @@ -75,7 +75,7 @@ func testAccDataSourceAzureRMVnet_basic(rInt int, location string) string { } } - data "azurerm_vnet" "test" { + data "azurerm_virtual_network" "test" { resource_group_name = "${azurerm_resource_group.test.name}" name = "${azurerm_virtual_network.test.name}" } @@ -83,7 +83,7 @@ func testAccDataSourceAzureRMVnet_basic(rInt int, location string) string { `, rInt, location, rInt) } -func testAccDataSourceAzureRMVnet_peering(rInt int, location string) string { +func testAccDataSourceArmVirtualNetwork_peering(rInt int, location string) string { return fmt.Sprintf(` resource "azurerm_resource_group" "test" { name = "acctest%d-rg" @@ -111,7 +111,7 @@ func testAccDataSourceAzureRMVnet_peering(rInt int, location string) string { remote_virtual_network_id = "${azurerm_virtual_network.test2.id}" } - data "azurerm_vnet" "test" { + data "azurerm_virtual_network" "test" { resource_group_name = "${azurerm_resource_group.test.name}" name = "${azurerm_virtual_network.test1.name}" } diff --git a/azurerm/provider.go b/azurerm/provider.go index 6ef55769d068..a81a0ae5b763 100644 --- a/azurerm/provider.go +++ b/azurerm/provider.go @@ -80,7 +80,7 @@ func Provider() terraform.ResourceProvider { "azurerm_snapshot": dataSourceArmSnapshot(), "azurerm_subnet": dataSourceArmSubnet(), "azurerm_subscription": dataSourceArmSubscription(), - "azurerm_vnet": dataSourceArmVnet(), + "azurerm_virtual_network": dataSourceArmVirtualNetwork(), }, ResourcesMap: map[string]*schema.Resource{ diff --git a/website/docs/d/virtual_network.html.markdown b/website/docs/d/virtual_network.html.markdown new file mode 100644 index 000000000000..72a0d147df31 --- /dev/null +++ b/website/docs/d/virtual_network.html.markdown @@ -0,0 +1,37 @@ +--- +layout: "azurerm" +page_title: "Azure Resource Manager: azurerm_virtual_network" +sidebar_current: "docs-azurerm-datasource-virtual-network" +description: |- + Get information about the specified Virtual Network. +--- + +# azurerm_virtual_network + +Use this data source to access the properties of an Azure Virtual Network. + +## Example Usage + +```hcl +data "azurerm_virtual_network" "test" { + name = "production" + resource_group_name = "networking" +} + +output "virtual_network_id" { + value = "${data.azurerm_virtual_network.test.id}" +} +``` + +## Argument Reference + +* `name` - (Required) Specifies the name of the Virtual Network. +* `resource_group_name` - (Required) Specifies the name of the resource group the Virtual Network is located in. + +## Attributes Reference + +* `id` - The ID of the virtual network. +* `address_spaces` - The list of address spaces used by the virtual network. +* `dns_servers` - The list of DNS servers used by the virtual network. +* `subnets` - The list of name of the subnets that are attached to this virtual network. +* `vnet_peerings` - A mapping of name - virtual network id of the virtual network peerings. From 8a6346ce5e122fdcd18ab4e47415d27d21912c86 Mon Sep 17 00:00:00 2001 From: tombuildsstuff Date: Tue, 14 Nov 2017 16:09:31 +0000 Subject: [PATCH 10/55] vmss: Support for updating the customData field Fixes #61 Fixes #490 --- ...port_arm_virtual_machine_scale_set_test.go | 43 ++++-- azurerm/provider.go | 5 + .../resource_arm_virtual_machine_scale_set.go | 45 +++--- ...urce_arm_virtual_machine_scale_set_test.go | 128 ++++++++++++++++++ .../r/virtual_machine_scale_set.html.markdown | 2 +- 5 files changed, 189 insertions(+), 34 deletions(-) diff --git a/azurerm/import_arm_virtual_machine_scale_set_test.go b/azurerm/import_arm_virtual_machine_scale_set_test.go index 71faf5758c8c..edc88a94b915 100644 --- a/azurerm/import_arm_virtual_machine_scale_set_test.go +++ b/azurerm/import_arm_virtual_machine_scale_set_test.go @@ -22,9 +22,10 @@ func TestAccAzureRMVirtualMachineScaleSet_importBasic(t *testing.T) { Config: config, }, { - ResourceName: resourceName, - ImportState: true, - ImportStateVerify: true, + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"os_profile.0.admin_password"}, }, }, }) @@ -45,9 +46,10 @@ func TestAccAzureRMVirtualMachineScaleSet_importBasic_managedDisk(t *testing.T) Config: config, }, { - ResourceName: resourceName, - ImportState: true, - ImportStateVerify: true, + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"os_profile.0.admin_password"}, }, }, }) @@ -71,6 +73,10 @@ func TestAccAzureRMVirtualMachineScaleSet_importLinux(t *testing.T) { ResourceName: resourceName, ImportState: true, ImportStateVerify: true, + ImportStateVerifyIgnore: []string{ + "os_profile.0.admin_password", + "os_profile.0.custom_data", + }, }, }, }) @@ -91,9 +97,10 @@ func TestAccAzureRMVirtualMachineScaleSet_importLoadBalancer(t *testing.T) { Config: config, }, { - ResourceName: resourceName, - ImportState: true, - ImportStateVerify: true, + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"os_profile.0.admin_password"}, }, }, }) @@ -116,6 +123,12 @@ func TestAccAzureRMVirtualMachineScaleSet_importOverProvision(t *testing.T) { testCheckAzureRMVirtualMachineScaleSetOverprovision(resourceName), ), }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"os_profile.0.admin_password"}, + }, }, }) } @@ -137,6 +150,12 @@ func TestAccAzureRMVirtualMachineScaleSet_importExtension(t *testing.T) { testCheckAzureRMVirtualMachineScaleSetExtension(resourceName), ), }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"os_profile.0.admin_password"}, + }, }, }) } @@ -158,6 +177,12 @@ func TestAccAzureRMVirtualMachineScaleSet_importMultipleExtensions(t *testing.T) testCheckAzureRMVirtualMachineScaleSetExtension(resourceName), ), }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"os_profile.0.admin_password"}, + }, }, }) } diff --git a/azurerm/provider.go b/azurerm/provider.go index eb73ea196a4e..5f7dfea31866 100644 --- a/azurerm/provider.go +++ b/azurerm/provider.go @@ -494,6 +494,11 @@ func ignoreCaseStateFunc(val interface{}) string { return strings.ToLower(val.(string)) } +func userDataDiffSuppressFunc(k, old, new string, d *schema.ResourceData) bool { + oldValue := userDataStateFunc(old) + return oldValue == new +} + func userDataStateFunc(v interface{}) string { switch s := v.(type) { case string: diff --git a/azurerm/resource_arm_virtual_machine_scale_set.go b/azurerm/resource_arm_virtual_machine_scale_set.go index daf71d642c19..e4c7a35a98c1 100644 --- a/azurerm/resource_arm_virtual_machine_scale_set.go +++ b/azurerm/resource_arm_virtual_machine_scale_set.go @@ -80,7 +80,7 @@ func resourceArmVirtualMachineScaleSet() *schema.Resource { }, "os_profile": { - Type: schema.TypeSet, + Type: schema.TypeList, Required: true, MaxItems: 1, Elem: &schema.Resource{ @@ -102,14 +102,13 @@ func resourceArmVirtualMachineScaleSet() *schema.Resource { }, "custom_data": { - Type: schema.TypeString, - Optional: true, - ForceNew: true, - StateFunc: userDataStateFunc, + Type: schema.TypeString, + Optional: true, + StateFunc: userDataStateFunc, + DiffSuppressFunc: userDataDiffSuppressFunc, }, }, }, - Set: resourceArmVirtualMachineScaleSetsOsProfileHash, }, "os_profile_secrets": { @@ -697,7 +696,7 @@ func resourceArmVirtualMachineScaleSetRead(d *schema.ResourceData, meta interfac d.Set("overprovision", properties.Overprovision) d.Set("single_placement_group", properties.SinglePlacementGroup) - osProfile, err := flattenAzureRMVirtualMachineScaleSetOsProfile(properties.VirtualMachineProfile.OsProfile) + osProfile, err := flattenAzureRMVirtualMachineScaleSetOsProfile(d, properties.VirtualMachineProfile.OsProfile) if err != nil { return fmt.Errorf("[DEBUG] Error flattening Virtual Machine Scale Set OS Profile. Error: %#v", err) } @@ -964,14 +963,27 @@ func flattenAzureRmVirtualMachineScaleSetNetworkProfile(profile *compute.Virtual return result } -func flattenAzureRMVirtualMachineScaleSetOsProfile(profile *compute.VirtualMachineScaleSetOSProfile) ([]interface{}, error) { +func flattenAzureRMVirtualMachineScaleSetOsProfile(d *schema.ResourceData, profile *compute.VirtualMachineScaleSetOSProfile) ([]interface{}, error) { result := make(map[string]interface{}) result["computer_name_prefix"] = *profile.ComputerNamePrefix result["admin_username"] = *profile.AdminUsername + // admin password isn't returned, so let's look it up + if v, ok := d.GetOk("os_profile.0.admin_password"); ok { + password := v.(string) + result["admin_password"] = password + } + if profile.CustomData != nil { result["custom_data"] = *profile.CustomData + } else { + // look up the current custom data + value := d.Get("os_profile.0.custom_data").(string) + if !isBase64Encoded(value) { + value = base64Encode(value) + } + result["custom_data"] = value } return []interface{}{result}, nil @@ -1146,21 +1158,6 @@ func resourceArmVirtualMachineScaleSetNetworkConfigurationHash(v interface{}) in return hashcode.String(buf.String()) } -func resourceArmVirtualMachineScaleSetsOsProfileHash(v interface{}) int { - var buf bytes.Buffer - m := v.(map[string]interface{}) - buf.WriteString(fmt.Sprintf("%s-", m["computer_name_prefix"].(string))) - buf.WriteString(fmt.Sprintf("%s-", m["admin_username"].(string))) - if m["custom_data"] != nil { - customData := m["custom_data"].(string) - if !isBase64Encoded(customData) { - customData = base64Encode(customData) - } - buf.WriteString(fmt.Sprintf("%s-", customData)) - } - return hashcode.String(buf.String()) -} - func resourceArmVirtualMachineScaleSetOsProfileLinuxConfigHash(v interface{}) int { var buf bytes.Buffer m := v.(map[string]interface{}) @@ -1325,7 +1322,7 @@ func expandAzureRmVirtualMachineScaleSetNetworkProfile(d *schema.ResourceData) * } func expandAzureRMVirtualMachineScaleSetsOsProfile(d *schema.ResourceData) (*compute.VirtualMachineScaleSetOSProfile, error) { - osProfileConfigs := d.Get("os_profile").(*schema.Set).List() + osProfileConfigs := d.Get("os_profile").([]interface{}) osProfileConfig := osProfileConfigs[0].(map[string]interface{}) namePrefix := osProfileConfig["computer_name_prefix"].(string) diff --git a/azurerm/resource_arm_virtual_machine_scale_set_test.go b/azurerm/resource_arm_virtual_machine_scale_set_test.go index 1d0761aff5f7..ffdea5290223 100644 --- a/azurerm/resource_arm_virtual_machine_scale_set_test.go +++ b/azurerm/resource_arm_virtual_machine_scale_set_test.go @@ -181,6 +181,34 @@ func TestAccAzureRMVirtualMachineScaleSet_linuxUpdated(t *testing.T) { }) } +func TestAccAzureRMVirtualMachineScaleSet_customDataUpdated(t *testing.T) { + resourceName := "azurerm_virtual_machine_scale_set.test" + ri := acctest.RandInt() + location := testLocation() + config := testAccAzureRMVirtualMachineScaleSet_linux(ri, location) + updatedConfig := testAccAzureRMVirtualMachineScaleSet_linuxCustomDataUpdated(ri, location) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMVirtualMachineScaleSetDestroy, + Steps: []resource.TestStep{ + { + Config: config, + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMVirtualMachineScaleSetExists(resourceName), + ), + }, + { + Config: updatedConfig, + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMVirtualMachineScaleSetExists(resourceName), + ), + }, + }, + }) +} + func TestAccAzureRMVirtualMachineScaleSet_basicLinux_managedDisk(t *testing.T) { ri := acctest.RandInt() config := testAccAzureRMVirtualMachineScaleSet_basicLinux_managedDisk(ri, testLocation()) @@ -1659,6 +1687,106 @@ resource "azurerm_virtual_machine_scale_set" "test" { `, rInt, location, rInt, rInt, rInt, rInt, rInt, rInt, rInt, rInt) } +func testAccAzureRMVirtualMachineScaleSet_linuxCustomDataUpdated(rInt int, location string) string { + return fmt.Sprintf(` +resource "azurerm_resource_group" "test" { + name = "acctestrg-%d" + location = "%s" +} +resource "azurerm_virtual_network" "test" { + name = "acctestvn-%d" + resource_group_name = "${azurerm_resource_group.test.name}" + location = "${azurerm_resource_group.test.location}" + address_space = ["10.0.0.0/8"] +} +resource "azurerm_subnet" "test" { + name = "acctestsn-%d" + resource_group_name = "${azurerm_resource_group.test.name}" + virtual_network_name = "${azurerm_virtual_network.test.name}" + address_prefix = "10.0.1.0/24" +} +resource "azurerm_storage_account" "test" { + name = "accsa%d" + resource_group_name = "${azurerm_resource_group.test.name}" + location = "${azurerm_resource_group.test.location}" + account_tier = "Standard" + account_replication_type = "LRS" +} +resource "azurerm_storage_container" "test" { + name = "acctestsc-%d" + resource_group_name = "${azurerm_resource_group.test.name}" + storage_account_name = "${azurerm_storage_account.test.name}" + container_access_type = "private" +} +resource "azurerm_public_ip" "test" { + name = "acctestpip-%d" + resource_group_name = "${azurerm_resource_group.test.name}" + location = "${azurerm_resource_group.test.location}" + public_ip_address_allocation = "static" +} +resource "azurerm_lb" "test" { + name = "acctestlb-%d" + resource_group_name = "${azurerm_resource_group.test.name}" + location = "${azurerm_resource_group.test.location}" + frontend_ip_configuration { + name = "ip-address" + public_ip_address_id = "${azurerm_public_ip.test.id}" + } +} +resource "azurerm_lb_backend_address_pool" "test" { + name = "acctestbap-%d" + resource_group_name = "${azurerm_resource_group.test.name}" + loadbalancer_id = "${azurerm_lb.test.id}" +} +resource "azurerm_virtual_machine_scale_set" "test" { + name = "acctestvmss-%d" + resource_group_name = "${azurerm_resource_group.test.name}" + location = "${azurerm_resource_group.test.location}" + upgrade_policy_mode = "Automatic" + sku { + name = "Standard_A0" + tier = "Standard" + capacity = "1" + } + os_profile { + computer_name_prefix = "prefix" + admin_username = "ubuntu" + admin_password = "password" + custom_data = "updated custom data!" + } + os_profile_linux_config { + disable_password_authentication = true + ssh_keys { + path = "/home/ubuntu/.ssh/authorized_keys" + key_data = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDCsTcryUl51Q2VSEHqDRNmceUFo55ZtcIwxl2QITbN1RREti5ml/VTytC0yeBOvnZA4x4CFpdw/lCDPk0yrH9Ei5vVkXmOrExdTlT3qI7YaAzj1tUVlBd4S6LX1F7y6VLActvdHuDDuXZXzCDd/97420jrDfWZqJMlUK/EmCE5ParCeHIRIvmBxcEnGfFIsw8xQZl0HphxWOtJil8qsUWSdMyCiJYYQpMoMliO99X40AUc4/AlsyPyT5ddbKk08YrZ+rKDVHF7o29rh4vi5MmHkVgVQHKiKybWlHq+b71gIAUQk9wrJxD+dqt4igrmDSpIjfjwnd+l5UIn5fJSO5DYV4YT/4hwK7OKmuo7OFHD0WyY5YnkYEMtFgzemnRBdE8ulcT60DQpVgRMXFWHvhyCWy0L6sgj1QWDZlLpvsIvNfHsyhKFMG1frLnMt/nP0+YCcfg+v1JYeCKjeoJxB8DWcRBsjzItY0CGmzP8UYZiYKl/2u+2TgFS5r7NWH11bxoUzjKdaa1NLw+ieA8GlBFfCbfWe6YVB9ggUte4VtYFMZGxOjS2bAiYtfgTKFJv+XqORAwExG6+G2eDxIDyo80/OA9IG7Xv/jwQr7D6KDjDuULFcN/iTxuttoKrHeYz1hf5ZQlBdllwJHYx6fK2g8kha6r2JIQKocvsAXiiONqSfw== hello@world.com" + } + } + network_profile { + name = "TestNetworkProfile" + primary = true + ip_configuration { + name = "TestIPConfiguration" + subnet_id = "${azurerm_subnet.test.id}" + load_balancer_backend_address_pool_ids = ["${azurerm_lb_backend_address_pool.test.id}"] + } + } + storage_profile_os_disk { + name = "osDiskProfile" + caching = "ReadWrite" + create_option = "FromImage" + os_type = "linux" + vhd_containers = ["${azurerm_storage_account.test.primary_blob_endpoint}${azurerm_storage_container.test.name}"] + } + storage_profile_image_reference { + publisher = "Canonical" + offer = "UbuntuServer" + sku = "16.04-LTS" + version = "latest" + } +} +`, rInt, location, rInt, rInt, rInt, rInt, rInt, rInt, rInt, rInt) +} + func testAccAzureRMVirtualMachineScaleSet_basicLinux_managedDisk(rInt int, location string) string { return fmt.Sprintf(` resource "azurerm_resource_group" "test" { diff --git a/website/docs/r/virtual_machine_scale_set.html.markdown b/website/docs/r/virtual_machine_scale_set.html.markdown index f92704ccaefb..5505451466eb 100644 --- a/website/docs/r/virtual_machine_scale_set.html.markdown +++ b/website/docs/r/virtual_machine_scale_set.html.markdown @@ -273,7 +273,7 @@ The following arguments are supported: * `computer_name_prefix` - (Required) Specifies the computer name prefix for all of the virtual machines in the scale set. Computer name prefixes must be 1 to 15 characters long. * `admin_username` - (Required) Specifies the administrator account name to use for all the instances of virtual machines in the scale set. * `admin_password` - (Required) Specifies the administrator password to use for all the instances of virtual machines in a scale set.. -* `custom_data` - (Optional) Specifies custom data to supply to the machine. On linux-based systems, this can be used as a cloud-init script. On other systems, this will be copied as a file on disk. Internally, Terraform will base64 encode this value before sending it to the API. The maximum length of the binary array is 65535 bytes. Changing this forces a new resource to be created. +* `custom_data` - (Optional) Specifies custom data to supply to the machine. On linux-based systems, this can be used as a cloud-init script. On other systems, this will be copied as a file on disk. Internally, Terraform will base64 encode this value before sending it to the API. The maximum length of the binary array is 65535 bytes. `os_profile_secrets` supports the following: From 5907ba4be1a066e7c3e15381670affd10474efb3 Mon Sep 17 00:00:00 2001 From: Tom Harvey Date: Thu, 16 Nov 2017 11:53:34 +0000 Subject: [PATCH 11/55] Updating to include #559 --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 580d3948a8d4..b37c562c213d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,6 +3,7 @@ IMPROVEMENTS: * `azurerm_eventhub_namespace`: capacity can now be configured up to 20 [GH-556] +* `azurerm_virtual_machine_scale_set`: Support for updating the customData field [GH-559] ## 0.3.3 (November 14, 2017) From 8ae6169e4c6d0c01cd4508cbfbdef603258154c0 Mon Sep 17 00:00:00 2001 From: tombuildsstuff Date: Thu, 16 Nov 2017 12:21:32 +0000 Subject: [PATCH 12/55] Support for Auto Inflating ``` $ acctests azurerm TestAccAzureRMEventHubNamespace_maximumThroughputUnits === RUN TestAccAzureRMEventHubNamespace_maximumThroughputUnits --- PASS: TestAccAzureRMEventHubNamespace_maximumThroughputUnits (202.41s) PASS ok github.com/terraform-providers/terraform-provider-azurerm/azurerm 202.432s ``` --- azurerm/resource_arm_eventhub_namespace.go | 29 ++++++++++++++ .../resource_arm_eventhub_namespace_test.go | 40 +++++++++++++++++++ .../docs/r/eventhub_namespace.html.markdown | 16 ++++---- 3 files changed, 78 insertions(+), 7 deletions(-) diff --git a/azurerm/resource_arm_eventhub_namespace.go b/azurerm/resource_arm_eventhub_namespace.go index 76171f7ef3b8..3c6097400120 100644 --- a/azurerm/resource_arm_eventhub_namespace.go +++ b/azurerm/resource_arm_eventhub_namespace.go @@ -9,6 +9,7 @@ import ( "github.com/Azure/azure-sdk-for-go/arm/eventhub" "github.com/hashicorp/terraform/helper/schema" + "github.com/hashicorp/terraform/helper/validation" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" ) @@ -51,6 +52,19 @@ func resourceArmEventHubNamespace() *schema.Resource { ValidateFunc: validateEventHubNamespaceCapacity, }, + "auto_inflate_enabled": { + Type: schema.TypeBool, + Optional: true, + Default: false, + }, + + "maximum_throughput_units": { + Type: schema.TypeInt, + Optional: true, + Computed: true, + ValidateFunc: validation.IntBetween(1, 20), + }, + "default_primary_connection_string": { Type: schema.TypeString, Computed: true, @@ -88,6 +102,8 @@ func resourceArmEventHubNamespaceCreate(d *schema.ResourceData, meta interface{} capacity := int32(d.Get("capacity").(int)) tags := d.Get("tags").(map[string]interface{}) + autoInflateEnabled := d.Get("auto_inflate_enabled").(bool) + parameters := eventhub.EHNamespace{ Location: &location, Sku: &eventhub.Sku{ @@ -95,9 +111,17 @@ func resourceArmEventHubNamespaceCreate(d *schema.ResourceData, meta interface{} Tier: eventhub.SkuTier(sku), Capacity: &capacity, }, + EHNamespaceProperties: &eventhub.EHNamespaceProperties{ + IsAutoInflateEnabled: utils.Bool(autoInflateEnabled), + }, Tags: expandTags(tags), } + if v, ok := d.GetOk("maximum_throughput_units"); ok { + maximumThroughputUnits := v.(int) + parameters.EHNamespaceProperties.MaximumThroughputUnits = utils.Int32(int32(maximumThroughputUnits)) + } + _, error := namespaceClient.CreateOrUpdate(resGroup, name, parameters, make(chan struct{})) err := <-error if err != nil { @@ -153,6 +177,11 @@ func resourceArmEventHubNamespaceRead(d *schema.ResourceData, meta interface{}) d.Set("default_secondary_key", keys.SecondaryKey) } + if props := resp.EHNamespaceProperties; props != nil { + d.Set("auto_inflate_enabled", props.IsAutoInflateEnabled) + d.Set("maximum_throughput_units", int(*props.MaximumThroughputUnits)) + } + flattenAndSetTags(d, resp.Tags) return nil diff --git a/azurerm/resource_arm_eventhub_namespace_test.go b/azurerm/resource_arm_eventhub_namespace_test.go index 96641e7d1ef9..369ff20f7f89 100644 --- a/azurerm/resource_arm_eventhub_namespace_test.go +++ b/azurerm/resource_arm_eventhub_namespace_test.go @@ -147,6 +147,26 @@ func TestAccAzureRMEventHubNamespace_readDefaultKeys(t *testing.T) { }) } +func TestAccAzureRMEventHubNamespace_maximumThroughputUnits(t *testing.T) { + resourceName := "azurerm_eventhub_namespace.test" + ri := acctest.RandInt() + config := testAccAzureRMEventHubNamespace_maximumThroughputUnits(ri, testLocation()) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMEventHubNamespaceDestroy, + Steps: []resource.TestStep{ + { + Config: config, + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMEventHubNamespaceExists(resourceName), + ), + }, + }, + }) +} + func TestAccAzureRMEventHubNamespace_NonStandardCasing(t *testing.T) { ri := acctest.RandInt() @@ -273,3 +293,23 @@ resource "azurerm_eventhub_namespace" "test" { } `, rInt, location, rInt) } + +func testAccAzureRMEventHubNamespace_maximumThroughputUnits(rInt int, location string) string { + return fmt.Sprintf(` + +resource "azurerm_resource_group" "test" { + name = "acctestRG-%d" + location = "%s" +} + +resource "azurerm_eventhub_namespace" "test" { + name = "acctesteventhubnamespace-%d" + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" + sku = "Standard" + capacity = "2" + auto_inflate_enabled = true + maximum_throughput_units = 20 +} +`, rInt, location, rInt) +} diff --git a/website/docs/r/eventhub_namespace.html.markdown b/website/docs/r/eventhub_namespace.html.markdown index 0f6ddf9ce797..8d7b959eb3e1 100644 --- a/website/docs/r/eventhub_namespace.html.markdown +++ b/website/docs/r/eventhub_namespace.html.markdown @@ -20,7 +20,7 @@ resource "azurerm_resource_group" "test" { resource "azurerm_eventhub_namespace" "test" { name = "acceptanceTestEventHubNamespace" - location = "West US" + location = "${azurerm_resource_group.test.location}" resource_group_name = "${azurerm_resource_group.test.name}" sku = "Standard" capacity = 2 @@ -35,17 +35,19 @@ resource "azurerm_eventhub_namespace" "test" { The following arguments are supported: -* `name` - (Required) Specifies the name of the EventHub Namespace resource . Changing this forces a - new resource to be created. +* `name` - (Required) Specifies the name of the EventHub Namespace resource. Changing this forces a new resource to be created. -* `resource_group_name` - (Required) The name of the resource group in which to - create the namespace. Changing this forces a new resource to be created. +* `resource_group_name` - (Required) The name of the resource group in which to create the namespace. Changing this forces a new resource to be created. * `location` - (Required) Specifies the supported Azure location where the resource exists. Changing this forces a new resource to be created. -* `sku` - (Required) Defines which tier to use. Options are Basic or Standard. +* `sku` - (Required) Defines which tier to use. Valid options are `Basic` and `Standard`. -* `capacity` - (Optional) Specifies the capacity of a Standard namespace. Can be 1, 2 or 4 +* `capacity` - (Optional) Specifies the Capacity / Throughput Units for a `Standard` SKU namespace. Valid values range from 1 - 20. + +* `auto_inflate_enabled` - (Optional) Is Auto Inflate enabled for the EventHub Namespace? + +* `maximum_throughput_units` - (Optional) Specifies the maximum number of throughput units when Auto Inflate is Enabled. Valid values range from 1 - 20. * `tags` - (Optional) A mapping of tags to assign to the resource. From c8141c7c4289de10c85c77adc202da270438b106 Mon Sep 17 00:00:00 2001 From: tombuildsstuff Date: Fri, 17 Nov 2017 15:21:51 +0000 Subject: [PATCH 13/55] New Resource: `azurerm_network_watcher` ``` $ acctests azurerm TestAccAzureRMNetworkWatcher_ === RUN TestAccAzureRMNetworkWatcher_importBasic --- PASS: TestAccAzureRMNetworkWatcher_importBasic (75.79s) === RUN TestAccAzureRMNetworkWatcher_importComplete --- PASS: TestAccAzureRMNetworkWatcher_importComplete (69.85s) === RUN TestAccAzureRMNetworkWatcher_basic --- PASS: TestAccAzureRMNetworkWatcher_basic (69.62s) === RUN TestAccAzureRMNetworkWatcher_complete --- PASS: TestAccAzureRMNetworkWatcher_complete (72.16s) === RUN TestAccAzureRMNetworkWatcher_update --- PASS: TestAccAzureRMNetworkWatcher_update (81.75s) === RUN TestAccAzureRMNetworkWatcher_disappears --- PASS: TestAccAzureRMNetworkWatcher_disappears (94.38s) PASS ok ``` --- azurerm/config.go | 13 ++ azurerm/import_arm_network_watcher_test.go | 50 +++++ azurerm/provider.go | 1 + azurerm/resource_arm_network_watcher.go | 116 +++++++++++ azurerm/resource_arm_network_watcher_test.go | 204 +++++++++++++++++++ website/azurerm.erb | 4 + website/docs/r/network_watcher.html.markdown | 53 +++++ 7 files changed, 441 insertions(+) create mode 100644 azurerm/import_arm_network_watcher_test.go create mode 100644 azurerm/resource_arm_network_watcher.go create mode 100644 azurerm/resource_arm_network_watcher_test.go create mode 100644 website/docs/r/network_watcher.html.markdown diff --git a/azurerm/config.go b/azurerm/config.go index 159a54726a8d..d17e403f99d8 100644 --- a/azurerm/config.go +++ b/azurerm/config.go @@ -160,6 +160,9 @@ type ArmClient struct { sqlElasticPoolsClient sql.ElasticPoolsClient sqlFirewallRulesClient sql.FirewallRulesClient sqlServersClient sql.ServersClient + + // Networking + watcherClient network.WatchersClient } func withRequestLogging() autorest.SendDecorator { @@ -655,11 +658,21 @@ func (c *Config) getArmClient() (*ArmClient, error) { client.registerDatabases(endpoint, c.SubscriptionID, auth, sender) client.registerDisks(endpoint, c.SubscriptionID, auth, sender) client.registerKeyVaultClients(endpoint, c.SubscriptionID, auth, keyVaultAuth, sender) + client.registerNetworkingClients(endpoint, c.SubscriptionID, auth, sender) client.registerRedisClients(endpoint, c.SubscriptionID, auth, sender) return &client, nil } +func (c *ArmClient) registerNetworkingClients(endpoint, subscriptionId string, auth autorest.Authorizer, sender autorest.Sender) { + // TODO: move the other networking stuff in here, gradually + watchersClient := network.NewWatchersClientWithBaseURI(endpoint, subscriptionId) + setUserAgent(&watchersClient.Client) + watchersClient.Authorizer = auth + watchersClient.Sender = sender + c.watcherClient = watchersClient +} + func (c *ArmClient) registerAuthentication(endpoint, graphEndpoint, subscriptionId, tenantId string, auth, graphAuth autorest.Authorizer, sender autorest.Sender) { spc := graphrbac.NewServicePrincipalsClientWithBaseURI(graphEndpoint, tenantId) setUserAgent(&spc.Client) diff --git a/azurerm/import_arm_network_watcher_test.go b/azurerm/import_arm_network_watcher_test.go new file mode 100644 index 000000000000..32e4868d7e31 --- /dev/null +++ b/azurerm/import_arm_network_watcher_test.go @@ -0,0 +1,50 @@ +package azurerm + +import ( + "testing" + + "github.com/hashicorp/terraform/helper/acctest" + "github.com/hashicorp/terraform/helper/resource" +) + +func TestAccAzureRMNetworkWatcher_importBasic(t *testing.T) { + rInt := acctest.RandInt() + resourceName := "azurerm_network_watcher.test" + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMNetworkWatcherDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMNetworkWatcher_basic(rInt, testLocation()), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + }, + }, + }) +} + +func TestAccAzureRMNetworkWatcher_importComplete(t *testing.T) { + rInt := acctest.RandInt() + resourceName := "azurerm_network_watcher.test" + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMNetworkWatcherDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMNetworkWatcher_complete(rInt, testLocation()), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + }, + }, + }) +} diff --git a/azurerm/provider.go b/azurerm/provider.go index 5f7dfea31866..c085d8709899 100644 --- a/azurerm/provider.go +++ b/azurerm/provider.go @@ -134,6 +134,7 @@ func Provider() terraform.ResourceProvider { "azurerm_network_interface": resourceArmNetworkInterface(), "azurerm_network_security_group": resourceArmNetworkSecurityGroup(), "azurerm_network_security_rule": resourceArmNetworkSecurityRule(), + "azurerm_network_watcher": resourceArmNetworkWatcher(), "azurerm_postgresql_configuration": resourceArmPostgreSQLConfiguration(), "azurerm_postgresql_database": resourceArmPostgreSQLDatabase(), "azurerm_postgresql_firewall_rule": resourceArmPostgreSQLFirewallRule(), diff --git a/azurerm/resource_arm_network_watcher.go b/azurerm/resource_arm_network_watcher.go new file mode 100644 index 000000000000..e81f49b1ae6f --- /dev/null +++ b/azurerm/resource_arm_network_watcher.go @@ -0,0 +1,116 @@ +package azurerm + +import ( + "fmt" + + "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/hashicorp/terraform/helper/schema" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" +) + +func resourceArmNetworkWatcher() *schema.Resource { + return &schema.Resource{ + Create: resourceArmNetworkWatcherCreateUpdate, + Read: resourceArmNetworkWatcherRead, + Update: resourceArmNetworkWatcherCreateUpdate, + Delete: resourceArmNetworkWatcherDelete, + Importer: &schema.ResourceImporter{ + State: schema.ImportStatePassthrough, + }, + + Schema: map[string]*schema.Schema{ + "name": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + }, + + "resource_group_name": resourceGroupNameSchema(), + + "location": locationSchema(), + + "tags": tagsSchema(), + }, + } +} + +func resourceArmNetworkWatcherCreateUpdate(d *schema.ResourceData, meta interface{}) error { + client := meta.(*ArmClient).watcherClient + + name := d.Get("name").(string) + resourceGroup := d.Get("resource_group_name").(string) + location := d.Get("location").(string) + tags := d.Get("tags").(map[string]interface{}) + + watcher := network.Watcher{ + Location: utils.String(location), + Tags: expandTags(tags), + } + _, err := client.CreateOrUpdate(resourceGroup, name, watcher) + if err != nil { + return err + } + + read, err := client.Get(resourceGroup, name) + if err != nil { + return err + } + if read.ID == nil { + return fmt.Errorf("Cannot read Network Watcher %q (Resource Group %q) ID", name, resourceGroup) + } + + d.SetId(*read.ID) + + return resourceArmNetworkWatcherRead(d, meta) +} + +func resourceArmNetworkWatcherRead(d *schema.ResourceData, meta interface{}) error { + client := meta.(*ArmClient).watcherClient + + id, err := parseAzureResourceID(d.Id()) + if err != nil { + return err + } + resourceGroup := id.ResourceGroup + name := id.Path["networkWatchers"] + + resp, err := client.Get(resourceGroup, name) + if err != nil { + if utils.ResponseWasNotFound(resp.Response) { + d.SetId("") + return nil + } + return fmt.Errorf("Error making Read request on Network Watcher %q (Resource Group %q): %+v", name, resourceGroup, err) + } + + d.Set("name", resp.Name) + d.Set("resource_group_name", resourceGroup) + d.Set("location", azureRMNormalizeLocation(*resp.Location)) + + flattenAndSetTags(d, resp.Tags) + + return nil +} + +func resourceArmNetworkWatcherDelete(d *schema.ResourceData, meta interface{}) error { + client := meta.(*ArmClient).watcherClient + + id, err := parseAzureResourceID(d.Id()) + if err != nil { + return err + } + resourceGroup := id.ResourceGroup + name := id.Path["networkWatchers"] + + deleteResp, deleteErr := client.Delete(resourceGroup, name, make(chan struct{})) + resp := <-deleteResp + err = <-deleteErr + + if err != nil { + if !utils.ResponseWasNotFound(resp) { + return fmt.Errorf("Error deleting Network Watcher %q (Resource Group %q): %+v", name, resourceGroup, err) + } + } + + return nil +} diff --git a/azurerm/resource_arm_network_watcher_test.go b/azurerm/resource_arm_network_watcher_test.go new file mode 100644 index 000000000000..73d963550f65 --- /dev/null +++ b/azurerm/resource_arm_network_watcher_test.go @@ -0,0 +1,204 @@ +package azurerm + +import ( + "fmt" + "testing" + + "github.com/hashicorp/terraform/helper/acctest" + "github.com/hashicorp/terraform/helper/resource" + "github.com/hashicorp/terraform/terraform" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" +) + +func TestAccAzureRMNetworkWatcher_basic(t *testing.T) { + resourceGroup := "azurerm_network_watcher.test" + rInt := acctest.RandInt() + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMNetworkWatcherDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMNetworkWatcher_basic(rInt, testLocation()), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMNetworkWatcherExists(resourceGroup), + ), + }, + }, + }) +} + +func TestAccAzureRMNetworkWatcher_complete(t *testing.T) { + resourceGroup := "azurerm_network_watcher.test" + rInt := acctest.RandInt() + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMNetworkWatcherDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMNetworkWatcher_complete(rInt, testLocation()), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMNetworkWatcherExists(resourceGroup), + ), + }, + }, + }) +} + +func TestAccAzureRMNetworkWatcher_update(t *testing.T) { + resourceGroup := "azurerm_network_watcher.test" + rInt := acctest.RandInt() + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMNetworkWatcherDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMNetworkWatcher_basic(rInt, testLocation()), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMNetworkWatcherExists(resourceGroup), + ), + }, + { + Config: testAccAzureRMNetworkWatcher_complete(rInt, testLocation()), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMNetworkWatcherExists(resourceGroup), + ), + }, + }, + }) +} + +func TestAccAzureRMNetworkWatcher_disappears(t *testing.T) { + resourceGroup := "azurerm_network_watcher.test" + rInt := acctest.RandInt() + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMNetworkWatcherDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMNetworkWatcher_basic(rInt, testLocation()), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMNetworkWatcherExists(resourceGroup), + testCheckAzureRMNetworkWatcherDisappears(resourceGroup), + ), + ExpectNonEmptyPlan: true, + }, + }, + }) +} + +func testCheckAzureRMNetworkWatcherExists(name string) resource.TestCheckFunc { + return func(s *terraform.State) error { + + rs, ok := s.RootModule().Resources[name] + if !ok { + return fmt.Errorf("Not found: %s", name) + } + + name := rs.Primary.Attributes["name"] + resourceGroup, hasResourceGroup := rs.Primary.Attributes["resource_group_name"] + if !hasResourceGroup { + return fmt.Errorf("Bad: no resource group found in state for Network Watcher: %q", name) + } + + conn := testAccProvider.Meta().(*ArmClient).watcherClient + + resp, err := conn.Get(resourceGroup, name) + if err != nil { + if utils.ResponseWasNotFound(resp.Response) { + return fmt.Errorf("Bad: Network Watcher %q (resource group: %q) does not exist", name, resourceGroup) + } + return fmt.Errorf("Bad: Get on watcherClient: %+v", err) + } + + return nil + } +} + +func testCheckAzureRMNetworkWatcherDisappears(name string) resource.TestCheckFunc { + return func(s *terraform.State) error { + + rs, ok := s.RootModule().Resources[name] + if !ok { + return fmt.Errorf("Not found: %q", name) + } + + name := rs.Primary.Attributes["name"] + resourceGroup, hasResourceGroup := rs.Primary.Attributes["resource_group_name"] + if !hasResourceGroup { + return fmt.Errorf("Bad: no resource group found in state for Network Watcher: %q", name) + } + + client := testAccProvider.Meta().(*ArmClient).watcherClient + deleteResp, deleteErr := client.Delete(resourceGroup, name, make(chan struct{})) + resp := <-deleteResp + err := <-deleteErr + if err != nil { + if !utils.ResponseWasNotFound(resp) { + return fmt.Errorf("Bad: Delete on watcherClient: %+v", err) + } + } + + return nil + } +} + +func testCheckAzureRMNetworkWatcherDestroy(s *terraform.State) error { + for _, rs := range s.RootModule().Resources { + + if rs.Type != "azurerm_network_watcher" { + continue + } + + name := rs.Primary.Attributes["name"] + resourceGroup := rs.Primary.Attributes["resource_group_name"] + + client := testAccProvider.Meta().(*ArmClient).watcherClient + resp, err := client.Get(resourceGroup, name) + + if err != nil { + if !utils.ResponseWasNotFound(resp.Response) { + return fmt.Errorf("Network Watcher still exists:\n%#v", resp) + } + } + } + + return nil +} + +func testAccAzureRMNetworkWatcher_basic(rInt int, location string) string { + return fmt.Sprintf(` +resource "azurerm_resource_group" "test" { + name = "acctestRG-%d" + location = "%s" +} + +resource "azurerm_network_watcher" "test" { + name = "acctestnw-%d" + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" +} +`, rInt, location, rInt) +} + +func testAccAzureRMNetworkWatcher_complete(rInt int, location string) string { + return fmt.Sprintf(` +resource "azurerm_resource_group" "test" { + name = "acctestRG-%d" + location = "%s" +} + +resource "azurerm_network_watcher" "test" { + name = "acctestnw-%d" + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" + tags { + "Source" = "AccTests" + } +} +`, rInt, location, rInt) +} diff --git a/website/azurerm.erb b/website/azurerm.erb index c01de2a7752d..8436799e6489 100644 --- a/website/azurerm.erb +++ b/website/azurerm.erb @@ -439,6 +439,10 @@ azurerm_network_security_rule + > + azurerm_network_watcher + + > azurerm_public_ip diff --git a/website/docs/r/network_watcher.html.markdown b/website/docs/r/network_watcher.html.markdown new file mode 100644 index 000000000000..6bdf22bcbca5 --- /dev/null +++ b/website/docs/r/network_watcher.html.markdown @@ -0,0 +1,53 @@ +--- +layout: "azurerm" +page_title: "Azure Resource Manager: azurerm_network_watcher" +sidebar_current: "docs-azurerm-resource-network-watcher" +description: |- + Manages a Network Watcher. + +--- + +# azurerm_network_watcher + +Manages a Network Watcher. + +## Example Usage + +```hcl +resource "azurerm_resource_group" "test" { + name = "production-nwwatcher" + location = "West US" +} + +resource "azurerm_network_watcher" "test" { + name = "production-nwwatcher" + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" +} +``` + +## Argument Reference + +The following arguments are supported: + +* `name` - (Required) The name of the Network Watcher. Changing this forces a new resource to be created. + +* `resource_group_name` - (Required) The name of the resource group in which to create the Network Watcher. Changing this forces a new resource to be created. + +* `location` - (Required) Specifies the supported Azure location where the resource exists. Changing this forces a new resource to be created. + +* `tags` - (Optional) A mapping of tags to assign to the resource. + +## Attributes Reference + +The following attributes are exported: + +* `id` - The Network Watcher ID. + +## Import + +Network Watchers can be imported using the `resource id`, e.g. + +```shell +terraform import azurerm_network_watcher.watcher1 /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup1/providers/Microsoft.Network/networkWatchers/watcher1 +``` From 2c3e9a23fd66abe33309b7a8ffbe833a42edec8c Mon Sep 17 00:00:00 2001 From: Tom Harvey Date: Fri, 17 Nov 2017 15:35:53 +0000 Subject: [PATCH 14/55] Updating to include #569 --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index b37c562c213d..6302ef72864a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,6 +3,7 @@ IMPROVEMENTS: * `azurerm_eventhub_namespace`: capacity can now be configured up to 20 [GH-556] +* `azurerm_eventhub_namespace` - support for AutoInflating/MaximumThroughputCapacity [GH-569] * `azurerm_virtual_machine_scale_set`: Support for updating the customData field [GH-559] ## 0.3.3 (November 14, 2017) From b8b4aa74cce8636cdee3e2a9d96b027be7b65262 Mon Sep 17 00:00:00 2001 From: Su Shi <1684739+metacpp@users.noreply.github.com> Date: Fri, 17 Nov 2017 14:26:54 -0800 Subject: [PATCH 15/55] Hotfix: upgrade packages under go-autorest to be v9.4.1. Intergrate with latest version of go-autorest to read access tokens through new way customized through environment variable. The old behavior on local shell will be kept. Notice: for Azure Cloud Shell user, please make sure that they're using latest patched provider. --- .../Azure/go-autorest/autorest/adal/config.go | 14 + .../go-autorest/autorest/adal/devicetoken.go | 14 + .../Azure/go-autorest/autorest/adal/msi.go | 14 + .../go-autorest/autorest/adal/msi_windows.go | 14 + .../go-autorest/autorest/adal/persist.go | 14 + .../Azure/go-autorest/autorest/adal/sender.go | 14 + .../Azure/go-autorest/autorest/adal/token.go | 14 + .../go-autorest/autorest/authorization.go | 14 + .../Azure/go-autorest/autorest/autorest.go | 17 ++ .../Azure/go-autorest/autorest/azure/async.go | 270 ++++++++++++++---- .../Azure/go-autorest/autorest/azure/azure.go | 22 +- .../go-autorest/autorest/azure/cli/profile.go | 14 + .../go-autorest/autorest/azure/cli/token.go | 27 +- .../autorest/azure/environments.go | 48 +++- .../Azure/go-autorest/autorest/azure/rp.go | 203 +++++++++++++ .../Azure/go-autorest/autorest/client.go | 30 +- .../Azure/go-autorest/autorest/date/date.go | 14 + .../Azure/go-autorest/autorest/date/time.go | 14 + .../go-autorest/autorest/date/timerfc1123.go | 14 + .../go-autorest/autorest/date/unixtime.go | 14 + .../go-autorest/autorest/date/utility.go | 14 + .../Azure/go-autorest/autorest/error.go | 14 + .../Azure/go-autorest/autorest/preparer.go | 14 + .../Azure/go-autorest/autorest/responder.go | 14 + .../go-autorest/autorest/retriablerequest.go | 14 + .../autorest/retriablerequest_1.7.go | 36 ++- .../autorest/retriablerequest_1.8.go | 42 +-- .../Azure/go-autorest/autorest/sender.go | 20 +- .../Azure/go-autorest/autorest/to/convert.go | 14 + .../Azure/go-autorest/autorest/utility.go | 26 ++ .../autorest/validation/validation.go | 21 +- .../Azure/go-autorest/autorest/version.go | 14 + vendor/vendor.json | 84 +++--- 33 files changed, 984 insertions(+), 142 deletions(-) create mode 100644 vendor/github.com/Azure/go-autorest/autorest/azure/rp.go diff --git a/vendor/github.com/Azure/go-autorest/autorest/adal/config.go b/vendor/github.com/Azure/go-autorest/autorest/adal/config.go index 12375e0e4bb8..49e9214d598a 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/adal/config.go +++ b/vendor/github.com/Azure/go-autorest/autorest/adal/config.go @@ -1,5 +1,19 @@ package adal +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "fmt" "net/url" diff --git a/vendor/github.com/Azure/go-autorest/autorest/adal/devicetoken.go b/vendor/github.com/Azure/go-autorest/autorest/adal/devicetoken.go index 6c511f8c8779..b38f4c245897 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/adal/devicetoken.go +++ b/vendor/github.com/Azure/go-autorest/autorest/adal/devicetoken.go @@ -1,5 +1,19 @@ package adal +// Copyright 2017 Microsoft Corporation +// +// 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. + /* This file is largely based on rjw57/oauth2device's code, with the follow differences: * scope -> resource, and only allow a single one diff --git a/vendor/github.com/Azure/go-autorest/autorest/adal/msi.go b/vendor/github.com/Azure/go-autorest/autorest/adal/msi.go index e87911e835d9..5e02d52ac27c 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/adal/msi.go +++ b/vendor/github.com/Azure/go-autorest/autorest/adal/msi.go @@ -2,5 +2,19 @@ package adal +// Copyright 2017 Microsoft Corporation +// +// 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. + // msiPath is the path to the MSI Extension settings file (to discover the endpoint) var msiPath = "/var/lib/waagent/ManagedIdentity-Settings" diff --git a/vendor/github.com/Azure/go-autorest/autorest/adal/msi_windows.go b/vendor/github.com/Azure/go-autorest/autorest/adal/msi_windows.go index 80f8004327f1..261b568829c8 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/adal/msi_windows.go +++ b/vendor/github.com/Azure/go-autorest/autorest/adal/msi_windows.go @@ -2,6 +2,20 @@ package adal +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "os" "strings" diff --git a/vendor/github.com/Azure/go-autorest/autorest/adal/persist.go b/vendor/github.com/Azure/go-autorest/autorest/adal/persist.go index 73711c6674ea..9e15f2751f27 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/adal/persist.go +++ b/vendor/github.com/Azure/go-autorest/autorest/adal/persist.go @@ -1,5 +1,19 @@ package adal +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "encoding/json" "fmt" diff --git a/vendor/github.com/Azure/go-autorest/autorest/adal/sender.go b/vendor/github.com/Azure/go-autorest/autorest/adal/sender.go index 7928c971abbe..0e5ad14d3962 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/adal/sender.go +++ b/vendor/github.com/Azure/go-autorest/autorest/adal/sender.go @@ -1,5 +1,19 @@ package adal +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "net/http" ) diff --git a/vendor/github.com/Azure/go-autorest/autorest/adal/token.go b/vendor/github.com/Azure/go-autorest/autorest/adal/token.go index 2ac8c3c22040..67dd97a18c18 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/adal/token.go +++ b/vendor/github.com/Azure/go-autorest/autorest/adal/token.go @@ -1,5 +1,19 @@ package adal +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "crypto/rand" "crypto/rsa" diff --git a/vendor/github.com/Azure/go-autorest/autorest/authorization.go b/vendor/github.com/Azure/go-autorest/autorest/authorization.go index 314ed7876bcc..71e3ced2d6a6 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/authorization.go +++ b/vendor/github.com/Azure/go-autorest/autorest/authorization.go @@ -1,5 +1,19 @@ package autorest +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "fmt" "net/http" diff --git a/vendor/github.com/Azure/go-autorest/autorest/autorest.go b/vendor/github.com/Azure/go-autorest/autorest/autorest.go index 51f1c4bbcac2..f86b66a410b1 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/autorest.go +++ b/vendor/github.com/Azure/go-autorest/autorest/autorest.go @@ -57,6 +57,20 @@ generated clients, see the Client described below. */ package autorest +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "net/http" "time" @@ -73,6 +87,9 @@ const ( // ResponseHasStatusCode returns true if the status code in the HTTP Response is in the passed set // and false otherwise. func ResponseHasStatusCode(resp *http.Response, codes ...int) bool { + if resp == nil { + return false + } return containsInt(codes, resp.StatusCode) } diff --git a/vendor/github.com/Azure/go-autorest/autorest/azure/async.go b/vendor/github.com/Azure/go-autorest/autorest/azure/async.go index 332a8909d1a9..f90699f6cc38 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/azure/async.go +++ b/vendor/github.com/Azure/go-autorest/autorest/azure/async.go @@ -1,7 +1,23 @@ package azure +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "bytes" + "context" + "encoding/json" "fmt" "io/ioutil" "net/http" @@ -23,6 +39,152 @@ const ( operationSucceeded string = "Succeeded" ) +var pollingCodes = [...]int{http.StatusAccepted, http.StatusCreated, http.StatusOK} + +// Future provides a mechanism to access the status and results of an asynchronous request. +// Since futures are stateful they should be passed by value to avoid race conditions. +type Future struct { + req *http.Request + resp *http.Response + ps pollingState +} + +// NewFuture returns a new Future object initialized with the specified request. +func NewFuture(req *http.Request) Future { + return Future{req: req} +} + +// Response returns the last HTTP response or nil if there isn't one. +func (f Future) Response() *http.Response { + return f.resp +} + +// Status returns the last status message of the operation. +func (f Future) Status() string { + if f.ps.State == "" { + return "Unknown" + } + return f.ps.State +} + +// PollingMethod returns the method used to monitor the status of the asynchronous operation. +func (f Future) PollingMethod() PollingMethodType { + return f.ps.PollingMethod +} + +// Done queries the service to see if the operation has completed. +func (f *Future) Done(sender autorest.Sender) (bool, error) { + // exit early if this future has terminated + if f.ps.hasTerminated() { + return true, f.errorInfo() + } + + resp, err := sender.Do(f.req) + f.resp = resp + if err != nil || !autorest.ResponseHasStatusCode(resp, pollingCodes[:]...) { + return false, err + } + + err = updatePollingState(resp, &f.ps) + if err != nil { + return false, err + } + + if f.ps.hasTerminated() { + return true, f.errorInfo() + } + + f.req, err = newPollingRequest(f.ps) + return false, err +} + +// GetPollingDelay returns a duration the application should wait before checking +// the status of the asynchronous request and true; this value is returned from +// the service via the Retry-After response header. If the header wasn't returned +// then the function returns the zero-value time.Duration and false. +func (f Future) GetPollingDelay() (time.Duration, bool) { + if f.resp == nil { + return 0, false + } + + retry := f.resp.Header.Get(autorest.HeaderRetryAfter) + if retry == "" { + return 0, false + } + + d, err := time.ParseDuration(retry + "s") + if err != nil { + panic(err) + } + + return d, true +} + +// WaitForCompletion will return when one of the following conditions is met: the long +// running operation has completed, the provided context is cancelled, or the client's +// polling duration has been exceeded. It will retry failed polling attempts based on +// the retry value defined in the client up to the maximum retry attempts. +func (f Future) WaitForCompletion(ctx context.Context, client autorest.Client) error { + ctx, cancel := context.WithTimeout(ctx, client.PollingDuration) + defer cancel() + + done, err := f.Done(client) + for attempts := 0; !done; done, err = f.Done(client) { + if attempts >= client.RetryAttempts { + return autorest.NewErrorWithError(err, "azure", "WaitForCompletion", f.resp, "the number of retries has been exceeded") + } + // we want delayAttempt to be zero in the non-error case so + // that DelayForBackoff doesn't perform exponential back-off + var delayAttempt int + var delay time.Duration + if err == nil { + // check for Retry-After delay, if not present use the client's polling delay + var ok bool + delay, ok = f.GetPollingDelay() + if !ok { + delay = client.PollingDelay + } + } else { + // there was an error polling for status so perform exponential + // back-off based on the number of attempts using the client's retry + // duration. update attempts after delayAttempt to avoid off-by-one. + delayAttempt = attempts + delay = client.RetryDuration + attempts++ + } + // wait until the delay elapses or the context is cancelled + delayElapsed := autorest.DelayForBackoff(delay, delayAttempt, ctx.Done()) + if !delayElapsed { + return autorest.NewErrorWithError(ctx.Err(), "azure", "WaitForCompletion", f.resp, "context has been cancelled") + } + } + return err +} + +// if the operation failed the polling state will contain +// error information and implements the error interface +func (f *Future) errorInfo() error { + if !f.ps.hasSucceeded() { + return f.ps + } + return nil +} + +// MarshalJSON implements the json.Marshaler interface. +func (f Future) MarshalJSON() ([]byte, error) { + return json.Marshal(&f.ps) +} + +// UnmarshalJSON implements the json.Unmarshaler interface. +func (f *Future) UnmarshalJSON(data []byte) error { + err := json.Unmarshal(data, &f.ps) + if err != nil { + return err + } + f.req, err = newPollingRequest(f.ps) + return err +} + // DoPollForAsynchronous returns a SendDecorator that polls if the http.Response is for an Azure // long-running operation. It will delay between requests for the duration specified in the // RetryAfter header or, if the header is absent, the passed delay. Polling may be canceled by @@ -34,8 +196,7 @@ func DoPollForAsynchronous(delay time.Duration) autorest.SendDecorator { if err != nil { return resp, err } - pollingCodes := []int{http.StatusAccepted, http.StatusCreated, http.StatusOK} - if !autorest.ResponseHasStatusCode(resp, pollingCodes...) { + if !autorest.ResponseHasStatusCode(resp, pollingCodes[:]...) { return resp, nil } @@ -52,10 +213,11 @@ func DoPollForAsynchronous(delay time.Duration) autorest.SendDecorator { break } - r, err = newPollingRequest(resp, ps) + r, err = newPollingRequest(ps) if err != nil { return resp, err } + r.Cancel = resp.Request.Cancel delay = autorest.GetRetryAfter(resp, delay) resp, err = autorest.SendWithSender(s, r, @@ -72,20 +234,15 @@ func getAsyncOperation(resp *http.Response) string { } func hasSucceeded(state string) bool { - return state == operationSucceeded + return strings.EqualFold(state, operationSucceeded) } func hasTerminated(state string) bool { - switch state { - case operationCanceled, operationFailed, operationSucceeded: - return true - default: - return false - } + return strings.EqualFold(state, operationCanceled) || strings.EqualFold(state, operationFailed) || strings.EqualFold(state, operationSucceeded) } func hasFailed(state string) bool { - return state == operationFailed + return strings.EqualFold(state, operationFailed) } type provisioningTracker interface { @@ -146,36 +303,42 @@ func (ps provisioningStatus) hasProvisioningError() bool { return ps.ProvisioningError != ServiceError{} } -type pollingResponseFormat string +// PollingMethodType defines a type used for enumerating polling mechanisms. +type PollingMethodType string const ( - usesOperationResponse pollingResponseFormat = "OperationResponse" - usesProvisioningStatus pollingResponseFormat = "ProvisioningStatus" - formatIsUnknown pollingResponseFormat = "" + // PollingAsyncOperation indicates the polling method uses the Azure-AsyncOperation header. + PollingAsyncOperation PollingMethodType = "AsyncOperation" + + // PollingLocation indicates the polling method uses the Location header. + PollingLocation PollingMethodType = "Location" + + // PollingUnknown indicates an unknown polling method and is the default value. + PollingUnknown PollingMethodType = "" ) type pollingState struct { - responseFormat pollingResponseFormat - uri string - state string - code string - message string + PollingMethod PollingMethodType `json:"pollingMethod"` + URI string `json:"uri"` + State string `json:"state"` + Code string `json:"code"` + Message string `json:"message"` } func (ps pollingState) hasSucceeded() bool { - return hasSucceeded(ps.state) + return hasSucceeded(ps.State) } func (ps pollingState) hasTerminated() bool { - return hasTerminated(ps.state) + return hasTerminated(ps.State) } func (ps pollingState) hasFailed() bool { - return hasFailed(ps.state) + return hasFailed(ps.State) } func (ps pollingState) Error() string { - return fmt.Sprintf("Long running operation terminated with status '%s': Code=%q Message=%q", ps.state, ps.code, ps.message) + return fmt.Sprintf("Long running operation terminated with status '%s': Code=%q Message=%q", ps.State, ps.Code, ps.Message) } // updatePollingState maps the operation status -- retrieved from either a provisioningState @@ -190,7 +353,7 @@ func updatePollingState(resp *http.Response, ps *pollingState) error { // -- The first response will always be a provisioningStatus response; only the polling requests, // depending on the header returned, may be something otherwise. var pt provisioningTracker - if ps.responseFormat == usesOperationResponse { + if ps.PollingMethod == PollingAsyncOperation { pt = &operationResource{} } else { pt = &provisioningStatus{} @@ -198,30 +361,30 @@ func updatePollingState(resp *http.Response, ps *pollingState) error { // If this is the first request (that is, the polling response shape is unknown), determine how // to poll and what to expect - if ps.responseFormat == formatIsUnknown { + if ps.PollingMethod == PollingUnknown { req := resp.Request if req == nil { return autorest.NewError("azure", "updatePollingState", "Azure Polling Error - Original HTTP request is missing") } // Prefer the Azure-AsyncOperation header - ps.uri = getAsyncOperation(resp) - if ps.uri != "" { - ps.responseFormat = usesOperationResponse + ps.URI = getAsyncOperation(resp) + if ps.URI != "" { + ps.PollingMethod = PollingAsyncOperation } else { - ps.responseFormat = usesProvisioningStatus + ps.PollingMethod = PollingLocation } // Else, use the Location header - if ps.uri == "" { - ps.uri = autorest.GetLocation(resp) + if ps.URI == "" { + ps.URI = autorest.GetLocation(resp) } // Lastly, requests against an existing resource, use the last request URI - if ps.uri == "" { + if ps.URI == "" { m := strings.ToUpper(req.Method) if m == http.MethodPatch || m == http.MethodPut || m == http.MethodGet { - ps.uri = req.URL.String() + ps.URI = req.URL.String() } } } @@ -242,23 +405,23 @@ func updatePollingState(resp *http.Response, ps *pollingState) error { // -- Unknown states are per-service inprogress states // -- Otherwise, infer state from HTTP status code if pt.hasTerminated() { - ps.state = pt.state() + ps.State = pt.state() } else if pt.state() != "" { - ps.state = operationInProgress + ps.State = operationInProgress } else { switch resp.StatusCode { case http.StatusAccepted: - ps.state = operationInProgress + ps.State = operationInProgress case http.StatusNoContent, http.StatusCreated, http.StatusOK: - ps.state = operationSucceeded + ps.State = operationSucceeded default: - ps.state = operationFailed + ps.State = operationFailed } } - if ps.state == operationInProgress && ps.uri == "" { + if strings.EqualFold(ps.State, operationInProgress) && ps.URI == "" { return autorest.NewError("azure", "updatePollingState", "Azure Polling Error - Unable to obtain polling URI for %s %s", resp.Request.Method, resp.Request.URL) } @@ -267,35 +430,30 @@ func updatePollingState(resp *http.Response, ps *pollingState) error { // -- Response // -- Otherwise, Unknown if ps.hasFailed() { - if ps.responseFormat == usesOperationResponse { + if ps.PollingMethod == PollingAsyncOperation { or := pt.(*operationResource) - ps.code = or.OperationError.Code - ps.message = or.OperationError.Message + ps.Code = or.OperationError.Code + ps.Message = or.OperationError.Message } else { p := pt.(*provisioningStatus) if p.hasProvisioningError() { - ps.code = p.ProvisioningError.Code - ps.message = p.ProvisioningError.Message + ps.Code = p.ProvisioningError.Code + ps.Message = p.ProvisioningError.Message } else { - ps.code = "Unknown" - ps.message = "None" + ps.Code = "Unknown" + ps.Message = "None" } } } return nil } -func newPollingRequest(resp *http.Response, ps pollingState) (*http.Request, error) { - req := resp.Request - if req == nil { - return nil, autorest.NewError("azure", "newPollingRequest", "Azure Polling Error - Original HTTP request is missing") - } - - reqPoll, err := autorest.Prepare(&http.Request{Cancel: req.Cancel}, +func newPollingRequest(ps pollingState) (*http.Request, error) { + reqPoll, err := autorest.Prepare(&http.Request{}, autorest.AsGet(), - autorest.WithBaseURL(ps.uri)) + autorest.WithBaseURL(ps.URI)) if err != nil { - return nil, autorest.NewErrorWithError(err, "azure", "newPollingRequest", nil, "Failure creating poll request to %s", ps.uri) + return nil, autorest.NewErrorWithError(err, "azure", "newPollingRequest", nil, "Failure creating poll request to %s", ps.URI) } return reqPoll, nil diff --git a/vendor/github.com/Azure/go-autorest/autorest/azure/azure.go b/vendor/github.com/Azure/go-autorest/autorest/azure/azure.go index 3f4d13421aac..fa18356476b9 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/azure/azure.go +++ b/vendor/github.com/Azure/go-autorest/autorest/azure/azure.go @@ -5,6 +5,20 @@ See the included examples for more detail. */ package azure +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "encoding/json" "fmt" @@ -165,7 +179,13 @@ func WithErrorUnlessStatusCode(codes ...int) autorest.RespondDecorator { if decodeErr != nil { return fmt.Errorf("autorest/azure: error response cannot be parsed: %q error: %v", b.String(), decodeErr) } else if e.ServiceError == nil { - e.ServiceError = &ServiceError{Code: "Unknown", Message: "Unknown service error"} + // Check if error is unwrapped ServiceError + if err := json.Unmarshal(b.Bytes(), &e.ServiceError); err != nil || e.ServiceError.Message == "" { + e.ServiceError = &ServiceError{ + Code: "Unknown", + Message: "Unknown service error", + } + } } e.RequestID = ExtractRequestID(resp) diff --git a/vendor/github.com/Azure/go-autorest/autorest/azure/cli/profile.go b/vendor/github.com/Azure/go-autorest/autorest/azure/cli/profile.go index b5b897c7df9e..3e226fe9b265 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/azure/cli/profile.go +++ b/vendor/github.com/Azure/go-autorest/autorest/azure/cli/profile.go @@ -1,5 +1,19 @@ package cli +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "bytes" "encoding/json" diff --git a/vendor/github.com/Azure/go-autorest/autorest/azure/cli/token.go b/vendor/github.com/Azure/go-autorest/autorest/azure/cli/token.go index a1f3af1517f0..83b81c34bf8d 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/azure/cli/token.go +++ b/vendor/github.com/Azure/go-autorest/autorest/azure/cli/token.go @@ -1,5 +1,19 @@ package cli +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "encoding/json" "fmt" @@ -48,8 +62,19 @@ func (t Token) ToADALToken() (converted adal.Token, err error) { } // AccessTokensPath returns the path where access tokens are stored from the Azure CLI +// TODO(#199): add unit test. func AccessTokensPath() (string, error) { - return homedir.Expand("~/.azure/accessTokens.json") + // Azure-CLI allows user to customize the path of access tokens thorugh environment variable. + var accessTokenPath = os.Getenv("AZURE_ACCESS_TOKEN_FILE") + var err error + + // Fallback logic to default path on non-cloud-shell environment. + // TODO(#200): remove the dependency on hard-coding path. + if accessTokenPath == "" { + accessTokenPath, err = homedir.Expand("~/.azure/accessTokens.json") + } + + return accessTokenPath, err } // ParseExpirationDate parses either a Azure CLI or CloudShell date into a time object diff --git a/vendor/github.com/Azure/go-autorest/autorest/azure/environments.go b/vendor/github.com/Azure/go-autorest/autorest/azure/environments.go index 1cf55651f2a4..efdab6a110cf 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/azure/environments.go +++ b/vendor/github.com/Azure/go-autorest/autorest/azure/environments.go @@ -1,10 +1,31 @@ package azure +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( + "encoding/json" "fmt" + "io/ioutil" + "os" "strings" ) +// EnvironmentFilepathName captures the name of the environment variable containing the path to the file +// to be used while populating the Azure Environment. +const EnvironmentFilepathName = "AZURE_ENVIRONMENT_FILEPATH" + var environments = map[string]Environment{ "AZURECHINACLOUD": ChinaCloud, "AZUREGERMANCLOUD": GermanCloud, @@ -119,12 +140,37 @@ var ( } ) -// EnvironmentFromName returns an Environment based on the common name specified +// EnvironmentFromName returns an Environment based on the common name specified. func EnvironmentFromName(name string) (Environment, error) { + // IMPORTANT + // As per @radhikagupta5: + // This is technical debt, fundamentally here because Kubernetes is not currently accepting + // contributions to the providers. Once that is an option, the provider should be updated to + // directly call `EnvironmentFromFile`. Until then, we rely on dispatching Azure Stack environment creation + // from this method based on the name that is provided to us. + if strings.EqualFold(name, "AZURESTACKCLOUD") { + return EnvironmentFromFile(os.Getenv(EnvironmentFilepathName)) + } + name = strings.ToUpper(name) env, ok := environments[name] if !ok { return env, fmt.Errorf("autorest/azure: There is no cloud environment matching the name %q", name) } + return env, nil } + +// EnvironmentFromFile loads an Environment from a configuration file available on disk. +// This function is particularly useful in the Hybrid Cloud model, where one must define their own +// endpoints. +func EnvironmentFromFile(location string) (unmarshaled Environment, err error) { + fileContents, err := ioutil.ReadFile(location) + if err != nil { + return + } + + err = json.Unmarshal(fileContents, &unmarshaled) + + return +} diff --git a/vendor/github.com/Azure/go-autorest/autorest/azure/rp.go b/vendor/github.com/Azure/go-autorest/autorest/azure/rp.go new file mode 100644 index 000000000000..66d1c8c2b3b9 --- /dev/null +++ b/vendor/github.com/Azure/go-autorest/autorest/azure/rp.go @@ -0,0 +1,203 @@ +// Copyright 2017 Microsoft Corporation +// +// 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 ( + "errors" + "fmt" + "net/http" + "net/url" + "strings" + "time" + + "github.com/Azure/go-autorest/autorest" +) + +// DoRetryWithRegistration tries to register the resource provider in case it is unregistered. +// It also handles request retries +func DoRetryWithRegistration(client autorest.Client) autorest.SendDecorator { + return func(s autorest.Sender) autorest.Sender { + return autorest.SenderFunc(func(r *http.Request) (resp *http.Response, err error) { + rr := autorest.NewRetriableRequest(r) + for currentAttempt := 0; currentAttempt < client.RetryAttempts; currentAttempt++ { + err = rr.Prepare() + if err != nil { + return resp, err + } + + resp, err = autorest.SendWithSender(s, rr.Request(), + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...), + ) + if err != nil { + return resp, err + } + + if resp.StatusCode != http.StatusConflict { + return resp, err + } + var re RequestError + err = autorest.Respond( + resp, + autorest.ByUnmarshallingJSON(&re), + ) + if err != nil { + return resp, err + } + err = re + + if re.ServiceError != nil && re.ServiceError.Code == "MissingSubscriptionRegistration" { + regErr := register(client, r, re) + if regErr != nil { + return resp, fmt.Errorf("failed auto registering Resource Provider: %s. Original error: %s", regErr, err) + } + } + } + return resp, fmt.Errorf("failed request: %s", err) + }) + } +} + +func getProvider(re RequestError) (string, error) { + if re.ServiceError != nil { + if re.ServiceError.Details != nil && len(*re.ServiceError.Details) > 0 { + detail := (*re.ServiceError.Details)[0].(map[string]interface{}) + return detail["target"].(string), nil + } + } + return "", errors.New("provider was not found in the response") +} + +func register(client autorest.Client, originalReq *http.Request, re RequestError) error { + subID := getSubscription(originalReq.URL.Path) + if subID == "" { + return errors.New("missing parameter subscriptionID to register resource provider") + } + providerName, err := getProvider(re) + if err != nil { + return fmt.Errorf("missing parameter provider to register resource provider: %s", err) + } + newURL := url.URL{ + Scheme: originalReq.URL.Scheme, + Host: originalReq.URL.Host, + } + + // taken from the resources SDK + // with almost identical code, this sections are easier to mantain + // It is also not a good idea to import the SDK here + // https://github.com/Azure/azure-sdk-for-go/blob/9f366792afa3e0ddaecdc860e793ba9d75e76c27/arm/resources/resources/providers.go#L252 + pathParameters := map[string]interface{}{ + "resourceProviderNamespace": autorest.Encode("path", providerName), + "subscriptionId": autorest.Encode("path", subID), + } + + const APIVersion = "2016-09-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsPost(), + autorest.WithBaseURL(newURL.String()), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/{resourceProviderNamespace}/register", pathParameters), + autorest.WithQueryParameters(queryParameters), + ) + + req, err := preparer.Prepare(&http.Request{}) + if err != nil { + return err + } + req.Cancel = originalReq.Cancel + + resp, err := autorest.SendWithSender(client, req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...), + ) + if err != nil { + return err + } + + type Provider struct { + RegistrationState *string `json:"registrationState,omitempty"` + } + var provider Provider + + err = autorest.Respond( + resp, + WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&provider), + autorest.ByClosing(), + ) + if err != nil { + return err + } + + // poll for registered provisioning state + now := time.Now() + for err == nil && time.Since(now) < client.PollingDuration { + // taken from the resources SDK + // https://github.com/Azure/azure-sdk-for-go/blob/9f366792afa3e0ddaecdc860e793ba9d75e76c27/arm/resources/resources/providers.go#L45 + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(newURL.String()), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/{resourceProviderNamespace}", pathParameters), + autorest.WithQueryParameters(queryParameters), + ) + req, err = preparer.Prepare(&http.Request{}) + if err != nil { + return err + } + req.Cancel = originalReq.Cancel + + resp, err := autorest.SendWithSender(client.Sender, req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...), + ) + if err != nil { + return err + } + + err = autorest.Respond( + resp, + WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&provider), + autorest.ByClosing(), + ) + if err != nil { + return err + } + + if provider.RegistrationState != nil && + *provider.RegistrationState == "Registered" { + break + } + + delayed := autorest.DelayWithRetryAfter(resp, originalReq.Cancel) + if !delayed { + autorest.DelayForBackoff(client.PollingDelay, 0, originalReq.Cancel) + } + } + if !(time.Since(now) < client.PollingDuration) { + return errors.New("polling for resource provider registration has exceeded the polling duration") + } + return err +} + +func getSubscription(path string) string { + parts := strings.Split(path, "/") + for i, v := range parts { + if v == "subscriptions" && (i+1) < len(parts) { + return parts[i+1] + } + } + return "" +} diff --git a/vendor/github.com/Azure/go-autorest/autorest/client.go b/vendor/github.com/Azure/go-autorest/autorest/client.go index 5f1e72fbe4df..9eebd83bf84c 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/client.go +++ b/vendor/github.com/Azure/go-autorest/autorest/client.go @@ -1,5 +1,19 @@ package autorest +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "bytes" "fmt" @@ -21,6 +35,9 @@ const ( // DefaultRetryAttempts is number of attempts for retry status codes (5xx). DefaultRetryAttempts = 3 + + // DefaultRetryDuration is the duration to wait between retries. + DefaultRetryDuration = 30 * time.Second ) var ( @@ -33,7 +50,8 @@ var ( Version(), ) - statusCodesForRetry = []int{ + // StatusCodesForRetry are a defined group of status code for which the client will retry + StatusCodesForRetry = []int{ http.StatusRequestTimeout, // 408 http.StatusTooManyRequests, // 429 http.StatusInternalServerError, // 500 @@ -157,9 +175,10 @@ func NewClientWithUserAgent(ua string) Client { PollingDelay: DefaultPollingDelay, PollingDuration: DefaultPollingDuration, RetryAttempts: DefaultRetryAttempts, - RetryDuration: 30 * time.Second, + RetryDuration: DefaultRetryDuration, UserAgent: defaultUserAgent, } + c.Sender = c.sender() c.AddToUserAgent(ua) return c } @@ -187,10 +206,9 @@ func (c Client) Do(r *http.Request) (*http.Response, error) { if err != nil { return nil, NewErrorWithError(err, "autorest/Client", "Do", nil, "Preparing request failed") } - resp, err := SendWithSender(c.sender(), r, - DoRetryForStatusCodes(c.RetryAttempts, c.RetryDuration, statusCodesForRetry...)) - Respond(resp, - c.ByInspecting()) + + resp, err := SendWithSender(c.sender(), r) + Respond(resp, c.ByInspecting()) return resp, err } diff --git a/vendor/github.com/Azure/go-autorest/autorest/date/date.go b/vendor/github.com/Azure/go-autorest/autorest/date/date.go index 80ca60e9b08a..c4571065685a 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/date/date.go +++ b/vendor/github.com/Azure/go-autorest/autorest/date/date.go @@ -5,6 +5,20 @@ time.Time types. And both convert to time.Time through a ToTime method. */ package date +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "fmt" "time" diff --git a/vendor/github.com/Azure/go-autorest/autorest/date/time.go b/vendor/github.com/Azure/go-autorest/autorest/date/time.go index c1af6296348d..b453fad0491e 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/date/time.go +++ b/vendor/github.com/Azure/go-autorest/autorest/date/time.go @@ -1,5 +1,19 @@ package date +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "regexp" "time" diff --git a/vendor/github.com/Azure/go-autorest/autorest/date/timerfc1123.go b/vendor/github.com/Azure/go-autorest/autorest/date/timerfc1123.go index 11995fb9f2c5..48fb39ba9b9a 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/date/timerfc1123.go +++ b/vendor/github.com/Azure/go-autorest/autorest/date/timerfc1123.go @@ -1,5 +1,19 @@ package date +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "errors" "time" diff --git a/vendor/github.com/Azure/go-autorest/autorest/date/unixtime.go b/vendor/github.com/Azure/go-autorest/autorest/date/unixtime.go index e085c77eea50..7073959b2a9c 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/date/unixtime.go +++ b/vendor/github.com/Azure/go-autorest/autorest/date/unixtime.go @@ -1,5 +1,19 @@ package date +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "bytes" "encoding/binary" diff --git a/vendor/github.com/Azure/go-autorest/autorest/date/utility.go b/vendor/github.com/Azure/go-autorest/autorest/date/utility.go index 207b1a240a3a..12addf0ebb4b 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/date/utility.go +++ b/vendor/github.com/Azure/go-autorest/autorest/date/utility.go @@ -1,5 +1,19 @@ package date +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "strings" "time" diff --git a/vendor/github.com/Azure/go-autorest/autorest/error.go b/vendor/github.com/Azure/go-autorest/autorest/error.go index aaef2ac8ec04..f724f33327ed 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/error.go +++ b/vendor/github.com/Azure/go-autorest/autorest/error.go @@ -1,5 +1,19 @@ package autorest +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "fmt" "net/http" diff --git a/vendor/github.com/Azure/go-autorest/autorest/preparer.go b/vendor/github.com/Azure/go-autorest/autorest/preparer.go index afd114821bc7..2290c4010032 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/preparer.go +++ b/vendor/github.com/Azure/go-autorest/autorest/preparer.go @@ -1,5 +1,19 @@ package autorest +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "bytes" "encoding/json" diff --git a/vendor/github.com/Azure/go-autorest/autorest/responder.go b/vendor/github.com/Azure/go-autorest/autorest/responder.go index 87f71e5854b5..a908a0adb708 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/responder.go +++ b/vendor/github.com/Azure/go-autorest/autorest/responder.go @@ -1,5 +1,19 @@ package autorest +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "bytes" "encoding/json" diff --git a/vendor/github.com/Azure/go-autorest/autorest/retriablerequest.go b/vendor/github.com/Azure/go-autorest/autorest/retriablerequest.go index 0ab1eb3003c9..fa11dbed79b1 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/retriablerequest.go +++ b/vendor/github.com/Azure/go-autorest/autorest/retriablerequest.go @@ -1,5 +1,19 @@ package autorest +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "bytes" "io" diff --git a/vendor/github.com/Azure/go-autorest/autorest/retriablerequest_1.7.go b/vendor/github.com/Azure/go-autorest/autorest/retriablerequest_1.7.go index e28eb2cbdbf9..7143cc61b58b 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/retriablerequest_1.7.go +++ b/vendor/github.com/Azure/go-autorest/autorest/retriablerequest_1.7.go @@ -1,17 +1,31 @@ // +build !go1.8 +// Copyright 2017 Microsoft Corporation +// +// 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 autorest import ( "bytes" + "io/ioutil" "net/http" ) // RetriableRequest provides facilities for retrying an HTTP request. type RetriableRequest struct { - req *http.Request - br *bytes.Reader - reset bool + req *http.Request + br *bytes.Reader } // Prepare signals that the request is about to be sent. @@ -19,21 +33,17 @@ func (rr *RetriableRequest) Prepare() (err error) { // preserve the request body; this is to support retry logic as // the underlying transport will always close the reqeust body if rr.req.Body != nil { - if rr.reset { - if rr.br != nil { - _, err = rr.br.Seek(0, 0 /*io.SeekStart*/) - } - rr.reset = false - if err != nil { - return err - } + if rr.br != nil { + _, err = rr.br.Seek(0, 0 /*io.SeekStart*/) + rr.req.Body = ioutil.NopCloser(rr.br) + } + if err != nil { + return err } if rr.br == nil { // fall back to making a copy (only do this once) err = rr.prepareFromByteReader() } - // indicates that the request body needs to be reset - rr.reset = true } return err } diff --git a/vendor/github.com/Azure/go-autorest/autorest/retriablerequest_1.8.go b/vendor/github.com/Azure/go-autorest/autorest/retriablerequest_1.8.go index 8c1d1aec8d94..ae15c6bf9629 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/retriablerequest_1.8.go +++ b/vendor/github.com/Azure/go-autorest/autorest/retriablerequest_1.8.go @@ -1,19 +1,33 @@ // +build go1.8 +// Copyright 2017 Microsoft Corporation +// +// 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 autorest import ( "bytes" "io" + "io/ioutil" "net/http" ) // RetriableRequest provides facilities for retrying an HTTP request. type RetriableRequest struct { - req *http.Request - rc io.ReadCloser - br *bytes.Reader - reset bool + req *http.Request + rc io.ReadCloser + br *bytes.Reader } // Prepare signals that the request is about to be sent. @@ -21,16 +35,14 @@ func (rr *RetriableRequest) Prepare() (err error) { // preserve the request body; this is to support retry logic as // the underlying transport will always close the reqeust body if rr.req.Body != nil { - if rr.reset { - if rr.rc != nil { - rr.req.Body = rr.rc - } else if rr.br != nil { - _, err = rr.br.Seek(0, io.SeekStart) - } - rr.reset = false - if err != nil { - return err - } + if rr.rc != nil { + rr.req.Body = rr.rc + } else if rr.br != nil { + _, err = rr.br.Seek(0, io.SeekStart) + rr.req.Body = ioutil.NopCloser(rr.br) + } + if err != nil { + return err } if rr.req.GetBody != nil { // this will allow us to preserve the body without having to @@ -43,8 +55,6 @@ func (rr *RetriableRequest) Prepare() (err error) { // fall back to making a copy (only do this once) err = rr.prepareFromByteReader() } - // indicates that the request body needs to be reset - rr.reset = true } return err } diff --git a/vendor/github.com/Azure/go-autorest/autorest/sender.go b/vendor/github.com/Azure/go-autorest/autorest/sender.go index 94b02984792e..e1ec49573ff8 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/sender.go +++ b/vendor/github.com/Azure/go-autorest/autorest/sender.go @@ -1,5 +1,19 @@ package autorest +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "fmt" "log" @@ -207,7 +221,8 @@ func DoRetryForStatusCodes(attempts int, backoff time.Duration, codes ...int) Se return resp, err } resp, err = s.Do(rr.Request()) - if err != nil || !ResponseHasStatusCode(resp, codes...) { + // we want to retry if err is not nil (e.g. transient network failure) + if err == nil && !ResponseHasStatusCode(resp, codes...) { return resp, err } delayed := DelayWithRetryAfter(resp, r.Cancel) @@ -223,6 +238,9 @@ func DoRetryForStatusCodes(attempts int, backoff time.Duration, codes ...int) Se // DelayWithRetryAfter invokes time.After for the duration specified in the "Retry-After" header in // responses with status code 429 func DelayWithRetryAfter(resp *http.Response, cancel <-chan struct{}) bool { + if resp == nil { + return false + } retryAfter, _ := strconv.Atoi(resp.Header.Get("Retry-After")) if resp.StatusCode == http.StatusTooManyRequests && retryAfter > 0 { select { diff --git a/vendor/github.com/Azure/go-autorest/autorest/to/convert.go b/vendor/github.com/Azure/go-autorest/autorest/to/convert.go index 7b180b866b90..fdda2ce1aa8e 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/to/convert.go +++ b/vendor/github.com/Azure/go-autorest/autorest/to/convert.go @@ -3,6 +3,20 @@ Package to provides helpers to ease working with pointer values of marshalled st */ package to +// Copyright 2017 Microsoft Corporation +// +// 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. + // String returns a string value for the passed string pointer. It returns the empty string if the // pointer is nil. func String(s *string) string { diff --git a/vendor/github.com/Azure/go-autorest/autorest/utility.go b/vendor/github.com/Azure/go-autorest/autorest/utility.go index 78067148b28d..1ef4575fa0bf 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/utility.go +++ b/vendor/github.com/Azure/go-autorest/autorest/utility.go @@ -1,11 +1,26 @@ package autorest +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "bytes" "encoding/json" "encoding/xml" "fmt" "io" + "net/http" "net/url" "reflect" "sort" @@ -176,3 +191,14 @@ func createQuery(v url.Values) string { } return buf.String() } + +// ChangeToGet turns the specified http.Request into a GET (it assumes it wasn't). +// This is mainly useful for long-running operations that use the Azure-AsyncOperation +// header, so we change the initial PUT into a GET to retrieve the final result. +func ChangeToGet(req *http.Request) *http.Request { + req.Method = "GET" + req.Body = nil + req.ContentLength = 0 + req.Header.Del("Content-Length") + return req +} diff --git a/vendor/github.com/Azure/go-autorest/autorest/validation/validation.go b/vendor/github.com/Azure/go-autorest/autorest/validation/validation.go index 38f0074d0abc..3fe62c93056d 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/validation/validation.go +++ b/vendor/github.com/Azure/go-autorest/autorest/validation/validation.go @@ -3,6 +3,20 @@ Package validation provides methods for validating parameter value using reflect */ package validation +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "fmt" "reflect" @@ -91,15 +105,12 @@ func validateStruct(x reflect.Value, v Constraint, name ...string) error { return createError(x, v, fmt.Sprintf("field %q doesn't exist", v.Target)) } - if err := Validate([]Validation{ + return Validate([]Validation{ { TargetValue: getInterfaceValue(f), Constraints: []Constraint{v}, }, - }); err != nil { - return err - } - return nil + }) } func validatePtr(x reflect.Value, v Constraint) error { diff --git a/vendor/github.com/Azure/go-autorest/autorest/version.go b/vendor/github.com/Azure/go-autorest/autorest/version.go index a222e8efaaf9..f588807dbb9c 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/version.go +++ b/vendor/github.com/Azure/go-autorest/autorest/version.go @@ -1,5 +1,19 @@ package autorest +// Copyright 2017 Microsoft Corporation +// +// 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. + import ( "bytes" "fmt" diff --git a/vendor/vendor.json b/vendor/vendor.json index c713a5e3d24f..280f34ba691b 100644 --- a/vendor/vendor.json +++ b/vendor/vendor.json @@ -251,67 +251,67 @@ "versionExact": "v11.1.0-beta" }, { - "checksumSHA1": "+4d+Y67AMKKuyR1EO33Zdt+RVx0=", - "comment": "v8.4.0", + "checksumSHA1": "tXSzwlsAPETo3wSlIX6o8GqGZLY=", + "comment": "v9.4.1", "path": "github.com/Azure/go-autorest/autorest", - "revision": "f6be1abbb5abd0517522f850dd785990d373da7e", - "revisionTime": "2017-09-13T23:19:17Z", - "version": "v8.4.0", - "versionExact": "v8.4.0" + "revision": "c67b24a8e30d876542a85022ebbdecf0e5a935e8", + "revisionTime": "2017-11-17T21:15:24Z", + "version": "v9.4.1", + "versionExact": "v9.4.1" }, { - "checksumSHA1": "7G4HgRaIT25bgz/hPtXG6Kv8Fho=", - "comment": "v8.4.0", + "checksumSHA1": "Ktj3H1WpOqxnC9kdAA+F7Ol7/RQ=", + "comment": "v9.4.1", "path": "github.com/Azure/go-autorest/autorest/adal", - "revision": "f6be1abbb5abd0517522f850dd785990d373da7e", - "revisionTime": "2017-09-13T23:19:17Z", - "version": "v8.4.0", - "versionExact": "v8.4.0" + "revision": "c67b24a8e30d876542a85022ebbdecf0e5a935e8", + "revisionTime": "2017-11-17T21:15:24Z", + "version": "v9.4.1", + "versionExact": "v9.4.1" }, { - "checksumSHA1": "2KdBFgT4qY+fMOkBTa5vA9V0AiM=", - "comment": "v8.4.0", + "checksumSHA1": "zXyLmDVpkYkIsL0yinNLoW82IZc=", + "comment": "v9.4.1", "path": "github.com/Azure/go-autorest/autorest/azure", - "revision": "f6be1abbb5abd0517522f850dd785990d373da7e", - "revisionTime": "2017-09-13T23:19:17Z", - "version": "v8.4.0", - "versionExact": "v8.4.0" + "revision": "c67b24a8e30d876542a85022ebbdecf0e5a935e8", + "revisionTime": "2017-11-17T21:15:24Z", + "version": "v9.4.1", + "versionExact": "v9.4.1" }, { - "checksumSHA1": "apxw17Dm1naEXMbVDCRnEDkQDQ8=", - "comment": "v8.4.0", + "checksumSHA1": "+nXRwVB/JVEGe+oLsFhCmSkKPuI=", + "comment": "v9.4.1", "path": "github.com/Azure/go-autorest/autorest/azure/cli", - "revision": "f6be1abbb5abd0517522f850dd785990d373da7e", - "revisionTime": "2017-09-13T23:19:17Z", - "version": "v8.4.0", - "versionExact": "v8.4.0" + "revision": "c67b24a8e30d876542a85022ebbdecf0e5a935e8", + "revisionTime": "2017-11-17T21:15:24Z", + "version": "v9.4.1", + "versionExact": "v9.4.1" }, { - "checksumSHA1": "LSF/pNrjhIxl6jiS6bKooBFCOxI=", - "comment": "v8.4.0", + "checksumSHA1": "9nXCi9qQsYjxCeajJKWttxgEt0I=", + "comment": "v9.4.1", "path": "github.com/Azure/go-autorest/autorest/date", - "revision": "f6be1abbb5abd0517522f850dd785990d373da7e", - "revisionTime": "2017-09-13T23:19:17Z", - "version": "v8.4.0", - "versionExact": "v8.4.0" + "revision": "c67b24a8e30d876542a85022ebbdecf0e5a935e8", + "revisionTime": "2017-11-17T21:15:24Z", + "version": "v9.4.1", + "versionExact": "v9.4.1" }, { - "checksumSHA1": "Ev8qCsbFjDlMlX0N2tYAhYQFpUc=", - "comment": "v8.4.0", + "checksumSHA1": "SbBb2GcJNm5GjuPKGL2777QywR4=", + "comment": "v9.4.1", "path": "github.com/Azure/go-autorest/autorest/to", - "revision": "f6be1abbb5abd0517522f850dd785990d373da7e", - "revisionTime": "2017-09-13T23:19:17Z", - "version": "v8.4.0", - "versionExact": "v8.4.0" + "revision": "c67b24a8e30d876542a85022ebbdecf0e5a935e8", + "revisionTime": "2017-11-17T21:15:24Z", + "version": "v9.4.1", + "versionExact": "v9.4.1" }, { - "checksumSHA1": "rGkTfIycpeix5TAbZS74ceGAPHI=", - "comment": "v8.4.0", + "checksumSHA1": "HfqZyKllcHQDvTwgCaYL1jUPmW0=", + "comment": "v9.4.1", "path": "github.com/Azure/go-autorest/autorest/validation", - "revision": "f6be1abbb5abd0517522f850dd785990d373da7e", - "revisionTime": "2017-09-13T23:19:17Z", - "version": "v8.4.0", - "versionExact": "v8.4.0" + "revision": "c67b24a8e30d876542a85022ebbdecf0e5a935e8", + "revisionTime": "2017-11-17T21:15:24Z", + "version": "v9.4.1", + "versionExact": "v9.4.1" }, { "checksumSHA1": "FIL83loX9V9APvGQIjJpbxq53F0=", From 5b802d493c6db5358d2a5f1a65caf9ae7bc79b31 Mon Sep 17 00:00:00 2001 From: tombuildsstuff Date: Sat, 18 Nov 2017 08:06:13 +0000 Subject: [PATCH 16/55] Vendoring the Locks SDK --- .../arm/resources/locks/client.go | 51 + .../arm/resources/locks/managementlocks.go | 1356 +++++++++++++++++ .../arm/resources/locks/models.go | 76 + .../arm/resources/locks/version.go | 28 + vendor/vendor.json | 8 + 5 files changed, 1519 insertions(+) create mode 100755 vendor/github.com/Azure/azure-sdk-for-go/arm/resources/locks/client.go create mode 100755 vendor/github.com/Azure/azure-sdk-for-go/arm/resources/locks/managementlocks.go create mode 100755 vendor/github.com/Azure/azure-sdk-for-go/arm/resources/locks/models.go create mode 100755 vendor/github.com/Azure/azure-sdk-for-go/arm/resources/locks/version.go diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/locks/client.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/locks/client.go new file mode 100755 index 000000000000..0b70ea01fc31 --- /dev/null +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/locks/client.go @@ -0,0 +1,51 @@ +// Package locks implements the Azure ARM Locks service API version 2016-09-01. +// +// Azure resources can be locked to prevent other users in your organization from deleting or modifying resources. +package locks + +// Copyright (c) Microsoft and contributors. All rights reserved. +// +// 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. +// +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +import ( + "github.com/Azure/go-autorest/autorest" +) + +const ( + // DefaultBaseURI is the default URI used for the service Locks + DefaultBaseURI = "https://management.azure.com" +) + +// ManagementClient is the base client for Locks. +type ManagementClient struct { + autorest.Client + BaseURI string + SubscriptionID string +} + +// New creates an instance of the ManagementClient client. +func New(subscriptionID string) ManagementClient { + return NewWithBaseURI(DefaultBaseURI, subscriptionID) +} + +// NewWithBaseURI creates an instance of the ManagementClient client. +func NewWithBaseURI(baseURI string, subscriptionID string) ManagementClient { + return ManagementClient{ + Client: autorest.NewClientWithUserAgent(UserAgent()), + BaseURI: baseURI, + SubscriptionID: subscriptionID, + } +} diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/locks/managementlocks.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/locks/managementlocks.go new file mode 100755 index 000000000000..6f4699dc5375 --- /dev/null +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/locks/managementlocks.go @@ -0,0 +1,1356 @@ +package locks + +// Copyright (c) Microsoft and contributors. All rights reserved. +// +// 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. +// +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +import ( + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "net/http" +) + +// ManagementLocksClient is the azure resources can be locked to prevent other users in your organization from deleting +// or modifying resources. +type ManagementLocksClient struct { + ManagementClient +} + +// NewManagementLocksClient creates an instance of the ManagementLocksClient client. +func NewManagementLocksClient(subscriptionID string) ManagementLocksClient { + return NewManagementLocksClientWithBaseURI(DefaultBaseURI, subscriptionID) +} + +// NewManagementLocksClientWithBaseURI creates an instance of the ManagementLocksClient client. +func NewManagementLocksClientWithBaseURI(baseURI string, subscriptionID string) ManagementLocksClient { + return ManagementLocksClient{NewWithBaseURI(baseURI, subscriptionID)} +} + +// CreateOrUpdateAtResourceGroupLevel when you apply a lock at a parent scope, all child resources inherit the same +// lock. To create management locks, you must have access to Microsoft.Authorization/* or +// Microsoft.Authorization/locks/* actions. Of the built-in roles, only Owner and User Access Administrator are granted +// those actions. +// +// resourceGroupName is the name of the resource group to lock. lockName is the lock name. The lock name can be a +// maximum of 260 characters. It cannot contain <, > %, &, :, \, ?, /, or any control characters. parameters is the +// management lock parameters. +func (client ManagementLocksClient) CreateOrUpdateAtResourceGroupLevel(resourceGroupName string, lockName string, parameters ManagementLockObject) (result ManagementLockObject, err error) { + if err := validation.Validate([]validation.Validation{ + {TargetValue: resourceGroupName, + Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, + {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, + {TargetValue: parameters, + Constraints: []validation.Constraint{{Target: "parameters.ManagementLockProperties", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { + return result, validation.NewErrorWithValidationError(err, "locks.ManagementLocksClient", "CreateOrUpdateAtResourceGroupLevel") + } + + req, err := client.CreateOrUpdateAtResourceGroupLevelPreparer(resourceGroupName, lockName, parameters) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "CreateOrUpdateAtResourceGroupLevel", nil, "Failure preparing request") + return + } + + resp, err := client.CreateOrUpdateAtResourceGroupLevelSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "CreateOrUpdateAtResourceGroupLevel", resp, "Failure sending request") + return + } + + result, err = client.CreateOrUpdateAtResourceGroupLevelResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "CreateOrUpdateAtResourceGroupLevel", resp, "Failure responding to request") + } + + return +} + +// CreateOrUpdateAtResourceGroupLevelPreparer prepares the CreateOrUpdateAtResourceGroupLevel request. +func (client ManagementLocksClient) CreateOrUpdateAtResourceGroupLevelPreparer(resourceGroupName string, lockName string, parameters ManagementLockObject) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "lockName": autorest.Encode("path", lockName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2016-09-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsJSON(), + autorest.AsPut(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Authorization/locks/{lockName}", pathParameters), + autorest.WithJSON(parameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare(&http.Request{}) +} + +// CreateOrUpdateAtResourceGroupLevelSender sends the CreateOrUpdateAtResourceGroupLevel request. The method will close the +// http.Response Body if it receives an error. +func (client ManagementLocksClient) CreateOrUpdateAtResourceGroupLevelSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req) +} + +// CreateOrUpdateAtResourceGroupLevelResponder handles the response to the CreateOrUpdateAtResourceGroupLevel request. The method always +// closes the http.Response Body. +func (client ManagementLocksClient) CreateOrUpdateAtResourceGroupLevelResponder(resp *http.Response) (result ManagementLockObject, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// CreateOrUpdateAtResourceLevel when you apply a lock at a parent scope, all child resources inherit the same lock. To +// create management locks, you must have access to Microsoft.Authorization/* or Microsoft.Authorization/locks/* +// actions. Of the built-in roles, only Owner and User Access Administrator are granted those actions. +// +// resourceGroupName is the name of the resource group containing the resource to lock. resourceProviderNamespace is +// the resource provider namespace of the resource to lock. parentResourcePath is the parent resource identity. +// resourceType is the resource type of the resource to lock. resourceName is the name of the resource to lock. +// lockName is the name of lock. The lock name can be a maximum of 260 characters. It cannot contain <, > %, &, :, \, +// ?, /, or any control characters. parameters is parameters for creating or updating a management lock. +func (client ManagementLocksClient) CreateOrUpdateAtResourceLevel(resourceGroupName string, resourceProviderNamespace string, parentResourcePath string, resourceType string, resourceName string, lockName string, parameters ManagementLockObject) (result ManagementLockObject, err error) { + if err := validation.Validate([]validation.Validation{ + {TargetValue: resourceGroupName, + Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, + {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, + {TargetValue: parameters, + Constraints: []validation.Constraint{{Target: "parameters.ManagementLockProperties", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { + return result, validation.NewErrorWithValidationError(err, "locks.ManagementLocksClient", "CreateOrUpdateAtResourceLevel") + } + + req, err := client.CreateOrUpdateAtResourceLevelPreparer(resourceGroupName, resourceProviderNamespace, parentResourcePath, resourceType, resourceName, lockName, parameters) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "CreateOrUpdateAtResourceLevel", nil, "Failure preparing request") + return + } + + resp, err := client.CreateOrUpdateAtResourceLevelSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "CreateOrUpdateAtResourceLevel", resp, "Failure sending request") + return + } + + result, err = client.CreateOrUpdateAtResourceLevelResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "CreateOrUpdateAtResourceLevel", resp, "Failure responding to request") + } + + return +} + +// CreateOrUpdateAtResourceLevelPreparer prepares the CreateOrUpdateAtResourceLevel request. +func (client ManagementLocksClient) CreateOrUpdateAtResourceLevelPreparer(resourceGroupName string, resourceProviderNamespace string, parentResourcePath string, resourceType string, resourceName string, lockName string, parameters ManagementLockObject) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "lockName": autorest.Encode("path", lockName), + "parentResourcePath": parentResourcePath, + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "resourceName": autorest.Encode("path", resourceName), + "resourceProviderNamespace": autorest.Encode("path", resourceProviderNamespace), + "resourceType": resourceType, + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2016-09-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsJSON(), + autorest.AsPut(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{parentResourcePath}/{resourceType}/{resourceName}/providers/Microsoft.Authorization/locks/{lockName}", pathParameters), + autorest.WithJSON(parameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare(&http.Request{}) +} + +// CreateOrUpdateAtResourceLevelSender sends the CreateOrUpdateAtResourceLevel request. The method will close the +// http.Response Body if it receives an error. +func (client ManagementLocksClient) CreateOrUpdateAtResourceLevelSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req) +} + +// CreateOrUpdateAtResourceLevelResponder handles the response to the CreateOrUpdateAtResourceLevel request. The method always +// closes the http.Response Body. +func (client ManagementLocksClient) CreateOrUpdateAtResourceLevelResponder(resp *http.Response) (result ManagementLockObject, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// CreateOrUpdateAtSubscriptionLevel when you apply a lock at a parent scope, all child resources inherit the same +// lock. To create management locks, you must have access to Microsoft.Authorization/* or +// Microsoft.Authorization/locks/* actions. Of the built-in roles, only Owner and User Access Administrator are granted +// those actions. +// +// lockName is the name of lock. The lock name can be a maximum of 260 characters. It cannot contain <, > %, &, :, \, +// ?, /, or any control characters. parameters is the management lock parameters. +func (client ManagementLocksClient) CreateOrUpdateAtSubscriptionLevel(lockName string, parameters ManagementLockObject) (result ManagementLockObject, err error) { + if err := validation.Validate([]validation.Validation{ + {TargetValue: parameters, + Constraints: []validation.Constraint{{Target: "parameters.ManagementLockProperties", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { + return result, validation.NewErrorWithValidationError(err, "locks.ManagementLocksClient", "CreateOrUpdateAtSubscriptionLevel") + } + + req, err := client.CreateOrUpdateAtSubscriptionLevelPreparer(lockName, parameters) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "CreateOrUpdateAtSubscriptionLevel", nil, "Failure preparing request") + return + } + + resp, err := client.CreateOrUpdateAtSubscriptionLevelSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "CreateOrUpdateAtSubscriptionLevel", resp, "Failure sending request") + return + } + + result, err = client.CreateOrUpdateAtSubscriptionLevelResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "CreateOrUpdateAtSubscriptionLevel", resp, "Failure responding to request") + } + + return +} + +// CreateOrUpdateAtSubscriptionLevelPreparer prepares the CreateOrUpdateAtSubscriptionLevel request. +func (client ManagementLocksClient) CreateOrUpdateAtSubscriptionLevelPreparer(lockName string, parameters ManagementLockObject) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "lockName": autorest.Encode("path", lockName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2016-09-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsJSON(), + autorest.AsPut(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Authorization/locks/{lockName}", pathParameters), + autorest.WithJSON(parameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare(&http.Request{}) +} + +// CreateOrUpdateAtSubscriptionLevelSender sends the CreateOrUpdateAtSubscriptionLevel request. The method will close the +// http.Response Body if it receives an error. +func (client ManagementLocksClient) CreateOrUpdateAtSubscriptionLevelSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req) +} + +// CreateOrUpdateAtSubscriptionLevelResponder handles the response to the CreateOrUpdateAtSubscriptionLevel request. The method always +// closes the http.Response Body. +func (client ManagementLocksClient) CreateOrUpdateAtSubscriptionLevelResponder(resp *http.Response) (result ManagementLockObject, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusCreated, http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// CreateOrUpdateByScope create or update a management lock by scope. +// +// scope is the scope for the lock. When providing a scope for the assignment, use '/subscriptions/{subscriptionId}' +// for subscriptions, '/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}' for resource groups, and +// '/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{parentResourcePathIfPresent}/{resourceType}/{resourceName}' +// for resources. lockName is the name of lock. parameters is create or update management lock parameters. +func (client ManagementLocksClient) CreateOrUpdateByScope(scope string, lockName string, parameters ManagementLockObject) (result ManagementLockObject, err error) { + if err := validation.Validate([]validation.Validation{ + {TargetValue: parameters, + Constraints: []validation.Constraint{{Target: "parameters.ManagementLockProperties", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { + return result, validation.NewErrorWithValidationError(err, "locks.ManagementLocksClient", "CreateOrUpdateByScope") + } + + req, err := client.CreateOrUpdateByScopePreparer(scope, lockName, parameters) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "CreateOrUpdateByScope", nil, "Failure preparing request") + return + } + + resp, err := client.CreateOrUpdateByScopeSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "CreateOrUpdateByScope", resp, "Failure sending request") + return + } + + result, err = client.CreateOrUpdateByScopeResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "CreateOrUpdateByScope", resp, "Failure responding to request") + } + + return +} + +// CreateOrUpdateByScopePreparer prepares the CreateOrUpdateByScope request. +func (client ManagementLocksClient) CreateOrUpdateByScopePreparer(scope string, lockName string, parameters ManagementLockObject) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "lockName": autorest.Encode("path", lockName), + "scope": autorest.Encode("path", scope), + } + + const APIVersion = "2016-09-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsJSON(), + autorest.AsPut(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/{scope}/providers/Microsoft.Authorization/locks/{lockName}", pathParameters), + autorest.WithJSON(parameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare(&http.Request{}) +} + +// CreateOrUpdateByScopeSender sends the CreateOrUpdateByScope request. The method will close the +// http.Response Body if it receives an error. +func (client ManagementLocksClient) CreateOrUpdateByScopeSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req) +} + +// CreateOrUpdateByScopeResponder handles the response to the CreateOrUpdateByScope request. The method always +// closes the http.Response Body. +func (client ManagementLocksClient) CreateOrUpdateByScopeResponder(resp *http.Response) (result ManagementLockObject, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// DeleteAtResourceGroupLevel to delete management locks, you must have access to Microsoft.Authorization/* or +// Microsoft.Authorization/locks/* actions. Of the built-in roles, only Owner and User Access Administrator are granted +// those actions. +// +// resourceGroupName is the name of the resource group containing the lock. lockName is the name of lock to delete. +func (client ManagementLocksClient) DeleteAtResourceGroupLevel(resourceGroupName string, lockName string) (result autorest.Response, err error) { + if err := validation.Validate([]validation.Validation{ + {TargetValue: resourceGroupName, + Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, + {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil { + return result, validation.NewErrorWithValidationError(err, "locks.ManagementLocksClient", "DeleteAtResourceGroupLevel") + } + + req, err := client.DeleteAtResourceGroupLevelPreparer(resourceGroupName, lockName) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "DeleteAtResourceGroupLevel", nil, "Failure preparing request") + return + } + + resp, err := client.DeleteAtResourceGroupLevelSender(req) + if err != nil { + result.Response = resp + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "DeleteAtResourceGroupLevel", resp, "Failure sending request") + return + } + + result, err = client.DeleteAtResourceGroupLevelResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "DeleteAtResourceGroupLevel", resp, "Failure responding to request") + } + + return +} + +// DeleteAtResourceGroupLevelPreparer prepares the DeleteAtResourceGroupLevel request. +func (client ManagementLocksClient) DeleteAtResourceGroupLevelPreparer(resourceGroupName string, lockName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "lockName": autorest.Encode("path", lockName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2016-09-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Authorization/locks/{lockName}", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare(&http.Request{}) +} + +// DeleteAtResourceGroupLevelSender sends the DeleteAtResourceGroupLevel request. The method will close the +// http.Response Body if it receives an error. +func (client ManagementLocksClient) DeleteAtResourceGroupLevelSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req) +} + +// DeleteAtResourceGroupLevelResponder handles the response to the DeleteAtResourceGroupLevel request. The method always +// closes the http.Response Body. +func (client ManagementLocksClient) DeleteAtResourceGroupLevelResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusNoContent, http.StatusOK), + autorest.ByClosing()) + result.Response = resp + return +} + +// DeleteAtResourceLevel to delete management locks, you must have access to Microsoft.Authorization/* or +// Microsoft.Authorization/locks/* actions. Of the built-in roles, only Owner and User Access Administrator are granted +// those actions. +// +// resourceGroupName is the name of the resource group containing the resource with the lock to delete. +// resourceProviderNamespace is the resource provider namespace of the resource with the lock to delete. +// parentResourcePath is the parent resource identity. resourceType is the resource type of the resource with the lock +// to delete. resourceName is the name of the resource with the lock to delete. lockName is the name of the lock to +// delete. +func (client ManagementLocksClient) DeleteAtResourceLevel(resourceGroupName string, resourceProviderNamespace string, parentResourcePath string, resourceType string, resourceName string, lockName string) (result autorest.Response, err error) { + if err := validation.Validate([]validation.Validation{ + {TargetValue: resourceGroupName, + Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, + {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil { + return result, validation.NewErrorWithValidationError(err, "locks.ManagementLocksClient", "DeleteAtResourceLevel") + } + + req, err := client.DeleteAtResourceLevelPreparer(resourceGroupName, resourceProviderNamespace, parentResourcePath, resourceType, resourceName, lockName) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "DeleteAtResourceLevel", nil, "Failure preparing request") + return + } + + resp, err := client.DeleteAtResourceLevelSender(req) + if err != nil { + result.Response = resp + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "DeleteAtResourceLevel", resp, "Failure sending request") + return + } + + result, err = client.DeleteAtResourceLevelResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "DeleteAtResourceLevel", resp, "Failure responding to request") + } + + return +} + +// DeleteAtResourceLevelPreparer prepares the DeleteAtResourceLevel request. +func (client ManagementLocksClient) DeleteAtResourceLevelPreparer(resourceGroupName string, resourceProviderNamespace string, parentResourcePath string, resourceType string, resourceName string, lockName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "lockName": autorest.Encode("path", lockName), + "parentResourcePath": parentResourcePath, + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "resourceName": autorest.Encode("path", resourceName), + "resourceProviderNamespace": autorest.Encode("path", resourceProviderNamespace), + "resourceType": resourceType, + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2016-09-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{parentResourcePath}/{resourceType}/{resourceName}/providers/Microsoft.Authorization/locks/{lockName}", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare(&http.Request{}) +} + +// DeleteAtResourceLevelSender sends the DeleteAtResourceLevel request. The method will close the +// http.Response Body if it receives an error. +func (client ManagementLocksClient) DeleteAtResourceLevelSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req) +} + +// DeleteAtResourceLevelResponder handles the response to the DeleteAtResourceLevel request. The method always +// closes the http.Response Body. +func (client ManagementLocksClient) DeleteAtResourceLevelResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusNoContent, http.StatusOK), + autorest.ByClosing()) + result.Response = resp + return +} + +// DeleteAtSubscriptionLevel to delete management locks, you must have access to Microsoft.Authorization/* or +// Microsoft.Authorization/locks/* actions. Of the built-in roles, only Owner and User Access Administrator are granted +// those actions. +// +// lockName is the name of lock to delete. +func (client ManagementLocksClient) DeleteAtSubscriptionLevel(lockName string) (result autorest.Response, err error) { + req, err := client.DeleteAtSubscriptionLevelPreparer(lockName) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "DeleteAtSubscriptionLevel", nil, "Failure preparing request") + return + } + + resp, err := client.DeleteAtSubscriptionLevelSender(req) + if err != nil { + result.Response = resp + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "DeleteAtSubscriptionLevel", resp, "Failure sending request") + return + } + + result, err = client.DeleteAtSubscriptionLevelResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "DeleteAtSubscriptionLevel", resp, "Failure responding to request") + } + + return +} + +// DeleteAtSubscriptionLevelPreparer prepares the DeleteAtSubscriptionLevel request. +func (client ManagementLocksClient) DeleteAtSubscriptionLevelPreparer(lockName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "lockName": autorest.Encode("path", lockName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2016-09-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Authorization/locks/{lockName}", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare(&http.Request{}) +} + +// DeleteAtSubscriptionLevelSender sends the DeleteAtSubscriptionLevel request. The method will close the +// http.Response Body if it receives an error. +func (client ManagementLocksClient) DeleteAtSubscriptionLevelSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req) +} + +// DeleteAtSubscriptionLevelResponder handles the response to the DeleteAtSubscriptionLevel request. The method always +// closes the http.Response Body. +func (client ManagementLocksClient) DeleteAtSubscriptionLevelResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusNoContent, http.StatusOK), + autorest.ByClosing()) + result.Response = resp + return +} + +// DeleteByScope delete a management lock by scope. +// +// scope is the scope for the lock. lockName is the name of lock. +func (client ManagementLocksClient) DeleteByScope(scope string, lockName string) (result autorest.Response, err error) { + req, err := client.DeleteByScopePreparer(scope, lockName) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "DeleteByScope", nil, "Failure preparing request") + return + } + + resp, err := client.DeleteByScopeSender(req) + if err != nil { + result.Response = resp + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "DeleteByScope", resp, "Failure sending request") + return + } + + result, err = client.DeleteByScopeResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "DeleteByScope", resp, "Failure responding to request") + } + + return +} + +// DeleteByScopePreparer prepares the DeleteByScope request. +func (client ManagementLocksClient) DeleteByScopePreparer(scope string, lockName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "lockName": autorest.Encode("path", lockName), + "scope": autorest.Encode("path", scope), + } + + const APIVersion = "2016-09-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/{scope}/providers/Microsoft.Authorization/locks/{lockName}", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare(&http.Request{}) +} + +// DeleteByScopeSender sends the DeleteByScope request. The method will close the +// http.Response Body if it receives an error. +func (client ManagementLocksClient) DeleteByScopeSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req) +} + +// DeleteByScopeResponder handles the response to the DeleteByScope request. The method always +// closes the http.Response Body. +func (client ManagementLocksClient) DeleteByScopeResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusNoContent, http.StatusOK), + autorest.ByClosing()) + result.Response = resp + return +} + +// GetAtResourceGroupLevel gets a management lock at the resource group level. +// +// resourceGroupName is the name of the locked resource group. lockName is the name of the lock to get. +func (client ManagementLocksClient) GetAtResourceGroupLevel(resourceGroupName string, lockName string) (result ManagementLockObject, err error) { + if err := validation.Validate([]validation.Validation{ + {TargetValue: resourceGroupName, + Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, + {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil { + return result, validation.NewErrorWithValidationError(err, "locks.ManagementLocksClient", "GetAtResourceGroupLevel") + } + + req, err := client.GetAtResourceGroupLevelPreparer(resourceGroupName, lockName) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "GetAtResourceGroupLevel", nil, "Failure preparing request") + return + } + + resp, err := client.GetAtResourceGroupLevelSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "GetAtResourceGroupLevel", resp, "Failure sending request") + return + } + + result, err = client.GetAtResourceGroupLevelResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "GetAtResourceGroupLevel", resp, "Failure responding to request") + } + + return +} + +// GetAtResourceGroupLevelPreparer prepares the GetAtResourceGroupLevel request. +func (client ManagementLocksClient) GetAtResourceGroupLevelPreparer(resourceGroupName string, lockName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "lockName": autorest.Encode("path", lockName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2016-09-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Authorization/locks/{lockName}", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare(&http.Request{}) +} + +// GetAtResourceGroupLevelSender sends the GetAtResourceGroupLevel request. The method will close the +// http.Response Body if it receives an error. +func (client ManagementLocksClient) GetAtResourceGroupLevelSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req) +} + +// GetAtResourceGroupLevelResponder handles the response to the GetAtResourceGroupLevel request. The method always +// closes the http.Response Body. +func (client ManagementLocksClient) GetAtResourceGroupLevelResponder(resp *http.Response) (result ManagementLockObject, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// GetAtResourceLevel get the management lock of a resource or any level below resource. +// +// resourceGroupName is the name of the resource group. resourceProviderNamespace is the namespace of the resource +// provider. parentResourcePath is an extra path parameter needed in some services, like SQL Databases. resourceType is +// the type of the resource. resourceName is the name of the resource. lockName is the name of lock. +func (client ManagementLocksClient) GetAtResourceLevel(resourceGroupName string, resourceProviderNamespace string, parentResourcePath string, resourceType string, resourceName string, lockName string) (result ManagementLockObject, err error) { + if err := validation.Validate([]validation.Validation{ + {TargetValue: resourceGroupName, + Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, + {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil { + return result, validation.NewErrorWithValidationError(err, "locks.ManagementLocksClient", "GetAtResourceLevel") + } + + req, err := client.GetAtResourceLevelPreparer(resourceGroupName, resourceProviderNamespace, parentResourcePath, resourceType, resourceName, lockName) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "GetAtResourceLevel", nil, "Failure preparing request") + return + } + + resp, err := client.GetAtResourceLevelSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "GetAtResourceLevel", resp, "Failure sending request") + return + } + + result, err = client.GetAtResourceLevelResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "GetAtResourceLevel", resp, "Failure responding to request") + } + + return +} + +// GetAtResourceLevelPreparer prepares the GetAtResourceLevel request. +func (client ManagementLocksClient) GetAtResourceLevelPreparer(resourceGroupName string, resourceProviderNamespace string, parentResourcePath string, resourceType string, resourceName string, lockName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "lockName": autorest.Encode("path", lockName), + "parentResourcePath": parentResourcePath, + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "resourceName": autorest.Encode("path", resourceName), + "resourceProviderNamespace": autorest.Encode("path", resourceProviderNamespace), + "resourceType": resourceType, + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2016-09-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{parentResourcePath}/{resourceType}/{resourceName}/providers/Microsoft.Authorization/locks/{lockName}", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare(&http.Request{}) +} + +// GetAtResourceLevelSender sends the GetAtResourceLevel request. The method will close the +// http.Response Body if it receives an error. +func (client ManagementLocksClient) GetAtResourceLevelSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req) +} + +// GetAtResourceLevelResponder handles the response to the GetAtResourceLevel request. The method always +// closes the http.Response Body. +func (client ManagementLocksClient) GetAtResourceLevelResponder(resp *http.Response) (result ManagementLockObject, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// GetAtSubscriptionLevel gets a management lock at the subscription level. +// +// lockName is the name of the lock to get. +func (client ManagementLocksClient) GetAtSubscriptionLevel(lockName string) (result ManagementLockObject, err error) { + req, err := client.GetAtSubscriptionLevelPreparer(lockName) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "GetAtSubscriptionLevel", nil, "Failure preparing request") + return + } + + resp, err := client.GetAtSubscriptionLevelSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "GetAtSubscriptionLevel", resp, "Failure sending request") + return + } + + result, err = client.GetAtSubscriptionLevelResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "GetAtSubscriptionLevel", resp, "Failure responding to request") + } + + return +} + +// GetAtSubscriptionLevelPreparer prepares the GetAtSubscriptionLevel request. +func (client ManagementLocksClient) GetAtSubscriptionLevelPreparer(lockName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "lockName": autorest.Encode("path", lockName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2016-09-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Authorization/locks/{lockName}", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare(&http.Request{}) +} + +// GetAtSubscriptionLevelSender sends the GetAtSubscriptionLevel request. The method will close the +// http.Response Body if it receives an error. +func (client ManagementLocksClient) GetAtSubscriptionLevelSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req) +} + +// GetAtSubscriptionLevelResponder handles the response to the GetAtSubscriptionLevel request. The method always +// closes the http.Response Body. +func (client ManagementLocksClient) GetAtSubscriptionLevelResponder(resp *http.Response) (result ManagementLockObject, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// GetByScope get a management lock by scope. +// +// scope is the scope for the lock. lockName is the name of lock. +func (client ManagementLocksClient) GetByScope(scope string, lockName string) (result ManagementLockObject, err error) { + req, err := client.GetByScopePreparer(scope, lockName) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "GetByScope", nil, "Failure preparing request") + return + } + + resp, err := client.GetByScopeSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "GetByScope", resp, "Failure sending request") + return + } + + result, err = client.GetByScopeResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "GetByScope", resp, "Failure responding to request") + } + + return +} + +// GetByScopePreparer prepares the GetByScope request. +func (client ManagementLocksClient) GetByScopePreparer(scope string, lockName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "lockName": autorest.Encode("path", lockName), + "scope": autorest.Encode("path", scope), + } + + const APIVersion = "2016-09-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/{scope}/providers/Microsoft.Authorization/locks/{lockName}", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare(&http.Request{}) +} + +// GetByScopeSender sends the GetByScope request. The method will close the +// http.Response Body if it receives an error. +func (client ManagementLocksClient) GetByScopeSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req) +} + +// GetByScopeResponder handles the response to the GetByScope request. The method always +// closes the http.Response Body. +func (client ManagementLocksClient) GetByScopeResponder(resp *http.Response) (result ManagementLockObject, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// ListAtResourceGroupLevel gets all the management locks for a resource group. +// +// resourceGroupName is the name of the resource group containing the locks to get. filter is the filter to apply on +// the operation. +func (client ManagementLocksClient) ListAtResourceGroupLevel(resourceGroupName string, filter string) (result ManagementLockListResult, err error) { + if err := validation.Validate([]validation.Validation{ + {TargetValue: resourceGroupName, + Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, + {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil { + return result, validation.NewErrorWithValidationError(err, "locks.ManagementLocksClient", "ListAtResourceGroupLevel") + } + + req, err := client.ListAtResourceGroupLevelPreparer(resourceGroupName, filter) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtResourceGroupLevel", nil, "Failure preparing request") + return + } + + resp, err := client.ListAtResourceGroupLevelSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtResourceGroupLevel", resp, "Failure sending request") + return + } + + result, err = client.ListAtResourceGroupLevelResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtResourceGroupLevel", resp, "Failure responding to request") + } + + return +} + +// ListAtResourceGroupLevelPreparer prepares the ListAtResourceGroupLevel request. +func (client ManagementLocksClient) ListAtResourceGroupLevelPreparer(resourceGroupName string, filter string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2016-09-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + if len(filter) > 0 { + queryParameters["$filter"] = autorest.Encode("query", filter) + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Authorization/locks", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare(&http.Request{}) +} + +// ListAtResourceGroupLevelSender sends the ListAtResourceGroupLevel request. The method will close the +// http.Response Body if it receives an error. +func (client ManagementLocksClient) ListAtResourceGroupLevelSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req) +} + +// ListAtResourceGroupLevelResponder handles the response to the ListAtResourceGroupLevel request. The method always +// closes the http.Response Body. +func (client ManagementLocksClient) ListAtResourceGroupLevelResponder(resp *http.Response) (result ManagementLockListResult, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// ListAtResourceGroupLevelNextResults retrieves the next set of results, if any. +func (client ManagementLocksClient) ListAtResourceGroupLevelNextResults(lastResults ManagementLockListResult) (result ManagementLockListResult, err error) { + req, err := lastResults.ManagementLockListResultPreparer() + if err != nil { + return result, autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtResourceGroupLevel", nil, "Failure preparing next results request") + } + if req == nil { + return + } + + resp, err := client.ListAtResourceGroupLevelSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + return result, autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtResourceGroupLevel", resp, "Failure sending next results request") + } + + result, err = client.ListAtResourceGroupLevelResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtResourceGroupLevel", resp, "Failure responding to next results request") + } + + return +} + +// ListAtResourceGroupLevelComplete gets all elements from the list without paging. +func (client ManagementLocksClient) ListAtResourceGroupLevelComplete(resourceGroupName string, filter string, cancel <-chan struct{}) (<-chan ManagementLockObject, <-chan error) { + resultChan := make(chan ManagementLockObject) + errChan := make(chan error, 1) + go func() { + defer func() { + close(resultChan) + close(errChan) + }() + list, err := client.ListAtResourceGroupLevel(resourceGroupName, filter) + if err != nil { + errChan <- err + return + } + if list.Value != nil { + for _, item := range *list.Value { + select { + case <-cancel: + return + case resultChan <- item: + // Intentionally left blank + } + } + } + for list.NextLink != nil { + list, err = client.ListAtResourceGroupLevelNextResults(list) + if err != nil { + errChan <- err + return + } + if list.Value != nil { + for _, item := range *list.Value { + select { + case <-cancel: + return + case resultChan <- item: + // Intentionally left blank + } + } + } + } + }() + return resultChan, errChan +} + +// ListAtResourceLevel gets all the management locks for a resource or any level below resource. +// +// resourceGroupName is the name of the resource group containing the locked resource. The name is case insensitive. +// resourceProviderNamespace is the namespace of the resource provider. parentResourcePath is the parent resource +// identity. resourceType is the resource type of the locked resource. resourceName is the name of the locked resource. +// filter is the filter to apply on the operation. +func (client ManagementLocksClient) ListAtResourceLevel(resourceGroupName string, resourceProviderNamespace string, parentResourcePath string, resourceType string, resourceName string, filter string) (result ManagementLockListResult, err error) { + if err := validation.Validate([]validation.Validation{ + {TargetValue: resourceGroupName, + Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, + {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil { + return result, validation.NewErrorWithValidationError(err, "locks.ManagementLocksClient", "ListAtResourceLevel") + } + + req, err := client.ListAtResourceLevelPreparer(resourceGroupName, resourceProviderNamespace, parentResourcePath, resourceType, resourceName, filter) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtResourceLevel", nil, "Failure preparing request") + return + } + + resp, err := client.ListAtResourceLevelSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtResourceLevel", resp, "Failure sending request") + return + } + + result, err = client.ListAtResourceLevelResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtResourceLevel", resp, "Failure responding to request") + } + + return +} + +// ListAtResourceLevelPreparer prepares the ListAtResourceLevel request. +func (client ManagementLocksClient) ListAtResourceLevelPreparer(resourceGroupName string, resourceProviderNamespace string, parentResourcePath string, resourceType string, resourceName string, filter string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "parentResourcePath": parentResourcePath, + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "resourceName": autorest.Encode("path", resourceName), + "resourceProviderNamespace": autorest.Encode("path", resourceProviderNamespace), + "resourceType": resourceType, + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2016-09-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + if len(filter) > 0 { + queryParameters["$filter"] = autorest.Encode("query", filter) + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{parentResourcePath}/{resourceType}/{resourceName}/providers/Microsoft.Authorization/locks", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare(&http.Request{}) +} + +// ListAtResourceLevelSender sends the ListAtResourceLevel request. The method will close the +// http.Response Body if it receives an error. +func (client ManagementLocksClient) ListAtResourceLevelSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req) +} + +// ListAtResourceLevelResponder handles the response to the ListAtResourceLevel request. The method always +// closes the http.Response Body. +func (client ManagementLocksClient) ListAtResourceLevelResponder(resp *http.Response) (result ManagementLockListResult, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// ListAtResourceLevelNextResults retrieves the next set of results, if any. +func (client ManagementLocksClient) ListAtResourceLevelNextResults(lastResults ManagementLockListResult) (result ManagementLockListResult, err error) { + req, err := lastResults.ManagementLockListResultPreparer() + if err != nil { + return result, autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtResourceLevel", nil, "Failure preparing next results request") + } + if req == nil { + return + } + + resp, err := client.ListAtResourceLevelSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + return result, autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtResourceLevel", resp, "Failure sending next results request") + } + + result, err = client.ListAtResourceLevelResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtResourceLevel", resp, "Failure responding to next results request") + } + + return +} + +// ListAtResourceLevelComplete gets all elements from the list without paging. +func (client ManagementLocksClient) ListAtResourceLevelComplete(resourceGroupName string, resourceProviderNamespace string, parentResourcePath string, resourceType string, resourceName string, filter string, cancel <-chan struct{}) (<-chan ManagementLockObject, <-chan error) { + resultChan := make(chan ManagementLockObject) + errChan := make(chan error, 1) + go func() { + defer func() { + close(resultChan) + close(errChan) + }() + list, err := client.ListAtResourceLevel(resourceGroupName, resourceProviderNamespace, parentResourcePath, resourceType, resourceName, filter) + if err != nil { + errChan <- err + return + } + if list.Value != nil { + for _, item := range *list.Value { + select { + case <-cancel: + return + case resultChan <- item: + // Intentionally left blank + } + } + } + for list.NextLink != nil { + list, err = client.ListAtResourceLevelNextResults(list) + if err != nil { + errChan <- err + return + } + if list.Value != nil { + for _, item := range *list.Value { + select { + case <-cancel: + return + case resultChan <- item: + // Intentionally left blank + } + } + } + } + }() + return resultChan, errChan +} + +// ListAtSubscriptionLevel gets all the management locks for a subscription. +// +// filter is the filter to apply on the operation. +func (client ManagementLocksClient) ListAtSubscriptionLevel(filter string) (result ManagementLockListResult, err error) { + req, err := client.ListAtSubscriptionLevelPreparer(filter) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtSubscriptionLevel", nil, "Failure preparing request") + return + } + + resp, err := client.ListAtSubscriptionLevelSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtSubscriptionLevel", resp, "Failure sending request") + return + } + + result, err = client.ListAtSubscriptionLevelResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtSubscriptionLevel", resp, "Failure responding to request") + } + + return +} + +// ListAtSubscriptionLevelPreparer prepares the ListAtSubscriptionLevel request. +func (client ManagementLocksClient) ListAtSubscriptionLevelPreparer(filter string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2016-09-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + if len(filter) > 0 { + queryParameters["$filter"] = autorest.Encode("query", filter) + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Authorization/locks", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare(&http.Request{}) +} + +// ListAtSubscriptionLevelSender sends the ListAtSubscriptionLevel request. The method will close the +// http.Response Body if it receives an error. +func (client ManagementLocksClient) ListAtSubscriptionLevelSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req) +} + +// ListAtSubscriptionLevelResponder handles the response to the ListAtSubscriptionLevel request. The method always +// closes the http.Response Body. +func (client ManagementLocksClient) ListAtSubscriptionLevelResponder(resp *http.Response) (result ManagementLockListResult, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// ListAtSubscriptionLevelNextResults retrieves the next set of results, if any. +func (client ManagementLocksClient) ListAtSubscriptionLevelNextResults(lastResults ManagementLockListResult) (result ManagementLockListResult, err error) { + req, err := lastResults.ManagementLockListResultPreparer() + if err != nil { + return result, autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtSubscriptionLevel", nil, "Failure preparing next results request") + } + if req == nil { + return + } + + resp, err := client.ListAtSubscriptionLevelSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + return result, autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtSubscriptionLevel", resp, "Failure sending next results request") + } + + result, err = client.ListAtSubscriptionLevelResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtSubscriptionLevel", resp, "Failure responding to next results request") + } + + return +} + +// ListAtSubscriptionLevelComplete gets all elements from the list without paging. +func (client ManagementLocksClient) ListAtSubscriptionLevelComplete(filter string, cancel <-chan struct{}) (<-chan ManagementLockObject, <-chan error) { + resultChan := make(chan ManagementLockObject) + errChan := make(chan error, 1) + go func() { + defer func() { + close(resultChan) + close(errChan) + }() + list, err := client.ListAtSubscriptionLevel(filter) + if err != nil { + errChan <- err + return + } + if list.Value != nil { + for _, item := range *list.Value { + select { + case <-cancel: + return + case resultChan <- item: + // Intentionally left blank + } + } + } + for list.NextLink != nil { + list, err = client.ListAtSubscriptionLevelNextResults(list) + if err != nil { + errChan <- err + return + } + if list.Value != nil { + for _, item := range *list.Value { + select { + case <-cancel: + return + case resultChan <- item: + // Intentionally left blank + } + } + } + } + }() + return resultChan, errChan +} diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/locks/models.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/locks/models.go new file mode 100755 index 000000000000..8373b88d7d87 --- /dev/null +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/locks/models.go @@ -0,0 +1,76 @@ +package locks + +// Copyright (c) Microsoft and contributors. All rights reserved. +// +// 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. +// +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +import ( + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/to" + "net/http" +) + +// LockLevel enumerates the values for lock level. +type LockLevel string + +const ( + // CanNotDelete specifies the can not delete state for lock level. + CanNotDelete LockLevel = "CanNotDelete" + // NotSpecified specifies the not specified state for lock level. + NotSpecified LockLevel = "NotSpecified" + // ReadOnly specifies the read only state for lock level. + ReadOnly LockLevel = "ReadOnly" +) + +// ManagementLockListResult is the list of locks. +type ManagementLockListResult struct { + autorest.Response `json:"-"` + Value *[]ManagementLockObject `json:"value,omitempty"` + NextLink *string `json:"nextLink,omitempty"` +} + +// ManagementLockListResultPreparer prepares a request to retrieve the next set of results. It returns +// nil if no more results exist. +func (client ManagementLockListResult) ManagementLockListResultPreparer() (*http.Request, error) { + if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 { + return nil, nil + } + return autorest.Prepare(&http.Request{}, + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String(client.NextLink))) +} + +// ManagementLockObject is the lock information. +type ManagementLockObject struct { + autorest.Response `json:"-"` + *ManagementLockProperties `json:"properties,omitempty"` + ID *string `json:"id,omitempty"` + Type *string `json:"type,omitempty"` + Name *string `json:"name,omitempty"` +} + +// ManagementLockOwner is lock owner properties. +type ManagementLockOwner struct { + ApplicationID *string `json:"applicationId,omitempty"` +} + +// ManagementLockProperties is the lock properties. +type ManagementLockProperties struct { + Level LockLevel `json:"level,omitempty"` + Notes *string `json:"notes,omitempty"` + Owners *[]ManagementLockOwner `json:"owners,omitempty"` +} diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/locks/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/locks/version.go new file mode 100755 index 000000000000..52819ed906c5 --- /dev/null +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/locks/version.go @@ -0,0 +1,28 @@ +package locks + +// Copyright (c) Microsoft and contributors. All rights reserved. +// +// 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. +// +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +// UserAgent returns the UserAgent string to use when sending http.Requests. +func UserAgent() string { + return "Azure-SDK-For-Go/v11.0.0-beta arm-locks/2016-09-01" +} + +// Version returns the semantic version (see http://semver.org) of the client. +func Version() string { + return "v11.0.0-beta" +} diff --git a/vendor/vendor.json b/vendor/vendor.json index c713a5e3d24f..fefe4e7d2426 100644 --- a/vendor/vendor.json +++ b/vendor/vendor.json @@ -162,6 +162,14 @@ "version": "v11.1.0-beta", "versionExact": "v11.1.0-beta" }, + { + "checksumSHA1": "bhJG74moCO/VErpBcGNWg6P77ek=", + "path": "github.com/Azure/azure-sdk-for-go/arm/resources/locks", + "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", + "revisionTime": "2017-10-06T17:43:09Z", + "version": "v11.1.0-beta", + "versionExact": "v11.1.0-beta" + }, { "checksumSHA1": "v3sNtVRCd3dMI1nSb8E5+IFuKsg=", "path": "github.com/Azure/azure-sdk-for-go/arm/resources/resources", From facd2a52e24de5842c86b18237a6f0508468fcbe Mon Sep 17 00:00:00 2001 From: tombuildsstuff Date: Sat, 18 Nov 2017 11:15:03 +0100 Subject: [PATCH 17/55] New Resource: `azurerm_management_lock` Note: As the Subscription specific Locks will break other tests; these tests need to be run individually. As such I've introduced the `TF_ACC_SUBSCRIPTION_PARALLEL_LOCK` environment variable for this purpose. Tests pass: ``` $ TF_ACC_SUBSCRIPTION_PARALLEL_LOCK=1 acctests azurerm TestAccAzureRMManagementLock_ === RUN TestAccAzureRMManagementLock_importResourceGroupReadOnlyBasic --- PASS: TestAccAzureRMManagementLock_importResourceGroupReadOnlyBasic (61.52s) === RUN TestAccAzureRMManagementLock_importResourceGroupReadOnlyComplete --- PASS: TestAccAzureRMManagementLock_importResourceGroupReadOnlyComplete (58.75s) === RUN TestAccAzureRMManagementLock_importResourceGroupCanNotDeleteBasic --- PASS: TestAccAzureRMManagementLock_importResourceGroupCanNotDeleteBasic (53.38s) === RUN TestAccAzureRMManagementLock_importResourceGroupCanNotDeleteComplete --- PASS: TestAccAzureRMManagementLock_importResourceGroupCanNotDeleteComplete (46.87s) === RUN TestAccAzureRMManagementLock_importPublicIPCanNotDeleteBasic --- PASS: TestAccAzureRMManagementLock_importPublicIPCanNotDeleteBasic (80.46s) === RUN TestAccAzureRMManagementLock_importPublicIPReadOnlyBasic --- PASS: TestAccAzureRMManagementLock_importPublicIPReadOnlyBasic (68.53s) === RUN TestAccAzureRMManagementLock_resourceGroupReadOnlyBasic --- PASS: TestAccAzureRMManagementLock_resourceGroupReadOnlyBasic (61.24s) === RUN TestAccAzureRMManagementLock_resourceGroupReadOnlyComplete --- PASS: TestAccAzureRMManagementLock_resourceGroupReadOnlyComplete (64.10s) === RUN TestAccAzureRMManagementLock_resourceGroupCanNotDeleteBasic --- PASS: TestAccAzureRMManagementLock_resourceGroupCanNotDeleteBasic (72.49s) === RUN TestAccAzureRMManagementLock_resourceGroupCanNotDeleteComplete --- PASS: TestAccAzureRMManagementLock_resourceGroupCanNotDeleteComplete (113.71s) === RUN TestAccAzureRMManagementLock_publicIPReadOnlyBasic --- PASS: TestAccAzureRMManagementLock_publicIPReadOnlyBasic (64.05s) === RUN TestAccAzureRMManagementLock_publicIPCanNotDeleteBasic --- PASS: TestAccAzureRMManagementLock_publicIPCanNotDeleteBasic (94.53s) === RUN TestAccAzureRMManagementLock_subscriptionReadOnlyBasic --- PASS: TestAccAzureRMManagementLock_subscriptionReadOnlyBasic (17.98s) === RUN TestAccAzureRMManagementLock_subscriptionCanNotDeleteBasic --- PASS: TestAccAzureRMManagementLock_subscriptionCanNotDeleteBasic (15.20s) PASS ok github.com/terraform-providers/terraform-provider-azurerm/azurerm 872.839s ``` Fixes #23 --- azurerm/config.go | 13 + azurerm/import_arm_management_lock_test.go | 134 +++++++ azurerm/provider.go | 1 + azurerm/resource_arm_management_lock.go | 155 ++++++++ azurerm/resource_arm_management_lock_test.go | 372 +++++++++++++++++++ website/azurerm.erb | 23 +- website/docs/r/management_lock.html.markdown | 93 +++++ 7 files changed, 784 insertions(+), 7 deletions(-) create mode 100644 azurerm/import_arm_management_lock_test.go create mode 100644 azurerm/resource_arm_management_lock.go create mode 100644 azurerm/resource_arm_management_lock_test.go create mode 100644 website/docs/r/management_lock.html.markdown diff --git a/azurerm/config.go b/azurerm/config.go index 159a54726a8d..311a11aee16a 100644 --- a/azurerm/config.go +++ b/azurerm/config.go @@ -28,6 +28,7 @@ import ( "github.com/Azure/azure-sdk-for-go/arm/operationalinsights" "github.com/Azure/azure-sdk-for-go/arm/postgresql" "github.com/Azure/azure-sdk-for-go/arm/redis" + "github.com/Azure/azure-sdk-for-go/arm/resources/locks" "github.com/Azure/azure-sdk-for-go/arm/resources/resources" "github.com/Azure/azure-sdk-for-go/arm/resources/subscriptions" "github.com/Azure/azure-sdk-for-go/arm/scheduler" @@ -160,6 +161,9 @@ type ArmClient struct { sqlElasticPoolsClient sql.ElasticPoolsClient sqlFirewallRulesClient sql.FirewallRulesClient sqlServersClient sql.ServersClient + + // Resources + managementLocksClient locks.ManagementLocksClient } func withRequestLogging() autorest.SendDecorator { @@ -656,6 +660,7 @@ func (c *Config) getArmClient() (*ArmClient, error) { client.registerDisks(endpoint, c.SubscriptionID, auth, sender) client.registerKeyVaultClients(endpoint, c.SubscriptionID, auth, keyVaultAuth, sender) client.registerRedisClients(endpoint, c.SubscriptionID, auth, sender) + client.registerResourcesClients(endpoint, c.SubscriptionID, auth, sender) return &client, nil } @@ -805,6 +810,14 @@ func (c *ArmClient) registerRedisClients(endpoint, subscriptionId string, auth a c.redisPatchSchedulesClient = patchSchedulesClient } +func (c *ArmClient) registerResourcesClients(endpoint, subscriptionId string, auth autorest.Authorizer, sender autorest.Sender) { + locksClient := locks.NewManagementLocksClientWithBaseURI(endpoint, subscriptionId) + setUserAgent(&locksClient.Client) + locksClient.Authorizer = auth + locksClient.Sender = sender + c.managementLocksClient = locksClient +} + func (armClient *ArmClient) getKeyForStorageAccount(resourceGroupName, storageAccountName string) (string, bool, error) { accountKeys, err := armClient.storageServiceClient.ListKeys(resourceGroupName, storageAccountName) if accountKeys.StatusCode == http.StatusNotFound { diff --git a/azurerm/import_arm_management_lock_test.go b/azurerm/import_arm_management_lock_test.go new file mode 100644 index 000000000000..dcb2638648af --- /dev/null +++ b/azurerm/import_arm_management_lock_test.go @@ -0,0 +1,134 @@ +package azurerm + +import ( + "testing" + + "github.com/hashicorp/terraform/helper/acctest" + "github.com/hashicorp/terraform/helper/resource" +) + +func TestAccAzureRMManagementLock_importResourceGroupReadOnlyBasic(t *testing.T) { + ri := acctest.RandInt() + config := testAccAzureRMManagementLock_resourceGroupReadOnlyBasic(ri, testLocation()) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMManagementLockDestroy, + Steps: []resource.TestStep{ + { + Config: config, + }, + { + ResourceName: "azurerm_management_lock.test", + ImportState: true, + ImportStateVerify: true, + }, + }, + }) +} + +func TestAccAzureRMManagementLock_importResourceGroupReadOnlyComplete(t *testing.T) { + ri := acctest.RandInt() + config := testAccAzureRMManagementLock_resourceGroupReadOnlyComplete(ri, testLocation()) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMManagementLockDestroy, + Steps: []resource.TestStep{ + { + Config: config, + }, + { + ResourceName: "azurerm_management_lock.test", + ImportState: true, + ImportStateVerify: true, + }, + }, + }) +} + +func TestAccAzureRMManagementLock_importResourceGroupCanNotDeleteBasic(t *testing.T) { + ri := acctest.RandInt() + config := testAccAzureRMManagementLock_resourceGroupCanNotDeleteBasic(ri, testLocation()) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMManagementLockDestroy, + Steps: []resource.TestStep{ + { + Config: config, + }, + { + ResourceName: "azurerm_management_lock.test", + ImportState: true, + ImportStateVerify: true, + }, + }, + }) +} + +func TestAccAzureRMManagementLock_importResourceGroupCanNotDeleteComplete(t *testing.T) { + ri := acctest.RandInt() + config := testAccAzureRMManagementLock_resourceGroupCanNotDeleteComplete(ri, testLocation()) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMManagementLockDestroy, + Steps: []resource.TestStep{ + { + Config: config, + }, + { + ResourceName: "azurerm_management_lock.test", + ImportState: true, + ImportStateVerify: true, + }, + }, + }) +} + +func TestAccAzureRMManagementLock_importPublicIPCanNotDeleteBasic(t *testing.T) { + ri := acctest.RandInt() + config := testAccAzureRMManagementLock_publicIPCanNotDeleteBasic(ri, testLocation()) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMManagementLockDestroy, + Steps: []resource.TestStep{ + { + Config: config, + }, + { + ResourceName: "azurerm_management_lock.test", + ImportState: true, + ImportStateVerify: true, + }, + }, + }) +} + +func TestAccAzureRMManagementLock_importPublicIPReadOnlyBasic(t *testing.T) { + ri := acctest.RandInt() + config := testAccAzureRMManagementLock_publicIPReadOnlyBasic(ri, testLocation()) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMManagementLockDestroy, + Steps: []resource.TestStep{ + { + Config: config, + }, + { + ResourceName: "azurerm_management_lock.test", + ImportState: true, + ImportStateVerify: true, + }, + }, + }) +} diff --git a/azurerm/provider.go b/azurerm/provider.go index 5f7dfea31866..97d482bcfaff 100644 --- a/azurerm/provider.go +++ b/azurerm/provider.go @@ -127,6 +127,7 @@ func Provider() terraform.ResourceProvider { "azurerm_local_network_gateway": resourceArmLocalNetworkGateway(), "azurerm_log_analytics_workspace": resourceArmLogAnalyticsWorkspace(), "azurerm_managed_disk": resourceArmManagedDisk(), + "azurerm_management_lock": resourceArmManagementLock(), "azurerm_mysql_configuration": resourceArmMySQLConfiguration(), "azurerm_mysql_database": resourceArmMySqlDatabase(), "azurerm_mysql_firewall_rule": resourceArmMySqlFirewallRule(), diff --git a/azurerm/resource_arm_management_lock.go b/azurerm/resource_arm_management_lock.go new file mode 100644 index 000000000000..b1888c3793a4 --- /dev/null +++ b/azurerm/resource_arm_management_lock.go @@ -0,0 +1,155 @@ +package azurerm + +import ( + "fmt" + "log" + "strings" + + "github.com/Azure/azure-sdk-for-go/arm/resources/locks" + "github.com/hashicorp/terraform/helper/schema" + "github.com/hashicorp/terraform/helper/validation" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" +) + +func resourceArmManagementLock() *schema.Resource { + return &schema.Resource{ + Create: resourceArmManagementLockCreateUpdate, + Read: resourceArmManagementLockRead, + Delete: resourceArmManagementLockDelete, + Importer: &schema.ResourceImporter{ + State: schema.ImportStatePassthrough, + }, + + Schema: map[string]*schema.Schema{ + "name": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + // TODO: validation + // The lock name can be a maximum of 260 characters. + // It cannot contain <, > %, &, :, \, ?, /, or any control characters. + }, + + "scope": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + }, + + "lock_level": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + ValidateFunc: validation.StringInSlice([]string{ + string(locks.CanNotDelete), + string(locks.ReadOnly), + }, false), + }, + + "notes": { + Type: schema.TypeString, + Optional: true, + ForceNew: true, + ValidateFunc: validation.StringLenBetween(0, 512), + }, + }, + } +} + +func resourceArmManagementLockCreateUpdate(d *schema.ResourceData, meta interface{}) error { + client := meta.(*ArmClient).managementLocksClient + log.Printf("[INFO] preparing arguments for AzureRM Management Lock creation.") + + name := d.Get("name").(string) + scope := d.Get("scope").(string) + lockLevel := d.Get("lock_level").(string) + notes := d.Get("notes").(string) + + lock := locks.ManagementLockObject{ + ManagementLockProperties: &locks.ManagementLockProperties{ + Level: locks.LockLevel(lockLevel), + Notes: utils.String(notes), + }, + } + + _, err := client.CreateOrUpdateByScope(scope, name, lock) + if err != nil { + return err + } + + read, err := client.GetByScope(scope, name) + if err != nil { + return err + } + + if read.ID == nil { + return fmt.Errorf("Cannot read ID of AzureRM Management Lock %q (Scope %q)", name, scope) + } + + d.SetId(*read.ID) + return resourceArmManagementLockRead(d, meta) +} + +func resourceArmManagementLockRead(d *schema.ResourceData, meta interface{}) error { + client := meta.(*ArmClient).managementLocksClient + + id, err := parseAzureRMLockId(d.Id()) + if err != nil { + return err + } + + resp, err := client.GetByScope(id.Scope, id.Name) + if err != nil { + if utils.ResponseWasNotFound(resp.Response) { + d.SetId("") + return nil + } + return fmt.Errorf("Error making Read request on AzureRM Management Lock %q (Scope %q): %+v", id.Name, id.Scope, err) + } + + d.Set("name", resp.Name) + d.Set("scope", id.Scope) + + if props := resp.ManagementLockProperties; props != nil { + d.Set("lock_level", string(props.Level)) + d.Set("notes", props.Notes) + } + + return nil +} + +func resourceArmManagementLockDelete(d *schema.ResourceData, meta interface{}) error { + client := meta.(*ArmClient).managementLocksClient + + id, err := parseAzureRMLockId(d.Id()) + if err != nil { + return err + } + + resp, err := client.DeleteByScope(id.Scope, id.Name) + if err != nil { + if utils.ResponseWasNotFound(resp) { + return nil + } + + return fmt.Errorf("Error issuing AzureRM delete request for Management Lock %q (Scope %q): %+v", id.Name, id.Scope, err) + } + + return nil +} + +type AzureManagementLockId struct { + Scope string + Name string +} + +func parseAzureRMLockId(id string) (*AzureManagementLockId, error) { + segments := strings.Split(id, "/providers/Microsoft.Authorization/locks/") + scope := segments[0] + name := segments[1] + lockId := AzureManagementLockId{ + Scope: scope, + Name: name, + } + return &lockId, nil +} diff --git a/azurerm/resource_arm_management_lock_test.go b/azurerm/resource_arm_management_lock_test.go new file mode 100644 index 000000000000..382042d3b04a --- /dev/null +++ b/azurerm/resource_arm_management_lock_test.go @@ -0,0 +1,372 @@ +package azurerm + +import ( + "fmt" + "testing" + + "os" + + "github.com/hashicorp/terraform/helper/acctest" + "github.com/hashicorp/terraform/helper/resource" + "github.com/hashicorp/terraform/terraform" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" +) + +func TestAccAzureRMManagementLock_resourceGroupReadOnlyBasic(t *testing.T) { + resourceName := "azurerm_management_lock.test" + ri := acctest.RandInt() + location := testLocation() + config := testAccAzureRMManagementLock_resourceGroupReadOnlyBasic(ri, location) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMManagementLockDestroy, + Steps: []resource.TestStep{ + { + Config: config, + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMManagementLockExists(resourceName), + ), + }, + }, + }) +} + +func TestAccAzureRMManagementLock_resourceGroupReadOnlyComplete(t *testing.T) { + resourceName := "azurerm_management_lock.test" + ri := acctest.RandInt() + location := testLocation() + config := testAccAzureRMManagementLock_resourceGroupReadOnlyComplete(ri, location) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMManagementLockDestroy, + Steps: []resource.TestStep{ + { + Config: config, + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMManagementLockExists(resourceName), + ), + }, + }, + }) +} + +func TestAccAzureRMManagementLock_resourceGroupCanNotDeleteBasic(t *testing.T) { + resourceName := "azurerm_management_lock.test" + ri := acctest.RandInt() + location := testLocation() + config := testAccAzureRMManagementLock_resourceGroupCanNotDeleteBasic(ri, location) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMManagementLockDestroy, + Steps: []resource.TestStep{ + { + Config: config, + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMManagementLockExists(resourceName), + ), + }, + }, + }) +} + +func TestAccAzureRMManagementLock_resourceGroupCanNotDeleteComplete(t *testing.T) { + resourceName := "azurerm_management_lock.test" + ri := acctest.RandInt() + location := testLocation() + config := testAccAzureRMManagementLock_resourceGroupCanNotDeleteComplete(ri, location) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMManagementLockDestroy, + Steps: []resource.TestStep{ + { + Config: config, + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMManagementLockExists(resourceName), + ), + }, + }, + }) +} + +func TestAccAzureRMManagementLock_publicIPReadOnlyBasic(t *testing.T) { + resourceName := "azurerm_management_lock.test" + ri := acctest.RandInt() + location := testLocation() + config := testAccAzureRMManagementLock_publicIPReadOnlyBasic(ri, location) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMManagementLockDestroy, + Steps: []resource.TestStep{ + { + Config: config, + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMManagementLockExists(resourceName), + ), + }, + }, + }) +} + +func TestAccAzureRMManagementLock_publicIPCanNotDeleteBasic(t *testing.T) { + resourceName := "azurerm_management_lock.test" + ri := acctest.RandInt() + location := testLocation() + config := testAccAzureRMManagementLock_publicIPCanNotDeleteBasic(ri, location) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMManagementLockDestroy, + Steps: []resource.TestStep{ + { + Config: config, + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMManagementLockExists(resourceName), + ), + }, + }, + }) +} + +func TestAccAzureRMManagementLock_subscriptionReadOnlyBasic(t *testing.T) { + _, exists := os.LookupEnv("TF_ACC_SUBSCRIPTION_PARALLEL_LOCK") + if !exists { + t.Skip("`TF_ACC_SUBSCRIPTION_PARALLEL_LOCK` isn't specified - skipping since this test can't be run in Parallel") + } + + resourceName := "azurerm_management_lock.test" + ri := acctest.RandInt() + config := testAccAzureRMManagementLock_subscriptionReadOnlyBasic(ri) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMManagementLockDestroy, + Steps: []resource.TestStep{ + { + Config: config, + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMManagementLockExists(resourceName), + ), + }, + }, + }) +} + +func TestAccAzureRMManagementLock_subscriptionCanNotDeleteBasic(t *testing.T) { + _, exists := os.LookupEnv("TF_ACC_SUBSCRIPTION_PARALLEL_LOCK") + if !exists { + t.Skip("`TF_ACC_SUBSCRIPTION_PARALLEL_LOCK` isn't specified - skipping since this test can't be run in Parallel") + } + + resourceName := "azurerm_management_lock.test" + ri := acctest.RandInt() + config := testAccAzureRMManagementLock_subscriptionCanNotDeleteBasic(ri) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMManagementLockDestroy, + Steps: []resource.TestStep{ + { + Config: config, + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMManagementLockExists(resourceName), + ), + }, + }, + }) +} + +func testCheckAzureRMManagementLockExists(resourceName string) resource.TestCheckFunc { + return func(s *terraform.State) error { + // Ensure we have enough information in state to look up in API + rs, ok := s.RootModule().Resources[resourceName] + if !ok { + return fmt.Errorf("Not found: %q", resourceName) + } + + name := rs.Primary.Attributes["name"] + scope := rs.Primary.Attributes["scope"] + + client := testAccProvider.Meta().(*ArmClient).managementLocksClient + + resp, err := client.GetByScope(scope, name) + if err != nil { + if utils.ResponseWasNotFound(resp.Response) { + return fmt.Errorf("Bad: Management Lock %q (Scope %q) does not exist", name, scope) + } + + return fmt.Errorf("Bad: Get on managementLocksClient: %+v", err) + } + + return nil + } +} + +func testCheckAzureRMManagementLockDestroy(s *terraform.State) error { + client := testAccProvider.Meta().(*ArmClient).managementLocksClient + + for _, rs := range s.RootModule().Resources { + if rs.Type != "azurerm_management_lock" { + continue + } + + name := rs.Primary.Attributes["name"] + scope := rs.Primary.Attributes["scope"] + + resp, err := client.GetByScope(scope, name) + + if err != nil { + if utils.ResponseWasNotFound(resp.Response) { + return nil + } + + return err + } + } + + return nil +} + +func testAccAzureRMManagementLock_resourceGroupReadOnlyBasic(rInt int, location string) string { + return fmt.Sprintf(` +resource "azurerm_resource_group" "test" { + name = "acctestRG-%d" + location = "%s" +} + +resource "azurerm_management_lock" "test" { + name = "acctestlock-%d" + scope = "${azurerm_resource_group.test.id}" + lock_level = "ReadOnly" +} +`, rInt, location, rInt) +} + +func testAccAzureRMManagementLock_resourceGroupReadOnlyComplete(rInt int, location string) string { + return fmt.Sprintf(` +resource "azurerm_resource_group" "test" { + name = "acctestRG-%d" + location = "%s" +} + +resource "azurerm_management_lock" "test" { + name = "acctestlock-%d" + scope = "${azurerm_resource_group.test.id}" + lock_level = "ReadOnly" + notes = "Hello, World!" +} +`, rInt, location, rInt) +} + +func testAccAzureRMManagementLock_resourceGroupCanNotDeleteBasic(rInt int, location string) string { + return fmt.Sprintf(` +resource "azurerm_resource_group" "test" { + name = "acctestRG-%d" + location = "%s" +} + +resource "azurerm_management_lock" "test" { + name = "acctestlock-%d" + scope = "${azurerm_resource_group.test.id}" + lock_level = "CanNotDelete" +} +`, rInt, location, rInt) +} + +func testAccAzureRMManagementLock_resourceGroupCanNotDeleteComplete(rInt int, location string) string { + return fmt.Sprintf(` +resource "azurerm_resource_group" "test" { + name = "acctestRG-%d" + location = "%s" +} + +resource "azurerm_management_lock" "test" { + name = "acctestlock-%d" + scope = "${azurerm_resource_group.test.id}" + lock_level = "CanNotDelete" + notes = "Hello, World!" +} +`, rInt, location, rInt) +} + +func testAccAzureRMManagementLock_publicIPReadOnlyBasic(rInt int, location string) string { + return fmt.Sprintf(` +resource "azurerm_resource_group" "test" { + name = "acctestRG-%d" + location = "%s" +} + +resource "azurerm_public_ip" "test" { + name = "acctestpublicip-%d" + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" + public_ip_address_allocation = "static" + idle_timeout_in_minutes = 30 +} + +resource "azurerm_management_lock" "test" { + name = "acctestlock-%d" + scope = "${azurerm_public_ip.test.id}" + lock_level = "ReadOnly" +} +`, rInt, location, rInt, rInt) +} + +func testAccAzureRMManagementLock_publicIPCanNotDeleteBasic(rInt int, location string) string { + return fmt.Sprintf(` +resource "azurerm_resource_group" "test" { + name = "acctestRG-%d" + location = "%s" +} + +resource "azurerm_public_ip" "test" { + name = "acctestpublicip-%d" + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" + public_ip_address_allocation = "static" + idle_timeout_in_minutes = 30 +} + +resource "azurerm_management_lock" "test" { + name = "acctestlock-%d" + scope = "${azurerm_public_ip.test.id}" + lock_level = "CanNotDelete" +} +`, rInt, location, rInt, rInt) +} + +func testAccAzureRMManagementLock_subscriptionReadOnlyBasic(rInt int) string { + return fmt.Sprintf(` +data "azurerm_subscription" "current" {} + +resource "azurerm_management_lock" "test" { + name = "acctestlock-%d" + scope = "${data.azurerm_subscription.current.id}" + lock_level = "ReadOnly" +} +`, rInt) +} + +func testAccAzureRMManagementLock_subscriptionCanNotDeleteBasic(rInt int) string { + return fmt.Sprintf(` +data "azurerm_subscription" "current" {} + +resource "azurerm_management_lock" "test" { + name = "acctestlock-%d" + scope = "${data.azurerm_subscription.current.id}" + lock_level = "CanNotDelete" +} +`, rInt) +} diff --git a/website/azurerm.erb b/website/azurerm.erb index c01de2a7752d..5df07fd2fe9e 100644 --- a/website/azurerm.erb +++ b/website/azurerm.erb @@ -370,6 +370,15 @@ + > + Management Resources + + + > Messaging Resources
    @@ -474,13 +483,13 @@ > - OMS Resources - - + OMS Resources + + > Redis Resources diff --git a/website/docs/r/management_lock.html.markdown b/website/docs/r/management_lock.html.markdown new file mode 100644 index 000000000000..01873674456e --- /dev/null +++ b/website/docs/r/management_lock.html.markdown @@ -0,0 +1,93 @@ +--- +layout: "azurerm" +page_title: "Azure Resource Manager: azurerm_management_lock" +sidebar_current: "docs-azurerm-resource-management-lock" +description: |- + Manages a Management Lock which is scoped to a Subscription, Resource Group or Resource. + +--- + +# azurerm_management_lock + +Manages a Management Lock which is scoped to a Subscription, Resource Group or Resource. + +## Example Usage (Subscription Level Lock) + +```hcl +data "azurerm_subscription" "current" {} + +resource "azurerm_management_lock" "subscription-level" { + name = "subscription-level" + scope = "${data.azurerm_subscription.current.id}" + lock_level = "CanNotDelete" + notes = "Items can't be deleted in this subscription!" +} +``` + +## Example Usage (Resource Group Level Lock) + +```hcl +resource "azurerm_resource_group" "test" { + name = "locked-resource-group" + location = "West Europe" +} + +resource "azurerm_management_lock" "resource-group-level" { + name = "resource-group-level" + scope = "${azurerm_resource_group.test.id}" + lock_level = "ReadOnly" + notes = "This Resource Group is Read-Only" +} +``` + +## Example Usage (Resource Level Lock) + +```hcl +resource "azurerm_resource_group" "test" { + name = "locked-resource-group" + location = "West Europe" +} + +resource "azurerm_public_ip" "test" { + name = "locked-publicip" + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" + public_ip_address_allocation = "static" + idle_timeout_in_minutes = 30 +} + +resource "azurerm_management_lock" "public-ip" { + name = "resource-ip" + scope = "${azurerm_public_ip.test.id}" + lock_level = "CanNotDelete" + notes = "Locked because it's needed by a third-party" +} +``` + +## Argument Reference + +The following arguments are supported: + +* `name` - (Required) Specifies the name of the Management Lock. Changing this forces a new resource to be created. + +* `scope` - (Required) Specifies the scope at which the Management Lock should be created. Changing this forces a new resource to be created. + +* `lock_level` - (Required) Specifies the Level to be used for this Lock. Possible values are `CanNotDelete` and `ReadOnly`. Changing this forces a new resource to be created. + +~> **Note:** `CanNotDelete` means authorized users are able to read and modify the resources, but not delete. `ReadOnly` means authorized users can only read from a resource, but they can't modify or delete it. + +* `note` - (Optional) Specifies some notes about the lock. Maximum of 512 characters. Changing this forces a new resource to be created. + +## Attributes Reference + +The following attributes are exported: + +* `id` - The ID of the Management Lock + +## Import + +Management Locks can be imported using the `resource id`, e.g. + +```shell +terraform import azurerm_management_lock.lock1 /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup1/providers/Microsoft.Authorization/locks/lock1 +``` From 7af969332de2adbeac757b51def83d3d966ecdb8 Mon Sep 17 00:00:00 2001 From: Tom Harvey Date: Mon, 20 Nov 2017 12:33:14 +0100 Subject: [PATCH 18/55] Updating to include #573 --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6302ef72864a..43d5d38d3127 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,7 @@ IMPROVEMENTS: +* authentication: add support for the latest Azure CLI configuration [GH-573] * `azurerm_eventhub_namespace`: capacity can now be configured up to 20 [GH-556] * `azurerm_eventhub_namespace` - support for AutoInflating/MaximumThroughputCapacity [GH-569] * `azurerm_virtual_machine_scale_set`: Support for updating the customData field [GH-559] From f3f6c4cfd7c6e56ddfe2b3ae183043f7806ae014 Mon Sep 17 00:00:00 2001 From: Tom Harvey Date: Tue, 21 Nov 2017 09:21:37 +0100 Subject: [PATCH 19/55] Updating to include #571 --- CHANGELOG.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 43d5d38d3127..96d29fedd189 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,9 @@ ## 1.0.0 (Unreleased) +FEATURES: + +* New Resource: `azurerm_network_watcher` [GH-571] + IMPROVEMENTS: * authentication: add support for the latest Azure CLI configuration [GH-573] From 8fe5b5f89419dfef3fd541b9ffa16f3abeebd176 Mon Sep 17 00:00:00 2001 From: tombuildsstuff Date: Tue, 21 Nov 2017 12:42:45 +0100 Subject: [PATCH 20/55] Adding validation for the locks name Tests: ``` $ acctests azurerm TestValidateManagementLockName === RUN TestValidateManagementLockName --- PASS: TestValidateManagementLockName (0.00s) PASS ok github.com/terraform-providers/terraform-provider-azurerm/azurerm 0.020s ``` --- azurerm/resource_arm_management_lock.go | 26 ++++++++++++++----- azurerm/resource_arm_management_lock_test.go | 27 ++++++++++++++++++++ 2 files changed, 47 insertions(+), 6 deletions(-) diff --git a/azurerm/resource_arm_management_lock.go b/azurerm/resource_arm_management_lock.go index b1888c3793a4..47e661bb1144 100644 --- a/azurerm/resource_arm_management_lock.go +++ b/azurerm/resource_arm_management_lock.go @@ -5,6 +5,8 @@ import ( "log" "strings" + "regexp" + "github.com/Azure/azure-sdk-for-go/arm/resources/locks" "github.com/hashicorp/terraform/helper/schema" "github.com/hashicorp/terraform/helper/validation" @@ -22,12 +24,10 @@ func resourceArmManagementLock() *schema.Resource { Schema: map[string]*schema.Schema{ "name": { - Type: schema.TypeString, - Required: true, - ForceNew: true, - // TODO: validation - // The lock name can be a maximum of 260 characters. - // It cannot contain <, > %, &, :, \, ?, /, or any control characters. + Type: schema.TypeString, + Required: true, + ForceNew: true, + ValidateFunc: validateArmManagementLockName, }, "scope": { @@ -145,6 +145,10 @@ type AzureManagementLockId struct { func parseAzureRMLockId(id string) (*AzureManagementLockId, error) { segments := strings.Split(id, "/providers/Microsoft.Authorization/locks/") + if len(segments) != 2 { + return nil, fmt.Errorf("Expected ID to be in the format `{scope}/providers/Microsoft.Authorization/locks/{name} - got %d segments", len(segments)) + } + scope := segments[0] name := segments[1] lockId := AzureManagementLockId{ @@ -153,3 +157,13 @@ func parseAzureRMLockId(id string) (*AzureManagementLockId, error) { } return &lockId, nil } + +func validateArmManagementLockName(v interface{}, k string) (ws []string, es []error) { + input := v.(string) + + if !regexp.MustCompile(`\A([A-Za-z0-9\-_]{1, 260})\z`).MatchString(input) { + es = append(es, fmt.Errorf("%s can only consist of alphanumeric characters, dashes and underscores - and must be a maxiumum of 260 characters", k)) + } + + return +} diff --git a/azurerm/resource_arm_management_lock_test.go b/azurerm/resource_arm_management_lock_test.go index 382042d3b04a..9c57436b6f08 100644 --- a/azurerm/resource_arm_management_lock_test.go +++ b/azurerm/resource_arm_management_lock_test.go @@ -12,6 +12,33 @@ import ( "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" ) +func TestValidateManagementLockName(t *testing.T) { + str := acctest.RandString(259) + testCases := []struct { + input string + shouldError bool + }{ + {"ab", false}, + {"ABC", false}, + {"abc", false}, + {"abc123ABC", false}, + {"123abcABC", false}, + {"ABC123abc", false}, + {"abc-123", false}, + {"abc_123", false}, + {str, false}, + {str + "h", true}, + } + + for _, test := range testCases { + _, es := validateArmStorageAccountName(test.input, "name") + + if test.shouldError && len(es) == 0 { + t.Fatalf("Expected validating name %q to fail", test.input) + } + } +} + func TestAccAzureRMManagementLock_resourceGroupReadOnlyBasic(t *testing.T) { resourceName := "azurerm_management_lock.test" ri := acctest.RandInt() From 032c7acb38359de7e8e19ec05ed6ef59c8d64058 Mon Sep 17 00:00:00 2001 From: tombuildsstuff Date: Tue, 21 Nov 2017 12:46:53 +0100 Subject: [PATCH 21/55] Linting --- azurerm/config.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/azurerm/config.go b/azurerm/config.go index a63d979a53fa..a8c339a83a97 100644 --- a/azurerm/config.go +++ b/azurerm/config.go @@ -162,7 +162,7 @@ type ArmClient struct { sqlFirewallRulesClient sql.FirewallRulesClient sqlServersClient sql.ServersClient - // Networking + // Networking watcherClient network.WatchersClient // Resources From 487c48f5ef1db3bec724d0cf753e66bed9ea512d Mon Sep 17 00:00:00 2001 From: Tom Harvey Date: Tue, 21 Nov 2017 13:11:47 +0100 Subject: [PATCH 22/55] Updating to include #575 --- CHANGELOG.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 96d29fedd189..b8037f660bd1 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,7 +2,8 @@ FEATURES: -* New Resource: `azurerm_network_watcher` [GH-571] +* **New Resource:** `azurerm_management_lock` [GH-575] +* **New Resource:** `azurerm_network_watcher` [GH-571] IMPROVEMENTS: From f9f121eebd1d38a83012e7c9f9865ea85bb000d3 Mon Sep 17 00:00:00 2001 From: Tom Harvey Date: Tue, 21 Nov 2017 21:53:52 +0100 Subject: [PATCH 23/55] Updating the changelog for consistency --- CHANGELOG.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index b8037f660bd1..7d070dd945e6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,9 +8,9 @@ FEATURES: IMPROVEMENTS: * authentication: add support for the latest Azure CLI configuration [GH-573] -* `azurerm_eventhub_namespace`: capacity can now be configured up to 20 [GH-556] +* `azurerm_eventhub_namespace` - capacity can now be configured up to 20 [GH-556] * `azurerm_eventhub_namespace` - support for AutoInflating/MaximumThroughputCapacity [GH-569] -* `azurerm_virtual_machine_scale_set`: Support for updating the customData field [GH-559] +* `azurerm_virtual_machine_scale_set` - Support for updating the customData field [GH-559] ## 0.3.3 (November 14, 2017) From b5be3fad90ff758331d1714f7285990ac54a0835 Mon Sep 17 00:00:00 2001 From: Damien Caro Date: Sat, 25 Nov 2017 18:24:26 -0800 Subject: [PATCH 24/55] removed tabs, used spaces --- azurerm/data_source_virtual_network_test.go | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/azurerm/data_source_virtual_network_test.go b/azurerm/data_source_virtual_network_test.go index e218579f87f3..8830b6c40391 100644 --- a/azurerm/data_source_virtual_network_test.go +++ b/azurerm/data_source_virtual_network_test.go @@ -70,7 +70,7 @@ func testAccDataSourceArmVirtualNetwork_basic(rInt int, location string) string dns_servers = ["10.0.0.4"] subnet { - name = "subnet1" + name = "subnet1" address_prefix = "10.0.1.0/24" } } @@ -105,15 +105,15 @@ func testAccDataSourceArmVirtualNetwork_peering(rInt int, location string) strin } resource "azurerm_virtual_network_peering" "test1" { - name = "peer-1to2" - resource_group_name = "${azurerm_resource_group.test.name}" - virtual_network_name = "${azurerm_virtual_network.test1.name}" - remote_virtual_network_id = "${azurerm_virtual_network.test2.id}" + name = "peer-1to2" + resource_group_name = "${azurerm_resource_group.test.name}" + virtual_network_name = "${azurerm_virtual_network.test1.name}" + remote_virtual_network_id = "${azurerm_virtual_network.test2.id}" } data "azurerm_virtual_network" "test" { resource_group_name = "${azurerm_resource_group.test.name}" - name = "${azurerm_virtual_network.test1.name}" + name = "${azurerm_virtual_network.test1.name}" } `, rInt, location, rInt, rInt) } From 4b94d4834184b9fdfd5d3d836b201129e3469341 Mon Sep 17 00:00:00 2001 From: Greg Oliver Date: Tue, 28 Nov 2017 08:34:47 -0800 Subject: [PATCH 25/55] add test for issue #450 --- azurerm/resource_arm_route_table_test.go | 127 +++++++++++++++++++++++ 1 file changed, 127 insertions(+) diff --git a/azurerm/resource_arm_route_table_test.go b/azurerm/resource_arm_route_table_test.go index ee0ea02a3166..09d9e106f636 100644 --- a/azurerm/resource_arm_route_table_test.go +++ b/azurerm/resource_arm_route_table_test.go @@ -169,6 +169,36 @@ func TestAccAzureRMRouteTable_multipleRoutes(t *testing.T) { }) } +func TestAccAzureRMRouteTable_withTagsSubnet(t *testing.T) { + ri := acctest.RandInt() + configSetup := testAccAzureRMRouteTable_withTagsSubnet(ri, testLocation()) + configTest := testAccAzureRMRouteTable_withAddTagsSubnet(ri, testLocation()) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMRouteTableDestroy, + Steps: []resource.TestStep{ + { + Config: configSetup, + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMRouteTableExists("azurerm_route_table.test"), + testCheckAzureRMSubnetExists("azurerm_subnet.subnet1"), + resource.TestCheckResourceAttrSet("azurerm_subnet.subnet1", "route_table_id"), + ), + }, + { + Config: configTest, + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMRouteTableExists("azurerm_route_table.test"), + testCheckAzureRMSubnetExists("azurerm_subnet.subnet1"), + resource.TestCheckResourceAttrSet("azurerm_subnet.subnet1", "route_table_id"), + ), + }, + }, + }) +} + func testCheckAzureRMRouteTableExists(name string) resource.TestCheckFunc { return func(s *terraform.State) error { @@ -380,3 +410,100 @@ resource "azurerm_route_table" "test" { } `, rInt, location, rInt) } + +func testAccAzureRMRouteTable_withTagsSubnet(rInt int, location string) string { + return fmt.Sprintf(` +resource "azurerm_resource_group" "test" { + name = "acctestRG-%d" + location = "%s" + tags { + environment = "staging" + } +} + +resource "azurerm_virtual_network" "test" { + name = "acctestvirtnet%d" + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" + address_space = ["10.0.0.0/16"] + + tags { + environment = "staging" + } +} + +resource "azurerm_subnet" "subnet1" { + name = "subnet1" + resource_group_name = "${azurerm_resource_group.test.name}" + virtual_network_name = "${azurerm_virtual_network.test.name}" + address_prefix = "10.0.1.0/24" + route_table_id = "${azurerm_route_table.test.id}" +} + +resource "azurerm_route_table" "test" { + name = "acctestrt%d" + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" + + route { + name = "route1" + address_prefix = "10.1.0.0/16" + next_hop_type = "vnetlocal" + } + + tags { + environment = "staging" + } +} +`, rInt, location, rInt, rInt) +} + +func testAccAzureRMRouteTable_withAddTagsSubnet(rInt int, location string) string { + return fmt.Sprintf(` +resource "azurerm_resource_group" "test" { + name = "acctestRG-%d" + location = "%s" + tags { + environment = "staging" + cloud = "Azure" + } +} + +resource "azurerm_virtual_network" "test" { + name = "acctestvirtnet%d" + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" + address_space = ["10.0.0.0/16"] + + tags { + environment = "staging" + cloud = "Azure" + } +} + +resource "azurerm_subnet" "subnet1" { + name = "subnet1" + resource_group_name = "${azurerm_resource_group.test.name}" + virtual_network_name = "${azurerm_virtual_network.test.name}" + address_prefix = "10.0.1.0/24" + route_table_id = "${azurerm_route_table.test.id}" +} + +resource "azurerm_route_table" "test" { + name = "acctestrt%d" + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" + + route { + name = "route1" + address_prefix = "10.1.0.0/16" + next_hop_type = "vnetlocal" + } + + tags { + environment = "staging" + cloud = "Azure" + } +} +`, rInt, location, rInt, rInt) +} From ac14281fbcc0ef1f68da669340f49511577c8429 Mon Sep 17 00:00:00 2001 From: Jeffrey Cline Date: Tue, 28 Nov 2017 16:02:57 -0800 Subject: [PATCH 26/55] Updated the way user agent string gets assigned. --- azurerm/config.go | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/azurerm/config.go b/azurerm/config.go index a8c339a83a97..0ca0e2a4ebe0 100644 --- a/azurerm/config.go +++ b/azurerm/config.go @@ -198,10 +198,14 @@ func withRequestLogging() autorest.SendDecorator { } func setUserAgent(client *autorest.Client) { - version := terraform.VersionString() - client.UserAgent = fmt.Sprintf("HashiCorp-Terraform-v%s", version) + // if the user agent already has a value append Terraform user agent string + if tfVersion := fmt.Sprintf("HashiCorp-Terraform-v%s", terraform.VersionString()); client.UserAgent != "" { + client.UserAgent = fmt.Sprintf("%s;%s", client.UserAgent, tfVersion) + } else { + client.UserAgent = tfVersion + } - // append the CloudShell version to the user agent + // append the CloudShell version to the user agent if it exists if azureAgent := os.Getenv("AZURE_HTTP_USER_AGENT"); azureAgent != "" { client.UserAgent = fmt.Sprintf("%s;%s", client.UserAgent, azureAgent) } From 143602307090df447a37225b342ab54a2114f8ba Mon Sep 17 00:00:00 2001 From: Jeffrey Cline Date: Tue, 28 Nov 2017 18:56:36 -0800 Subject: [PATCH 27/55] Changed code to make it more readable. --- azurerm/config.go | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/azurerm/config.go b/azurerm/config.go index 0ca0e2a4ebe0..9b20737f9a16 100644 --- a/azurerm/config.go +++ b/azurerm/config.go @@ -198,9 +198,11 @@ func withRequestLogging() autorest.SendDecorator { } func setUserAgent(client *autorest.Client) { - // if the user agent already has a value append Terraform user agent string - if tfVersion := fmt.Sprintf("HashiCorp-Terraform-v%s", terraform.VersionString()); client.UserAgent != "" { - client.UserAgent = fmt.Sprintf("%s;%s", client.UserAgent, tfVersion) + tfVersion := fmt.Sprintf("HashiCorp-Terraform-v%s", terraform.VersionString()) + + // if the user agent already has a value append the Terraform user agent string + if curUserAgent := client.UserAgent; curUserAgent != "" { + client.UserAgent = fmt.Sprintf("%s;%s", curUserAgent, tfVersion) } else { client.UserAgent = tfVersion } From 6e8f6ea12129ad561d00a88f1c1af225093b9e63 Mon Sep 17 00:00:00 2001 From: Henry Buckle Date: Wed, 29 Nov 2017 07:23:27 +0000 Subject: [PATCH 28/55] pr tweaks --- azurerm/resource_arm_virtual_machine.go | 8 ++++++-- website/docs/r/virtual_machine.html.markdown | 2 +- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/azurerm/resource_arm_virtual_machine.go b/azurerm/resource_arm_virtual_machine.go index 59f68fd8603a..0d51abf56073 100644 --- a/azurerm/resource_arm_virtual_machine.go +++ b/azurerm/resource_arm_virtual_machine.go @@ -79,8 +79,12 @@ func resourceArmVirtualMachine() *schema.Resource { Elem: &schema.Resource{ Schema: map[string]*schema.Schema{ "type": { - Type: schema.TypeString, - Required: true, + Type: schema.TypeString, + Required: true, + DiffSuppressFunc: ignoreCaseDiffSuppressFunc, + ValidateFunc: validation.StringInSlice([]string{ + "SystemAssigned", + }, true), }, "principal_id": { Type: schema.TypeString, diff --git a/website/docs/r/virtual_machine.html.markdown b/website/docs/r/virtual_machine.html.markdown index fe6c21546092..8ad1321e13ea 100644 --- a/website/docs/r/virtual_machine.html.markdown +++ b/website/docs/r/virtual_machine.html.markdown @@ -326,7 +326,7 @@ resource "azurerm_virtual_machine" "test" { `identity` supports the following: -* `type` - (Required) Specifies the identity type of the virtual machine. The only allowable value is `SystemAssigned`. To enable Managed Service Identity the ManagedIdentityExtension must also be added to the virtual machine. The Principal ID can be retrieved after the virtual machine has been created, e.g. +* `type` - (Required) Specifies the identity type of the virtual machine. The only allowable value is `SystemAssigned`. To enable Managed Service Identity the virtual machine extension "ManagedIdentityExtensionForWindows" or "ManagedIdentityExtensionForLinux" must also be added to the virtual machine. The Principal ID can be retrieved after the virtual machine has been created, e.g. ```hcl resource "azurerm_virtual_machine" "test" { From de19f2fcd860208084ad03e8d979278796e70a95 Mon Sep 17 00:00:00 2001 From: dmitri Date: Wed, 29 Nov 2017 17:27:57 +0100 Subject: [PATCH 29/55] Avoid out of index errors when flattening image data disks. --- azurerm/resource_arm_image.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/azurerm/resource_arm_image.go b/azurerm/resource_arm_image.go index 9d92987bdb29..5793ac8fe16c 100644 --- a/azurerm/resource_arm_image.go +++ b/azurerm/resource_arm_image.go @@ -314,7 +314,7 @@ func flattenAzureRmImageDataDisks(d *schema.ResourceData, diskImages *[]compute. result := make([]interface{}, 0) if images := diskImages; images != nil { - for i, disk := range *images { + for _, disk := range *images { l := make(map[string]interface{}) if disk.BlobURI != nil { l["blob_uri"] = *disk.BlobURI @@ -328,7 +328,7 @@ func flattenAzureRmImageDataDisks(d *schema.ResourceData, diskImages *[]compute. l["managed_disk_id"] = *disk.ManagedDisk.ID } - result[i] = l + result = append(result, l) } } From dd91170c18e7aed58b9a9d8c564b7a8bb76341e5 Mon Sep 17 00:00:00 2001 From: Tom Harvey Date: Thu, 30 Nov 2017 10:57:38 +0000 Subject: [PATCH 30/55] Updating to include #587 --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7d070dd945e6..d9e3d573d030 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,7 @@ FEATURES: IMPROVEMENTS: * authentication: add support for the latest Azure CLI configuration [GH-573] +* core: appending additions to the User Agent, so we don't overwrite the Go SDK User Agent info [GH-587] * `azurerm_eventhub_namespace` - capacity can now be configured up to 20 [GH-556] * `azurerm_eventhub_namespace` - support for AutoInflating/MaximumThroughputCapacity [GH-569] * `azurerm_virtual_machine_scale_set` - Support for updating the customData field [GH-559] From 61b167158a5d7b46ebbb5135064eb9a54d69b0e3 Mon Sep 17 00:00:00 2001 From: Tom Harvey Date: Thu, 30 Nov 2017 11:23:25 +0000 Subject: [PATCH 31/55] Updating to include #589 --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index d9e3d573d030..d445a5189d04 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,7 @@ IMPROVEMENTS: * core: appending additions to the User Agent, so we don't overwrite the Go SDK User Agent info [GH-587] * `azurerm_eventhub_namespace` - capacity can now be configured up to 20 [GH-556] * `azurerm_eventhub_namespace` - support for AutoInflating/MaximumThroughputCapacity [GH-569] +* `azurerm_image`: fixing an out of index error when flattening image data disks [GH-589] * `azurerm_virtual_machine_scale_set` - Support for updating the customData field [GH-559] ## 0.3.3 (November 14, 2017) From cd6457ba6a0d44cd4d7a86b4089717e8dc98945a Mon Sep 17 00:00:00 2001 From: tombuildsstuff Date: Sat, 18 Nov 2017 07:49:01 +0000 Subject: [PATCH 32/55] Conditional loading of the Subscription ID / Tenant ID / Environment --- azurerm/provider.go | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/azurerm/provider.go b/azurerm/provider.go index 8c58bad0ae45..f1a76e995529 100644 --- a/azurerm/provider.go +++ b/azurerm/provider.go @@ -257,15 +257,19 @@ func (c *Config) LoadTokensFromAzureCLI() error { return fmt.Errorf("Azure CLI Authorization Profile was not found. Please ensure the Azure CLI is installed and then log-in with `az login`.") } - // pull out the TenantID and Subscription ID from the Azure Profile, if not set - if c.SubscriptionID == "" && c.TenantID == "" { - for _, subscription := range profile.Subscriptions { - if subscription.IsDefault { + // pull out the Subscription ID / Tenant ID / Environment from the Azure Profile, if not set + for _, subscription := range profile.Subscriptions { + if subscription.IsDefault { + if c.SubscriptionID == "" { c.SubscriptionID = subscription.ID + } + if c.TenantID == "" { c.TenantID = subscription.TenantID + } + if c.Environment == "" { c.Environment = normalizeEnvironmentName(subscription.EnvironmentName) - break } + break } } From fe1e0f53c7e6bf84627092cf31b1fb2aacba652b Mon Sep 17 00:00:00 2001 From: tombuildsstuff Date: Thu, 30 Nov 2017 14:59:59 +0000 Subject: [PATCH 33/55] Refactoring the provider block to support determining the TenantID/Environment from the SubscriptionID Splitting out the authentication logic into a helpers folder Also adding unit tests for these - which pass: ``` $ go test . -v === RUN TestAzureFindValidAccessTokenForTenant_InvalidDate --- PASS: TestAzureFindValidAccessTokenForTenant_InvalidDate (0.00s) === RUN TestAzureFindValidAccessTokenForTenant_Expired 2017/11/30 15:02:01 [DEBUG] Token "7cabcf30-8dca-43f9-91e6-fd56dfb8632f" has expired --- PASS: TestAzureFindValidAccessTokenForTenant_Expired (0.00s) === RUN TestAzureFindValidAccessTokenForTenant_ExpiringIn --- PASS: TestAzureFindValidAccessTokenForTenant_ExpiringIn (0.00s) === RUN TestAzureFindValidAccessTokenForTenant_InvalidManagementDomain 2017/11/30 15:02:01 [DEBUG] Resource "https://portal.azure.com/" isn't a management domain --- PASS: TestAzureFindValidAccessTokenForTenant_InvalidManagementDomain (0.00s) === RUN TestAzureFindValidAccessTokenForTenant_DifferentTenant 2017/11/30 15:02:01 [DEBUG] Resource "https://management.core.windows.net/" isn't for the correct Tenant --- PASS: TestAzureFindValidAccessTokenForTenant_DifferentTenant (0.00s) === RUN TestAzureFindValidAccessTokenForTenant_ValidFromCloudShell --- PASS: TestAzureFindValidAccessTokenForTenant_ValidFromCloudShell (0.00s) === RUN TestAzureFindValidAccessTokenForTenant_ValidFromAzureCLI --- PASS: TestAzureFindValidAccessTokenForTenant_ValidFromAzureCLI (0.00s) === RUN TestAzureFindValidAccessTokenForTenant_NoTokens --- PASS: TestAzureFindValidAccessTokenForTenant_NoTokens (0.00s) === RUN TestAzureCLIProfileFindDefaultSubscription --- PASS: TestAzureCLIProfileFindDefaultSubscription (0.00s) === RUN TestAzureCLIProfileFindSubscription --- PASS: TestAzureCLIProfileFindSubscription (0.00s) === RUN TestAzurePopulateSubscriptionFromCLIProfile_Missing --- PASS: TestAzurePopulateSubscriptionFromCLIProfile_Missing (0.00s) === RUN TestAzurePopulateSubscriptionFromCLIProfile_NoDefault --- PASS: TestAzurePopulateSubscriptionFromCLIProfile_NoDefault (0.00s) === RUN TestAzurePopulateSubscriptionFromCLIProfile_Default --- PASS: TestAzurePopulateSubscriptionFromCLIProfile_Default (0.00s) === RUN TestAzurePopulateTenantAndEnvironmentFromCLIProfile_Empty --- PASS: TestAzurePopulateTenantAndEnvironmentFromCLIProfile_Empty (0.00s) === RUN TestAzurePopulateTenantAndEnvironmentFromCLIProfile_MissingSubscription --- PASS: TestAzurePopulateTenantAndEnvironmentFromCLIProfile_MissingSubscription (0.00s) === RUN TestAzurePopulateTenantAndEnvironmentFromCLIProfile_PopulateEnvironment --- PASS: TestAzurePopulateTenantAndEnvironmentFromCLIProfile_PopulateEnvironment (0.00s) === RUN TestAzurePopulateTenantAndEnvironmentFromCLIProfile_NormaliseAndPopulateEnvironment --- PASS: TestAzurePopulateTenantAndEnvironmentFromCLIProfile_NormaliseAndPopulateEnvironment (0.00s) === RUN TestAzurePopulateTenantAndEnvironmentFromCLIProfile_PopulateTenantId --- PASS: TestAzurePopulateTenantAndEnvironmentFromCLIProfile_PopulateTenantId (0.00s) === RUN TestAzurePopulateTenantAndEnvironmentFromCLIProfile_Complete --- PASS: TestAzurePopulateTenantAndEnvironmentFromCLIProfile_Complete (0.00s) === RUN TestAzurePopulateFromAccessToken_Missing --- PASS: TestAzurePopulateFromAccessToken_Missing (0.00s) === RUN TestAzurePopulateFromAccessToken_Exists --- PASS: TestAzurePopulateFromAccessToken_Exists (0.00s) === RUN TestAzureEnvironmentNames --- PASS: TestAzureEnvironmentNames (0.00s) === RUN TestAzureValidateBearerAuth --- PASS: TestAzureValidateBearerAuth (0.00s) === RUN TestAzureValidateServicePrincipal --- PASS: TestAzureValidateServicePrincipal (0.00s) PASS ok github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/authentication 0.012s ``` --- azurerm/config.go | 11 +- .../helpers/authentication/access_token.go | 55 ++++ .../authentication/access_token_test.go | 217 +++++++++++++ .../authentication/azure_cli_profile.go | 33 ++ .../authentication/azure_cli_profile_test.go | 192 ++++++++++++ azurerm/helpers/authentication/config.go | 132 ++++++++ azurerm/helpers/authentication/config_test.go | 285 ++++++++++++++++++ azurerm/helpers/authentication/environment.go | 16 + .../authentication/environment_test.go | 23 ++ azurerm/helpers/authentication/validation.go | 51 ++++ .../helpers/authentication/validation_test.go | 166 ++++++++++ azurerm/provider.go | 172 +---------- azurerm/provider_test.go | 7 +- 13 files changed, 1185 insertions(+), 175 deletions(-) create mode 100644 azurerm/helpers/authentication/access_token.go create mode 100644 azurerm/helpers/authentication/access_token_test.go create mode 100644 azurerm/helpers/authentication/azure_cli_profile.go create mode 100644 azurerm/helpers/authentication/azure_cli_profile_test.go create mode 100644 azurerm/helpers/authentication/config.go create mode 100644 azurerm/helpers/authentication/config_test.go create mode 100644 azurerm/helpers/authentication/environment.go create mode 100644 azurerm/helpers/authentication/environment_test.go create mode 100644 azurerm/helpers/authentication/validation.go create mode 100644 azurerm/helpers/authentication/validation_test.go diff --git a/azurerm/config.go b/azurerm/config.go index 9b20737f9a16..289ffc0b33a3 100644 --- a/azurerm/config.go +++ b/azurerm/config.go @@ -44,6 +44,7 @@ import ( "github.com/Azure/go-autorest/autorest/adal" "github.com/Azure/go-autorest/autorest/azure" "github.com/hashicorp/terraform/terraform" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/authentication" ) // ArmClient contains the handles to all the specific Azure Resource Manager @@ -213,7 +214,7 @@ func setUserAgent(client *autorest.Client) { } } -func (c *Config) getAuthorizationToken(oauthConfig *adal.OAuthConfig, endpoint string) (*autorest.BearerAuthorizer, error) { +func getAuthorizationToken(c *authentication.Config, oauthConfig *adal.OAuthConfig, endpoint string) (*autorest.BearerAuthorizer, error) { useServicePrincipal := c.ClientSecret != "" if useServicePrincipal { @@ -245,7 +246,7 @@ func (c *Config) getAuthorizationToken(oauthConfig *adal.OAuthConfig, endpoint s // getArmClient is a helper method which returns a fully instantiated // *ArmClient based on the Config's current settings. -func (c *Config) getArmClient() (*ArmClient, error) { +func getArmClient(c *authentication.Config) (*ArmClient, error) { // detect cloud from environment env, envErr := azure.EnvironmentFromName(c.Environment) if envErr != nil { @@ -280,21 +281,21 @@ func (c *Config) getArmClient() (*ArmClient, error) { // Resource Manager endpoints endpoint := env.ResourceManagerEndpoint - auth, err := c.getAuthorizationToken(oauthConfig, endpoint) + auth, err := getAuthorizationToken(c, oauthConfig, endpoint) if err != nil { return nil, err } // Graph Endpoints graphEndpoint := env.GraphEndpoint - graphAuth, err := c.getAuthorizationToken(oauthConfig, graphEndpoint) + graphAuth, err := getAuthorizationToken(c, oauthConfig, graphEndpoint) if err != nil { return nil, err } // Key Vault Endpoints keyVaultAuth := autorest.NewBearerAuthorizerCallback(sender, func(tenantID, resource string) (*autorest.BearerAuthorizer, error) { - keyVaultSpt, err := c.getAuthorizationToken(oauthConfig, resource) + keyVaultSpt, err := getAuthorizationToken(c, oauthConfig, resource) if err != nil { return nil, err } diff --git a/azurerm/helpers/authentication/access_token.go b/azurerm/helpers/authentication/access_token.go new file mode 100644 index 000000000000..6fa06355b8d6 --- /dev/null +++ b/azurerm/helpers/authentication/access_token.go @@ -0,0 +1,55 @@ +package authentication + +import ( + "fmt" + "log" + "strings" + "time" + + "github.com/Azure/go-autorest/autorest/adal" + "github.com/Azure/go-autorest/autorest/azure/cli" +) + +type AccessToken struct { + ClientID string + AccessToken *adal.Token + IsCloudShell bool +} + +func findValidAccessTokenForTenant(tokens []cli.Token, tenantId string) (*AccessToken, error) { + for _, accessToken := range tokens { + token, err := accessToken.ToADALToken() + if err != nil { + return nil, fmt.Errorf("[DEBUG] Error converting access token to token: %+v", err) + } + + expirationDate, err := cli.ParseExpirationDate(accessToken.ExpiresOn) + if err != nil { + return nil, fmt.Errorf("Error parsing expiration date: %q", accessToken.ExpiresOn) + } + + if expirationDate.UTC().Before(time.Now().UTC()) { + log.Printf("[DEBUG] Token %q has expired", token.AccessToken) + continue + } + + if !strings.Contains(accessToken.Resource, "management") { + log.Printf("[DEBUG] Resource %q isn't a management domain", accessToken.Resource) + continue + } + + if !strings.HasSuffix(accessToken.Authority, tenantId) { + log.Printf("[DEBUG] Resource %q isn't for the correct Tenant", accessToken.Resource) + continue + } + + validAccessToken := AccessToken{ + ClientID: accessToken.ClientID, + AccessToken: &token, + IsCloudShell: accessToken.RefreshToken == "", + } + return &validAccessToken, nil + } + + return nil, fmt.Errorf("No Access Token was found for the Tenant ID %q", tenantId) +} diff --git a/azurerm/helpers/authentication/access_token_test.go b/azurerm/helpers/authentication/access_token_test.go new file mode 100644 index 000000000000..3eccdd341687 --- /dev/null +++ b/azurerm/helpers/authentication/access_token_test.go @@ -0,0 +1,217 @@ +package authentication + +import ( + "testing" + "time" + + "github.com/Azure/go-autorest/autorest/azure/cli" +) + +func TestAzureFindValidAccessTokenForTenant_InvalidDate(t *testing.T) { + tenantId := "c056adac-c6a6-4ddf-ab20-0f26d47f7eea" + expectedToken := cli.Token{ + ExpiresOn: "invalid date", + AccessToken: "7cabcf30-8dca-43f9-91e6-fd56dfb8632f", + TokenType: "9b10b986-7a61-4542-8d5a-9fcd96112585", + RefreshToken: "4ec3874d-ee2e-4980-ba47-b5bac11ddb94", + Resource: "https://management.core.windows.net/", + Authority: tenantId, + } + tokens := []cli.Token{expectedToken} + token, err := findValidAccessTokenForTenant(tokens, tenantId) + + if err == nil { + t.Fatalf("Expected an error to be returned but got nil") + } + + if token != nil { + t.Fatalf("Expected Token to be nil but got: %+v", token) + } +} + +func TestAzureFindValidAccessTokenForTenant_Expired(t *testing.T) { + expirationDate := time.Now().Add(time.Minute * -1) + tenantId := "c056adac-c6a6-4ddf-ab20-0f26d47f7eea" + expectedToken := cli.Token{ + ExpiresOn: expirationDate.Format("2006-01-02 15:04:05.999999"), + AccessToken: "7cabcf30-8dca-43f9-91e6-fd56dfb8632f", + TokenType: "9b10b986-7a61-4542-8d5a-9fcd96112585", + RefreshToken: "4ec3874d-ee2e-4980-ba47-b5bac11ddb94", + Resource: "https://management.core.windows.net/", + Authority: tenantId, + } + tokens := []cli.Token{expectedToken} + token, err := findValidAccessTokenForTenant(tokens, tenantId) + + if err == nil { + t.Fatalf("Expected an error to be returned but got nil") + } + + if token != nil { + t.Fatalf("Expected Token to be nil but got: %+v", token) + } +} + +func TestAzureFindValidAccessTokenForTenant_ExpiringIn(t *testing.T) { + minutesToVerify := []int{1, 30, 60} + + for _, minute := range minutesToVerify { + expirationDate := time.Now().Add(time.Minute * time.Duration(minute)) + tenantId := "c056adac-c6a6-4ddf-ab20-0f26d47f7eea" + expectedToken := cli.Token{ + ExpiresOn: expirationDate.Format("2006-01-02 15:04:05.999999"), + AccessToken: "7cabcf30-8dca-43f9-91e6-fd56dfb8632f", + TokenType: "9b10b986-7a61-4542-8d5a-9fcd96112585", + RefreshToken: "4ec3874d-ee2e-4980-ba47-b5bac11ddb94", + Resource: "https://management.core.windows.net/", + Authority: tenantId, + } + tokens := []cli.Token{expectedToken} + token, err := findValidAccessTokenForTenant(tokens, tenantId) + + if err != nil { + t.Fatalf("Expected no error to be returned for minute %d but got %+v", minute, err) + } + + if token == nil { + t.Fatalf("Expected Token to have a value for minute %d but it was nil", minute) + } + + if token.AccessToken.AccessToken != expectedToken.AccessToken { + t.Fatalf("Expected the Access Token to be %q for minute %d but got %q", expectedToken.AccessToken, minute, token.AccessToken.AccessToken) + } + + if token.ClientID != expectedToken.ClientID { + t.Fatalf("Expected the Client ID to be %q for minute %d but got %q", expectedToken.ClientID, minute, token.ClientID) + } + + if token.IsCloudShell != false { + t.Fatalf("Expected `IsCloudShell` to be false for minute %d but got true", minute) + } + } +} + +func TestAzureFindValidAccessTokenForTenant_InvalidManagementDomain(t *testing.T) { + expirationDate := time.Now().Add(1 * time.Hour) + tenantId := "c056adac-c6a6-4ddf-ab20-0f26d47f7eea" + expectedToken := cli.Token{ + ExpiresOn: expirationDate.Format("2006-01-02 15:04:05.999999"), + AccessToken: "7cabcf30-8dca-43f9-91e6-fd56dfb8632f", + TokenType: "9b10b986-7a61-4542-8d5a-9fcd96112585", + Resource: "https://portal.azure.com/", + Authority: tenantId, + } + tokens := []cli.Token{expectedToken} + token, err := findValidAccessTokenForTenant(tokens, tenantId) + + if err == nil { + t.Fatalf("Expected an error but didn't get one") + } + + if token != nil { + t.Fatalf("Expected Token to be nil but got: %+v", token) + } +} + +func TestAzureFindValidAccessTokenForTenant_DifferentTenant(t *testing.T) { + expirationDate := time.Now().Add(1 * time.Hour) + expectedToken := cli.Token{ + ExpiresOn: expirationDate.Format("2006-01-02 15:04:05.999999"), + AccessToken: "7cabcf30-8dca-43f9-91e6-fd56dfb8632f", + TokenType: "9b10b986-7a61-4542-8d5a-9fcd96112585", + Resource: "https://management.core.windows.net/", + Authority: "9b5095de-5496-4b5e-9bc6-ef2c017b9d35", + } + tokens := []cli.Token{expectedToken} + token, err := findValidAccessTokenForTenant(tokens, "c056adac-c6a6-4ddf-ab20-0f26d47f7eea") + + if err == nil { + t.Fatalf("Expected an error but didn't get one") + } + + if token != nil { + t.Fatalf("Expected Token to be nil but got: %+v", token) + } +} + +func TestAzureFindValidAccessTokenForTenant_ValidFromCloudShell(t *testing.T) { + expirationDate := time.Now().Add(1 * time.Hour) + tenantId := "c056adac-c6a6-4ddf-ab20-0f26d47f7eea" + expectedToken := cli.Token{ + ExpiresOn: expirationDate.Format(time.RFC3339), + AccessToken: "7cabcf30-8dca-43f9-91e6-fd56dfb8632f", + TokenType: "9b10b986-7a61-4542-8d5a-9fcd96112585", + Resource: "https://management.core.windows.net/", + Authority: tenantId, + } + tokens := []cli.Token{expectedToken} + token, err := findValidAccessTokenForTenant(tokens, tenantId) + + if err != nil { + t.Fatalf("Expected no error to be returned but got %+v", err) + } + + if token == nil { + t.Fatalf("Expected Token to have a value but it was nil") + } + + if token.AccessToken.AccessToken != expectedToken.AccessToken { + t.Fatalf("Expected the Access Token to be %q but got %q", expectedToken.AccessToken, token.AccessToken.AccessToken) + } + + if token.ClientID != expectedToken.ClientID { + t.Fatalf("Expected the Client ID to be %q but got %q", expectedToken.ClientID, token.ClientID) + } + + if token.IsCloudShell != true { + t.Fatalf("Expected `IsCloudShell` to be true but got false") + } +} + +func TestAzureFindValidAccessTokenForTenant_ValidFromAzureCLI(t *testing.T) { + expirationDate := time.Now().Add(1 * time.Hour) + tenantId := "c056adac-c6a6-4ddf-ab20-0f26d47f7eea" + expectedToken := cli.Token{ + ExpiresOn: expirationDate.Format("2006-01-02 15:04:05.999999"), + AccessToken: "7cabcf30-8dca-43f9-91e6-fd56dfb8632f", + TokenType: "9b10b986-7a61-4542-8d5a-9fcd96112585", + RefreshToken: "4ec3874d-ee2e-4980-ba47-b5bac11ddb94", + Resource: "https://management.core.windows.net/", + Authority: tenantId, + } + tokens := []cli.Token{expectedToken} + token, err := findValidAccessTokenForTenant(tokens, tenantId) + + if err != nil { + t.Fatalf("Expected no error to be returned but got %+v", err) + } + + if token == nil { + t.Fatalf("Expected Token to have a value but it was nil") + } + + if token.AccessToken.AccessToken != expectedToken.AccessToken { + t.Fatalf("Expected the Access Token to be %q but got %q", expectedToken.AccessToken, token.AccessToken.AccessToken) + } + + if token.ClientID != expectedToken.ClientID { + t.Fatalf("Expected the Client ID to be %q but got %q", expectedToken.ClientID, token.ClientID) + } + + if token.IsCloudShell != false { + t.Fatalf("Expected `IsCloudShell` to be false but got true") + } +} + +func TestAzureFindValidAccessTokenForTenant_NoTokens(t *testing.T) { + tokens := make([]cli.Token, 0) + token, err := findValidAccessTokenForTenant(tokens, "abc123") + + if err == nil { + t.Fatalf("Expected an error but didn't get one") + } + + if token != nil { + t.Fatalf("Expected a null token to be returned but got: %+v", token) + } +} diff --git a/azurerm/helpers/authentication/azure_cli_profile.go b/azurerm/helpers/authentication/azure_cli_profile.go new file mode 100644 index 000000000000..8b563d7ab9cd --- /dev/null +++ b/azurerm/helpers/authentication/azure_cli_profile.go @@ -0,0 +1,33 @@ +package authentication + +import ( + "strings" + + "fmt" + + "github.com/Azure/go-autorest/autorest/azure/cli" +) + +type AzureCLIProfile struct { + cli.Profile +} + +func (a AzureCLIProfile) FindDefaultSubscriptionId() (string, error) { + for _, subscription := range a.Subscriptions { + if subscription.IsDefault { + return subscription.ID, nil + } + } + + return "", fmt.Errorf("No Subscription was Marked as Default in the Azure Profile.") +} + +func (a AzureCLIProfile) FindSubscription(subscriptionId string) (*cli.Subscription, error) { + for _, subscription := range a.Subscriptions { + if strings.EqualFold(subscription.ID, subscriptionId) { + return &subscription, nil + } + } + + return nil, fmt.Errorf("Subscription %q was not found in your Azure CLI credentials. Please verify it exists in `az account list`.", subscriptionId) +} diff --git a/azurerm/helpers/authentication/azure_cli_profile_test.go b/azurerm/helpers/authentication/azure_cli_profile_test.go new file mode 100644 index 000000000000..3b051ce366f3 --- /dev/null +++ b/azurerm/helpers/authentication/azure_cli_profile_test.go @@ -0,0 +1,192 @@ +package authentication + +import ( + "testing" + + "github.com/Azure/go-autorest/autorest/azure/cli" +) + +func TestAzureCLIProfileFindDefaultSubscription(t *testing.T) { + cases := []struct { + Description string + Subscriptions []cli.Subscription + ExpectedSubscriptionId string + ExpectError bool + }{ + { + Description: "Empty Subscriptions", + Subscriptions: []cli.Subscription{}, + ExpectError: true, + }, + { + Description: "Single Subscription", + Subscriptions: []cli.Subscription{ + { + ID: "7f68fe06-9404-4db8-a5c7-29639dc4b299", + IsDefault: true, + }, + }, + ExpectError: false, + ExpectedSubscriptionId: "7f68fe06-9404-4db8-a5c7-29639dc4b299", + }, + { + Description: "Multiple Subscriptions with First as the Default", + Subscriptions: []cli.Subscription{ + { + ID: "7f68fe06-9404-4db8-a5c7-29639dc4b299", + IsDefault: true, + }, + { + ID: "f36508bb-53b9-4aad-a2ac-2df86acf0c31", + IsDefault: false, + }, + }, + ExpectError: false, + ExpectedSubscriptionId: "7f68fe06-9404-4db8-a5c7-29639dc4b299", + }, + { + Description: "Multiple Subscriptions with Second as the Default", + Subscriptions: []cli.Subscription{ + { + ID: "7f68fe06-9404-4db8-a5c7-29639dc4b299", + IsDefault: false, + }, + { + ID: "f36508bb-53b9-4aad-a2ac-2df86acf0c31", + IsDefault: true, + }, + }, + ExpectError: false, + ExpectedSubscriptionId: "f36508bb-53b9-4aad-a2ac-2df86acf0c31", + }, + { + Description: "Multiple Subscriptions with None as the Default", + Subscriptions: []cli.Subscription{ + { + ID: "7f68fe06-9404-4db8-a5c7-29639dc4b299", + IsDefault: false, + }, + { + ID: "f36508bb-53b9-4aad-a2ac-2df86acf0c31", + IsDefault: false, + }, + }, + ExpectError: true, + }, + } + + for _, v := range cases { + profile := AzureCLIProfile{ + Profile: cli.Profile{ + Subscriptions: v.Subscriptions, + }, + } + actualSubscriptionId, err := profile.FindDefaultSubscriptionId() + + if v.ExpectError && err == nil { + t.Fatalf("Expected an error for %q: didn't get one", v.Description) + } + + if !v.ExpectError && err != nil { + t.Fatalf("Expected there to be no error for %q - but got: %v", v.Description, err) + } + + if actualSubscriptionId != v.ExpectedSubscriptionId { + t.Fatalf("Expected Subscription ID to be %q - got %q", v.ExpectedSubscriptionId, actualSubscriptionId) + } + } +} + +func TestAzureCLIProfileFindSubscription(t *testing.T) { + cases := []struct { + Description string + Subscriptions []cli.Subscription + SubscriptionIdToSearchFor string + ExpectError bool + }{ + { + Description: "Empty Subscriptions", + Subscriptions: []cli.Subscription{}, + SubscriptionIdToSearchFor: "7f68fe06-9404-4db8-a5c7-29639dc4b299", + ExpectError: true, + }, + { + Description: "Single Subscription", + SubscriptionIdToSearchFor: "7f68fe06-9404-4db8-a5c7-29639dc4b299", + Subscriptions: []cli.Subscription{ + { + ID: "7f68fe06-9404-4db8-a5c7-29639dc4b299", + IsDefault: true, + }, + }, + ExpectError: false, + }, + { + Description: "Finding the default subscription", + SubscriptionIdToSearchFor: "7f68fe06-9404-4db8-a5c7-29639dc4b299", + Subscriptions: []cli.Subscription{ + { + ID: "7f68fe06-9404-4db8-a5c7-29639dc4b299", + IsDefault: true, + }, + { + ID: "f36508bb-53b9-4aad-a2ac-2df86acf0c31", + IsDefault: false, + }, + }, + ExpectError: false, + }, + { + Description: "Finding a non default Subscription", + SubscriptionIdToSearchFor: "7f68fe06-9404-4db8-a5c7-29639dc4b299", + Subscriptions: []cli.Subscription{ + { + ID: "7f68fe06-9404-4db8-a5c7-29639dc4b299", + IsDefault: false, + }, + { + ID: "f36508bb-53b9-4aad-a2ac-2df86acf0c31", + IsDefault: true, + }, + }, + ExpectError: false, + }, + { + Description: "Multiple Subscriptions with None as the Default", + SubscriptionIdToSearchFor: "224f4ca6-117f-4928-bc0f-3df018feba3e", + Subscriptions: []cli.Subscription{ + { + ID: "7f68fe06-9404-4db8-a5c7-29639dc4b299", + IsDefault: false, + }, + { + ID: "f36508bb-53b9-4aad-a2ac-2df86acf0c31", + IsDefault: false, + }, + }, + ExpectError: true, + }, + } + + for _, v := range cases { + profile := AzureCLIProfile{ + Profile: cli.Profile{ + Subscriptions: v.Subscriptions, + }, + } + + subscription, err := profile.FindSubscription(v.SubscriptionIdToSearchFor) + + if v.ExpectError && err == nil { + t.Fatalf("Expected an error for %q: didn't get one", v.Description) + } + + if !v.ExpectError && err != nil { + t.Fatalf("Expected there to be no error for %q - but got: %v", v.Description, err) + } + + if subscription != nil && subscription.ID != v.SubscriptionIdToSearchFor { + t.Fatalf("Expected to find Subscription ID %q - got %q", subscription.ID, v.SubscriptionIdToSearchFor) + } + } +} diff --git a/azurerm/helpers/authentication/config.go b/azurerm/helpers/authentication/config.go new file mode 100644 index 000000000000..eb276c2e29d2 --- /dev/null +++ b/azurerm/helpers/authentication/config.go @@ -0,0 +1,132 @@ +package authentication + +import ( + "fmt" + + "log" + + "github.com/Azure/go-autorest/autorest/adal" + "github.com/Azure/go-autorest/autorest/azure/cli" +) + +// Config is the configuration structure used to instantiate a +// new Azure management client. +type Config struct { + ManagementURL string + + // Core + ClientID string + SubscriptionID string + TenantID string + Environment string + SkipCredentialsValidation bool + SkipProviderRegistration bool + + // Service Principal Auth + ClientSecret string + + // Bearer Auth + AccessToken *adal.Token + IsCloudShell bool +} + +func (c *Config) LoadTokensFromAzureCLI() error { + profilePath, err := cli.ProfilePath() + if err != nil { + return fmt.Errorf("Error loading the Profile Path from the Azure CLI: %+v", err) + } + + profile, err := cli.LoadProfile(profilePath) + if err != nil { + return fmt.Errorf("Azure CLI Authorization Profile was not found. Please ensure the Azure CLI is installed and then log-in with `az login`.") + } + + cliProfile := AzureCLIProfile{ + Profile: profile, + } + + // find the Subscription ID if it's not specified + if c.SubscriptionID == "" { + // we want to expose a more friendly error to the user, but this is useful for debug purposes + err := c.populateSubscriptionFromCLIProfile(cliProfile) + if err != nil { + log.Printf("Error Populating the Subscription from the CLI Profile: %s", err) + } + } + + // find the Tenant ID and Environment for that subscription if they're not specified + if c.TenantID == "" || c.Environment == "" { + err := c.populateTenantAndEnvironmentFromCLIProfile(cliProfile) + if err != nil { + // we want to expose a more friendly error to the user, but this is useful for debug purposes + log.Printf("Error Populating the Tenant and Environment from the CLI Profile: %s", err) + } + } + + foundToken := false + if c.TenantID != "" { + // pull out the ClientID and the AccessToken from the Azure Access Token + tokensPath, err := cli.AccessTokensPath() + if err != nil { + return fmt.Errorf("Error loading the Tokens Path from the Azure CLI: %+v", err) + } + + tokens, err := cli.LoadTokens(tokensPath) + if err != nil { + return fmt.Errorf("Azure CLI Authorization Tokens were not found. Please ensure the Azure CLI is installed and then log-in with `az login`.") + } + + validToken, _ := findValidAccessTokenForTenant(tokens, c.TenantID) + if validToken != nil { + foundToken, err = c.populateFromAccessToken(validToken) + if err != nil { + return err + } + } + } + + if !foundToken { + return fmt.Errorf("No valid (unexpired) Azure CLI Auth Tokens found. Please run `az login`.") + } + + return nil +} + +func (c *Config) populateSubscriptionFromCLIProfile(cliProfile AzureCLIProfile) error { + subscriptionId, err := cliProfile.FindDefaultSubscriptionId() + if err != nil { + return err + } + + c.SubscriptionID = subscriptionId + return nil +} + +func (c *Config) populateTenantAndEnvironmentFromCLIProfile(cliProfile AzureCLIProfile) error { + subscription, err := cliProfile.FindSubscription(c.SubscriptionID) + if err != nil { + return err + } + + if c.TenantID == "" { + c.TenantID = subscription.TenantID + } + + if c.Environment == "" { + c.Environment = normalizeEnvironmentName(subscription.EnvironmentName) + } + + return nil +} + +func (c *Config) populateFromAccessToken(token *AccessToken) (bool, error) { + if token == nil { + return false, fmt.Errorf("No valid access token was found to populate from") + } + + c.ClientID = token.ClientID + c.AccessToken = token.AccessToken + c.IsCloudShell = token.IsCloudShell + + return true, nil +} diff --git a/azurerm/helpers/authentication/config_test.go b/azurerm/helpers/authentication/config_test.go new file mode 100644 index 000000000000..8ccbb0082010 --- /dev/null +++ b/azurerm/helpers/authentication/config_test.go @@ -0,0 +1,285 @@ +package authentication + +import ( + "testing" + + "github.com/Azure/go-autorest/autorest/adal" + "github.com/Azure/go-autorest/autorest/azure/cli" +) + +func TestAzurePopulateSubscriptionFromCLIProfile_Missing(t *testing.T) { + config := Config{} + profiles := AzureCLIProfile{ + Profile: cli.Profile{ + Subscriptions: []cli.Subscription{}, + }, + } + + err := config.populateSubscriptionFromCLIProfile(profiles) + if err == nil { + t.Fatalf("Expected an error to be returned - but didn't get one") + } +} + +func TestAzurePopulateSubscriptionFromCLIProfile_NoDefault(t *testing.T) { + config := Config{} + profiles := AzureCLIProfile{ + Profile: cli.Profile{ + Subscriptions: []cli.Subscription{ + { + IsDefault: false, + ID: "abc123", + }, + }, + }, + } + + err := config.populateSubscriptionFromCLIProfile(profiles) + if err == nil { + t.Fatalf("Expected an error to be returned - but didn't get one") + } +} + +func TestAzurePopulateSubscriptionFromCLIProfile_Default(t *testing.T) { + subscriptionId := "abc123" + config := Config{} + profiles := AzureCLIProfile{ + Profile: cli.Profile{ + Subscriptions: []cli.Subscription{ + { + IsDefault: true, + ID: subscriptionId, + }, + }, + }, + } + + err := config.populateSubscriptionFromCLIProfile(profiles) + if err != nil { + t.Fatalf("Expected no error to be returned - but got: %+v", err) + } + + if config.SubscriptionID != subscriptionId { + t.Fatalf("Expected the Subscription ID to be %q but got %q", subscriptionId, config.SubscriptionID) + } +} + +func TestAzurePopulateTenantAndEnvironmentFromCLIProfile_Empty(t *testing.T) { + config := Config{} + profiles := AzureCLIProfile{ + Profile: cli.Profile{ + Subscriptions: []cli.Subscription{}, + }, + } + + err := config.populateTenantAndEnvironmentFromCLIProfile(profiles) + if err == nil { + t.Fatalf("Expected an error to be returned - but didn't get one") + } +} + +func TestAzurePopulateTenantAndEnvironmentFromCLIProfile_MissingSubscription(t *testing.T) { + config := Config{ + SubscriptionID: "bcd234", + } + profiles := AzureCLIProfile{ + Profile: cli.Profile{ + Subscriptions: []cli.Subscription{ + { + IsDefault: false, + ID: "abc123", + }, + }, + }, + } + + err := config.populateTenantAndEnvironmentFromCLIProfile(profiles) + if err == nil { + t.Fatalf("Expected an error to be returned - but didn't get one") + } +} + +func TestAzurePopulateTenantAndEnvironmentFromCLIProfile_PopulateEnvironment(t *testing.T) { + config := Config{ + SubscriptionID: "abc123", + TenantID: "bcd234", + } + profiles := AzureCLIProfile{ + Profile: cli.Profile{ + Subscriptions: []cli.Subscription{ + { + IsDefault: false, + ID: "abc123", + EnvironmentName: "public", + }, + }, + }, + } + + err := config.populateTenantAndEnvironmentFromCLIProfile(profiles) + if err != nil { + t.Fatalf("Expected no error to be returned - but got: %+v", err) + } + + if config.SubscriptionID != "abc123" { + t.Fatalf("Expected Subscription ID to be 'abc123' - got %q", config.SubscriptionID) + } + + if config.TenantID != "bcd234" { + t.Fatalf("Expected Tenant ID to be 'bcd234' - got %q", config.TenantID) + } + + if config.Environment != "public" { + t.Fatalf("Expected Tenant ID to be 'public' - got %q", config.Environment) + } +} + +func TestAzurePopulateTenantAndEnvironmentFromCLIProfile_NormaliseAndPopulateEnvironment(t *testing.T) { + config := Config{ + SubscriptionID: "abc123", + TenantID: "bcd234", + } + profiles := AzureCLIProfile{ + Profile: cli.Profile{ + Subscriptions: []cli.Subscription{ + { + IsDefault: false, + ID: "abc123", + }, + }, + }, + } + + err := config.populateTenantAndEnvironmentFromCLIProfile(profiles) + if err != nil { + t.Fatalf("Expected no error to be returned - but got: %+v", err) + } + + if config.SubscriptionID != "abc123" { + t.Fatalf("Expected Subscription ID to be 'abc123' - got %q", config.SubscriptionID) + } + + if config.TenantID != "bcd234" { + t.Fatalf("Expected Tenant ID to be 'bcd234' - got %q", config.TenantID) + } + + if config.Environment != "public" { + t.Fatalf("Expected Tenant ID to be 'public' - got %q", config.Environment) + } +} + +func TestAzurePopulateTenantAndEnvironmentFromCLIProfile_PopulateTenantId(t *testing.T) { + config := Config{ + SubscriptionID: "abc123", + Environment: "public", + } + profiles := AzureCLIProfile{ + Profile: cli.Profile{ + Subscriptions: []cli.Subscription{ + { + IsDefault: false, + ID: "abc123", + TenantID: "bcd234", + }, + }, + }, + } + + err := config.populateTenantAndEnvironmentFromCLIProfile(profiles) + if err != nil { + t.Fatalf("Expected no error to be returned - but got: %+v", err) + } + + if config.SubscriptionID != "abc123" { + t.Fatalf("Expected Subscription ID to be 'abc123' - got %q", config.SubscriptionID) + } + + if config.TenantID != "bcd234" { + t.Fatalf("Expected Tenant ID to be 'bcd234' - got %q", config.TenantID) + } + + if config.Environment != "public" { + t.Fatalf("Expected Tenant ID to be 'public' - got %q", config.Environment) + } +} + +func TestAzurePopulateTenantAndEnvironmentFromCLIProfile_Complete(t *testing.T) { + config := Config{ + SubscriptionID: "abc123", + TenantID: "bcd234", + Environment: "public", + } + profiles := AzureCLIProfile{ + Profile: cli.Profile{ + Subscriptions: []cli.Subscription{ + { + IsDefault: false, + ID: "abc123", + }, + }, + }, + } + + err := config.populateTenantAndEnvironmentFromCLIProfile(profiles) + if err != nil { + t.Fatalf("Expected no error to be returned - but got: %+v", err) + } + + if config.SubscriptionID != "abc123" { + t.Fatalf("Expected Subscription ID to be 'abc123' - got %q", config.SubscriptionID) + } + + if config.TenantID != "bcd234" { + t.Fatalf("Expected Tenant ID to be 'bcd234' - got %q", config.TenantID) + } + + if config.Environment != "public" { + t.Fatalf("Expected Tenant ID to be 'public' - got %q", config.Environment) + } +} + +func TestAzurePopulateFromAccessToken_Missing(t *testing.T) { + config := Config{} + + successful, err := config.populateFromAccessToken(nil) + if err == nil { + t.Fatalf("Expected an error but didn't get one") + } + + if successful { + t.Fatalf("Expected the population of a null token to be false, got true") + } +} + +func TestAzurePopulateFromAccessToken_Exists(t *testing.T) { + config := Config{} + + token := AccessToken{ + AccessToken: &adal.Token{ + AccessToken: "abc123", + }, + ClientID: "bcd234", + IsCloudShell: true, + } + + successful, err := config.populateFromAccessToken(&token) + if err != nil { + t.Fatalf("Expected no error but got: %+v", err) + } + + if !successful { + t.Fatalf("Expected the population of an existing token to be successful, it wasn't") + } + + if config.IsCloudShell != token.IsCloudShell { + t.Fatalf("Expected `IsCloudShell` to be %b, got %b", token.IsCloudShell, config.IsCloudShell) + } + + if config.ClientID != token.ClientID { + t.Fatalf("Expected `ClientID` to be %q, got %q", token.ClientID, config.ClientID) + } + + if config.AccessToken != token.AccessToken { + t.Fatalf("Expected `AccessToken` to be %+v, got %+v", token.AccessToken, config.AccessToken) + } +} diff --git a/azurerm/helpers/authentication/environment.go b/azurerm/helpers/authentication/environment.go new file mode 100644 index 000000000000..b18da1f22568 --- /dev/null +++ b/azurerm/helpers/authentication/environment.go @@ -0,0 +1,16 @@ +package authentication + +import "strings" + +func normalizeEnvironmentName(input string) string { + // Environment is stored as `Azure{Environment}Cloud` + output := strings.ToLower(input) + output = strings.TrimPrefix(output, "azure") + output = strings.TrimSuffix(output, "cloud") + + // however Azure Public is `AzureCloud` in the CLI Profile and not `AzurePublicCloud`. + if output == "" { + return "public" + } + return output +} diff --git a/azurerm/helpers/authentication/environment_test.go b/azurerm/helpers/authentication/environment_test.go new file mode 100644 index 000000000000..efe57b7110ca --- /dev/null +++ b/azurerm/helpers/authentication/environment_test.go @@ -0,0 +1,23 @@ +package authentication + +import ( + "testing" +) + +func TestAzureEnvironmentNames(t *testing.T) { + testData := map[string]string{ + "": "public", + "AzureChinaCloud": "china", + "AzureCloud": "public", + "AzureGermanCloud": "german", + "AZUREUSGOVERNMENTCLOUD": "usgovernment", + "AzurePublicCloud": "public", + } + + for input, expected := range testData { + actual := normalizeEnvironmentName(input) + if actual != expected { + t.Fatalf("Expected %q for input %q: got %q!", expected, input, actual) + } + } +} diff --git a/azurerm/helpers/authentication/validation.go b/azurerm/helpers/authentication/validation.go new file mode 100644 index 000000000000..8c777145a2cd --- /dev/null +++ b/azurerm/helpers/authentication/validation.go @@ -0,0 +1,51 @@ +package authentication + +import ( + "fmt" + + "github.com/hashicorp/go-multierror" +) + +func (c *Config) ValidateBearerAuth() error { + var err *multierror.Error + + if c.AccessToken == nil { + err = multierror.Append(err, fmt.Errorf("Access Token was not found in your Azure CLI Credentials.\n\nPlease login to the Azure CLI again via `az login`")) + } + + if c.ClientID == "" { + err = multierror.Append(err, fmt.Errorf("Client ID was not found in your Azure CLI Credentials.\n\nPlease login to the Azure CLI again via `az login`")) + } + + if c.SubscriptionID == "" { + err = multierror.Append(err, fmt.Errorf("Subscription ID was not found in your Azure CLI Credentials.\n\nPlease login to the Azure CLI again via `az login`")) + } + + if c.TenantID == "" { + err = multierror.Append(err, fmt.Errorf("Tenant ID was not found in your Azure CLI Credentials.\n\nPlease login to the Azure CLI again via `az login`")) + } + + return err.ErrorOrNil() +} + +func (c *Config) ValidateServicePrincipal() error { + var err *multierror.Error + + if c.SubscriptionID == "" { + err = multierror.Append(err, fmt.Errorf("Subscription ID must be configured for the AzureRM provider")) + } + if c.ClientID == "" { + err = multierror.Append(err, fmt.Errorf("Client ID must be configured for the AzureRM provider")) + } + if c.ClientSecret == "" { + err = multierror.Append(err, fmt.Errorf("Client Secret must be configured for the AzureRM provider")) + } + if c.TenantID == "" { + err = multierror.Append(err, fmt.Errorf("Tenant ID must be configured for the AzureRM provider")) + } + if c.Environment == "" { + err = multierror.Append(err, fmt.Errorf("Environment must be configured for the AzureRM provider")) + } + + return err.ErrorOrNil() +} diff --git a/azurerm/helpers/authentication/validation_test.go b/azurerm/helpers/authentication/validation_test.go new file mode 100644 index 000000000000..99cab000e609 --- /dev/null +++ b/azurerm/helpers/authentication/validation_test.go @@ -0,0 +1,166 @@ +package authentication + +import ( + "testing" + + "github.com/Azure/go-autorest/autorest/adal" +) + +func TestAzureValidateBearerAuth(t *testing.T) { + cases := []struct { + Description string + Config Config + ExpectError bool + }{ + { + Description: "Empty Configuration", + Config: Config{}, + ExpectError: true, + }, + { + Description: "Missing Access Token", + Config: Config{ + ClientID: "62e73395-5017-43b6-8ebf-d6c30a514cf1", + SubscriptionID: "8e8b5e02-5c13-4822-b7dc-4232afb7e8c2", + TenantID: "9834f8d0-24b3-41b7-8b8d-c611c461a129", + }, + ExpectError: true, + }, + { + Description: "Missing Client ID", + Config: Config{ + AccessToken: &adal.Token{}, + SubscriptionID: "8e8b5e02-5c13-4822-b7dc-4232afb7e8c2", + TenantID: "9834f8d0-24b3-41b7-8b8d-c611c461a129", + }, + ExpectError: true, + }, + { + Description: "Missing Subscription ID", + Config: Config{ + AccessToken: &adal.Token{}, + ClientID: "62e73395-5017-43b6-8ebf-d6c30a514cf1", + TenantID: "9834f8d0-24b3-41b7-8b8d-c611c461a129", + }, + ExpectError: true, + }, + { + Description: "Missing Tenant ID", + Config: Config{ + AccessToken: &adal.Token{}, + ClientID: "62e73395-5017-43b6-8ebf-d6c30a514cf1", + SubscriptionID: "8e8b5e02-5c13-4822-b7dc-4232afb7e8c2", + }, + ExpectError: true, + }, + { + Description: "Valid Configuration", + Config: Config{ + AccessToken: &adal.Token{}, + ClientID: "62e73395-5017-43b6-8ebf-d6c30a514cf1", + SubscriptionID: "8e8b5e02-5c13-4822-b7dc-4232afb7e8c2", + TenantID: "9834f8d0-24b3-41b7-8b8d-c611c461a129", + }, + ExpectError: false, + }, + } + + for _, v := range cases { + err := v.Config.ValidateBearerAuth() + + if v.ExpectError && err == nil { + t.Fatalf("Expected an error for %q: didn't get one", v.Description) + } + + if !v.ExpectError && err != nil { + t.Fatalf("Expected there to be no error for %q - but got: %v", v.Description, err) + } + } +} + +func TestAzureValidateServicePrincipal(t *testing.T) { + cases := []struct { + Description string + Config Config + ExpectError bool + }{ + { + Description: "Empty Configuration", + Config: Config{}, + ExpectError: true, + }, + { + Description: "Missing Client ID", + Config: Config{ + SubscriptionID: "8e8b5e02-5c13-4822-b7dc-4232afb7e8c2", + ClientSecret: "Does Hammer Time have Daylight Savings Time?", + TenantID: "9834f8d0-24b3-41b7-8b8d-c611c461a129", + Environment: "public", + }, + ExpectError: true, + }, + { + Description: "Missing Subscription ID", + Config: Config{ + ClientID: "62e73395-5017-43b6-8ebf-d6c30a514cf1", + ClientSecret: "Does Hammer Time have Daylight Savings Time?", + TenantID: "9834f8d0-24b3-41b7-8b8d-c611c461a129", + Environment: "public", + }, + ExpectError: true, + }, + { + Description: "Missing Client Secret", + Config: Config{ + ClientID: "62e73395-5017-43b6-8ebf-d6c30a514cf1", + SubscriptionID: "8e8b5e02-5c13-4822-b7dc-4232afb7e8c2", + TenantID: "9834f8d0-24b3-41b7-8b8d-c611c461a129", + Environment: "public", + }, + ExpectError: true, + }, + { + Description: "Missing Tenant ID", + Config: Config{ + ClientID: "62e73395-5017-43b6-8ebf-d6c30a514cf1", + SubscriptionID: "8e8b5e02-5c13-4822-b7dc-4232afb7e8c2", + ClientSecret: "Does Hammer Time have Daylight Savings Time?", + Environment: "public", + }, + ExpectError: true, + }, + { + Description: "Missing Environment", + Config: Config{ + ClientID: "62e73395-5017-43b6-8ebf-d6c30a514cf1", + SubscriptionID: "8e8b5e02-5c13-4822-b7dc-4232afb7e8c2", + ClientSecret: "Does Hammer Time have Daylight Savings Time?", + TenantID: "9834f8d0-24b3-41b7-8b8d-c611c461a129", + }, + ExpectError: true, + }, + { + Description: "Valid Configuration", + Config: Config{ + ClientID: "62e73395-5017-43b6-8ebf-d6c30a514cf1", + SubscriptionID: "8e8b5e02-5c13-4822-b7dc-4232afb7e8c2", + ClientSecret: "Does Hammer Time have Daylight Savings Time?", + TenantID: "9834f8d0-24b3-41b7-8b8d-c611c461a129", + Environment: "public", + }, + ExpectError: false, + }, + } + + for _, v := range cases { + err := v.Config.ValidateServicePrincipal() + + if v.ExpectError && err == nil { + t.Fatalf("Expected an error for %q: didn't get one", v.Description) + } + + if !v.ExpectError && err != nil { + t.Fatalf("Expected there to be no error for %q - but got: %v", v.Description, err) + } + } +} diff --git a/azurerm/provider.go b/azurerm/provider.go index f1a76e995529..5f600e5ff4bd 100644 --- a/azurerm/provider.go +++ b/azurerm/provider.go @@ -8,15 +8,12 @@ import ( "log" "strings" "sync" - "time" "github.com/Azure/azure-sdk-for-go/arm/resources/resources" - "github.com/Azure/go-autorest/autorest/adal" - "github.com/Azure/go-autorest/autorest/azure/cli" - "github.com/hashicorp/go-multierror" "github.com/hashicorp/terraform/helper/mutexkv" "github.com/hashicorp/terraform/helper/schema" "github.com/hashicorp/terraform/terraform" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/authentication" ) // Provider returns a terraform.ResourceProvider. @@ -181,168 +178,9 @@ func Provider() terraform.ResourceProvider { return p } -// Config is the configuration structure used to instantiate a -// new Azure management client. -type Config struct { - ManagementURL string - - // Core - ClientID string - SubscriptionID string - TenantID string - Environment string - SkipCredentialsValidation bool - SkipProviderRegistration bool - - // Service Principal Auth - ClientSecret string - - // Bearer Auth - AccessToken *adal.Token - IsCloudShell bool -} - -func (c *Config) validateServicePrincipal() error { - var err *multierror.Error - - if c.SubscriptionID == "" { - err = multierror.Append(err, fmt.Errorf("Subscription ID must be configured for the AzureRM provider")) - } - if c.ClientID == "" { - err = multierror.Append(err, fmt.Errorf("Client ID must be configured for the AzureRM provider")) - } - if c.ClientSecret == "" { - err = multierror.Append(err, fmt.Errorf("Client Secret must be configured for the AzureRM provider")) - } - if c.TenantID == "" { - err = multierror.Append(err, fmt.Errorf("Tenant ID must be configured for the AzureRM provider")) - } - if c.Environment == "" { - err = multierror.Append(err, fmt.Errorf("Environment must be configured for the AzureRM provider")) - } - - return err.ErrorOrNil() -} - -func (c *Config) validateBearerAuth() error { - var err *multierror.Error - - if c.AccessToken == nil { - err = multierror.Append(err, fmt.Errorf("Access Token was not found in your Azure CLI Credentials.\n\nPlease login to the Azure CLI again via `az login`")) - } - - if c.ClientID == "" { - err = multierror.Append(err, fmt.Errorf("Client ID was not found in your Azure CLI Credentials.\n\nPlease login to the Azure CLI again via `az login`")) - } - - if c.SubscriptionID == "" { - err = multierror.Append(err, fmt.Errorf("Subscription ID was not found in your Azure CLI Credentials.\n\nPlease login to the Azure CLI again via `az login`")) - } - - if c.TenantID == "" { - err = multierror.Append(err, fmt.Errorf("Tenant ID was not found in your Azure CLI Credentials.\n\nPlease login to the Azure CLI again via `az login`")) - } - - return err.ErrorOrNil() -} - -func (c *Config) LoadTokensFromAzureCLI() error { - profilePath, err := cli.ProfilePath() - if err != nil { - return fmt.Errorf("Error loading the Profile Path from the Azure CLI: %+v", err) - } - - profile, err := cli.LoadProfile(profilePath) - if err != nil { - return fmt.Errorf("Azure CLI Authorization Profile was not found. Please ensure the Azure CLI is installed and then log-in with `az login`.") - } - - // pull out the Subscription ID / Tenant ID / Environment from the Azure Profile, if not set - for _, subscription := range profile.Subscriptions { - if subscription.IsDefault { - if c.SubscriptionID == "" { - c.SubscriptionID = subscription.ID - } - if c.TenantID == "" { - c.TenantID = subscription.TenantID - } - if c.Environment == "" { - c.Environment = normalizeEnvironmentName(subscription.EnvironmentName) - } - break - } - } - - foundToken := false - if c.TenantID != "" { - // pull out the ClientID and the AccessToken from the Azure Access Token - tokensPath, err := cli.AccessTokensPath() - if err != nil { - return fmt.Errorf("Error loading the Tokens Path from the Azure CLI: %+v", err) - } - - tokens, err := cli.LoadTokens(tokensPath) - if err != nil { - return fmt.Errorf("Azure CLI Authorization Tokens were not found. Please ensure the Azure CLI is installed and then log-in with `az login`.") - } - - for _, accessToken := range tokens { - token, err := accessToken.ToADALToken() - if err != nil { - return fmt.Errorf("[DEBUG] Error converting access token to token: %+v", err) - } - - expirationDate, err := cli.ParseExpirationDate(accessToken.ExpiresOn) - if err != nil { - return fmt.Errorf("Error parsing expiration date: %q", accessToken.ExpiresOn) - } - - if expirationDate.UTC().Before(time.Now().UTC()) { - log.Printf("[DEBUG] Token '%s' has expired", token.AccessToken) - continue - } - - if !strings.Contains(accessToken.Resource, "management") { - log.Printf("[DEBUG] Resource '%s' isn't a management domain", accessToken.Resource) - continue - } - - if !strings.HasSuffix(accessToken.Authority, c.TenantID) { - log.Printf("[DEBUG] Resource '%s' isn't for the correct Tenant", accessToken.Resource) - continue - } - - c.ClientID = accessToken.ClientID - c.AccessToken = &token - c.IsCloudShell = accessToken.RefreshToken == "" - foundToken = true - break - } - } - - if !foundToken { - return fmt.Errorf("No valid (unexpired) Azure CLI Auth Tokens found. Please run `az login`.") - } - - return nil -} - -func normalizeEnvironmentName(input string) string { - // Environment is stored as `Azure{Environment}Cloud` - output := strings.ToLower(input) - output = strings.TrimPrefix(output, "azure") - output = strings.TrimSuffix(output, "cloud") - - // however Azure Public is `AzureCloud` in the CLI Profile and not `AzurePublicCloud`. - if output == "" { - return "public" - } - return output -} - func providerConfigure(p *schema.Provider) schema.ConfigureFunc { return func(d *schema.ResourceData) (interface{}, error) { - config := &Config{ + config := &authentication.Config{ SubscriptionID: d.Get("subscription_id").(string), ClientID: d.Get("client_id").(string), ClientSecret: d.Get("client_secret").(string), @@ -354,7 +192,7 @@ func providerConfigure(p *schema.Provider) schema.ConfigureFunc { if config.ClientSecret != "" { log.Printf("[DEBUG] Client Secret specified - using Service Principal for Authentication") - if err := config.validateServicePrincipal(); err != nil { + if err := config.ValidateServicePrincipal(); err != nil { return nil, err } } else { @@ -363,12 +201,12 @@ func providerConfigure(p *schema.Provider) schema.ConfigureFunc { return nil, err } - if err := config.validateBearerAuth(); err != nil { + if err := config.ValidateBearerAuth(); err != nil { return nil, fmt.Errorf("Please specify either a Service Principal, or log in with the Azure CLI (using `az login`)") } } - client, err := config.getArmClient() + client, err := getArmClient(config) if err != nil { return nil, err } diff --git a/azurerm/provider_test.go b/azurerm/provider_test.go index 676bcb9f0973..f0a1b235ba7f 100644 --- a/azurerm/provider_test.go +++ b/azurerm/provider_test.go @@ -10,6 +10,7 @@ import ( "github.com/hashicorp/terraform/helper/resource" "github.com/hashicorp/terraform/helper/schema" "github.com/hashicorp/terraform/terraform" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/authentication" ) var testAccProviders map[string]terraform.ResourceProvider @@ -84,7 +85,7 @@ func testArmEnvironment() (*azure.Environment, error) { return &env, nil } -func testGetAzureConfig(t *testing.T) *Config { +func testGetAzureConfig(t *testing.T) *authentication.Config { if os.Getenv(resource.TestEnvVar) == "" { t.Skip(fmt.Sprintf("Integration test skipped unless env '%s' set", resource.TestEnvVar)) return nil @@ -93,7 +94,7 @@ func testGetAzureConfig(t *testing.T) *Config { environment := testArmEnvironmentName() // we deliberately don't use the main config - since we care about - config := Config{ + config := authentication.Config{ SubscriptionID: os.Getenv("ARM_SUBSCRIPTION_ID"), ClientID: os.Getenv("ARM_CLIENT_ID"), TenantID: os.Getenv("ARM_TENANT_ID"), @@ -110,7 +111,7 @@ func TestAccAzureRMResourceProviderRegistration(t *testing.T) { return } - armClient, err := config.getArmClient() + armClient, err := getArmClient(config) if err != nil { t.Fatalf("Error building ARM Client: %+v", err) } From f5a01b15ba8bcdff2cb3f8fa4760353a0bf94c55 Mon Sep 17 00:00:00 2001 From: tombuildsstuff Date: Thu, 30 Nov 2017 15:39:49 +0000 Subject: [PATCH 34/55] Fixing the build --- azurerm/azurerm_sweeper_test.go | 5 +++-- azurerm/helpers/authentication/config_test.go | 2 +- azurerm/resource_arm_container_registry_migrate_test.go | 2 +- 3 files changed, 5 insertions(+), 4 deletions(-) diff --git a/azurerm/azurerm_sweeper_test.go b/azurerm/azurerm_sweeper_test.go index 849a6912c885..ad2212eab3db 100644 --- a/azurerm/azurerm_sweeper_test.go +++ b/azurerm/azurerm_sweeper_test.go @@ -8,6 +8,7 @@ import ( "testing" "github.com/hashicorp/terraform/helper/resource" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/authentication" ) func TestMain(m *testing.M) { @@ -29,7 +30,7 @@ func buildConfigForSweepers() (*ArmClient, error) { return nil, fmt.Errorf("ARM_SUBSCRIPTION_ID, ARM_CLIENT_ID, ARM_CLIENT_SECRET and ARM_TENANT_ID must be set for acceptance tests") } - config := &Config{ + config := &authentication.Config{ SubscriptionID: subscriptionID, ClientID: clientID, ClientSecret: clientSecret, @@ -38,7 +39,7 @@ func buildConfigForSweepers() (*ArmClient, error) { SkipProviderRegistration: false, } - return config.getArmClient() + return getArmClient(config) } func shouldSweepAcceptanceTestResource(name string, resourceLocation string, region string) bool { diff --git a/azurerm/helpers/authentication/config_test.go b/azurerm/helpers/authentication/config_test.go index 8ccbb0082010..5e22fbf8a814 100644 --- a/azurerm/helpers/authentication/config_test.go +++ b/azurerm/helpers/authentication/config_test.go @@ -272,7 +272,7 @@ func TestAzurePopulateFromAccessToken_Exists(t *testing.T) { } if config.IsCloudShell != token.IsCloudShell { - t.Fatalf("Expected `IsCloudShell` to be %b, got %b", token.IsCloudShell, config.IsCloudShell) + t.Fatalf("Expected `IsCloudShell` to be %t, got %t", token.IsCloudShell, config.IsCloudShell) } if config.ClientID != token.ClientID { diff --git a/azurerm/resource_arm_container_registry_migrate_test.go b/azurerm/resource_arm_container_registry_migrate_test.go index 94d58be2dbf7..f7828e7e4bf6 100644 --- a/azurerm/resource_arm_container_registry_migrate_test.go +++ b/azurerm/resource_arm_container_registry_migrate_test.go @@ -17,7 +17,7 @@ func TestAccAzureRMContainerRegistryMigrateState(t *testing.T) { t.SkipNow() return } - client, err := config.getArmClient() + client, err := getArmClient(config) if err != nil { t.Fatal(fmt.Errorf("Error building ARM Client: %+v", err)) return From eb2545933b5347ab50745ebfdbf3b1e87fd3b732 Mon Sep 17 00:00:00 2001 From: Junyi Yi Date: Thu, 30 Nov 2017 16:05:52 -0800 Subject: [PATCH 35/55] Remove the field marked as "Removed" according to #572. --- azurerm/resource_arm_virtual_machine.go | 31 ------------------------- 1 file changed, 31 deletions(-) diff --git a/azurerm/resource_arm_virtual_machine.go b/azurerm/resource_arm_virtual_machine.go index ac5db5454dcd..87765cdd9815 100644 --- a/azurerm/resource_arm_virtual_machine.go +++ b/azurerm/resource_arm_virtual_machine.go @@ -280,37 +280,6 @@ func resourceArmVirtualMachine() *schema.Resource { Default: false, }, - // TODO: remove this in the next major version - "diagnostics_profile": { - Type: schema.TypeSet, - Optional: true, - MaxItems: 1, - ConflictsWith: []string{"boot_diagnostics"}, - Removed: "Use field boot_diagnostics instead", - Elem: &schema.Resource{ - Schema: map[string]*schema.Schema{ - "boot_diagnostics": { - Type: schema.TypeSet, - Required: true, - MaxItems: 1, - Elem: &schema.Resource{ - Schema: map[string]*schema.Schema{ - "enabled": { - Type: schema.TypeBool, - Required: true, - }, - - "storage_uri": { - Type: schema.TypeString, - Required: true, - }, - }, - }, - }, - }, - }, - }, - "boot_diagnostics": { Type: schema.TypeList, Optional: true, From bd6654cdfe0aab0f4b1c7b52be4753ba0dfde0a5 Mon Sep 17 00:00:00 2001 From: tombuildsstuff Date: Fri, 1 Dec 2017 12:11:24 +0000 Subject: [PATCH 36/55] Upgrading to v11.2.2-beta of the Azure SDK for Go --- .../arm/appinsights/components.go | 24 +- .../arm/appinsights/operations.go | 4 +- .../arm/appinsights/version.go | 4 +- .../arm/appinsights/webtests.go | 24 +- .../authorization/classicadministrators.go | 4 +- .../arm/authorization/permissions.go | 8 +- .../provideroperationsmetadata.go | 8 +- .../arm/authorization/roleassignments.go | 40 +- .../arm/authorization/roledefinitions.go | 20 +- .../arm/authorization/version.go | 4 +- .../arm/automation/account.go | 24 +- .../arm/automation/activity.go | 8 +- .../agentregistrationinformation.go | 8 +- .../arm/automation/certificate.go | 20 +- .../arm/automation/connection.go | 20 +- .../arm/automation/connectiontype.go | 16 +- .../arm/automation/credential.go | 20 +- .../arm/automation/dsccompilationjob.go | 16 +- .../arm/automation/dscconfiguration.go | 20 +- .../arm/automation/dscnode.go | 16 +- .../arm/automation/dscnodeconfiguration.go | 16 +- .../azure-sdk-for-go/arm/automation/fields.go | 4 +- .../automation/hybridrunbookworkergroup.go | 16 +- .../azure-sdk-for-go/arm/automation/job.go | 32 +- .../arm/automation/jobschedule.go | 16 +- .../arm/automation/jobstream.go | 8 +- .../azure-sdk-for-go/arm/automation/module.go | 20 +- .../arm/automation/nodereports.go | 12 +- .../arm/automation/objectdatatypes.go | 8 +- .../arm/automation/operations.go | 4 +- .../arm/automation/runbook.go | 24 +- .../arm/automation/runbookdraft.go | 14 +- .../arm/automation/schedule.go | 20 +- .../arm/automation/statistics.go | 4 +- .../arm/automation/testjobs.go | 20 +- .../arm/automation/testjobstreams.go | 8 +- .../azure-sdk-for-go/arm/automation/usages.go | 4 +- .../arm/automation/variable.go | 20 +- .../arm/automation/version.go | 4 +- .../arm/automation/webhook.go | 24 +- .../Azure/azure-sdk-for-go/arm/cdn/client.go | 8 +- .../azure-sdk-for-go/arm/cdn/customdomains.go | 18 +- .../azure-sdk-for-go/arm/cdn/edgenodes.go | 4 +- .../azure-sdk-for-go/arm/cdn/endpoints.go | 23 +- .../azure-sdk-for-go/arm/cdn/operations.go | 4 +- .../Azure/azure-sdk-for-go/arm/cdn/origins.go | 9 +- .../azure-sdk-for-go/arm/cdn/profiles.go | 27 +- .../azure-sdk-for-go/arm/cdn/resourceusage.go | 4 +- .../Azure/azure-sdk-for-go/arm/cdn/version.go | 4 +- .../arm/compute/availabilitysets.go | 20 +- .../arm/compute/containerservices.go | 14 +- .../azure-sdk-for-go/arm/compute/disks.go | 17 +- .../azure-sdk-for-go/arm/compute/images.go | 14 +- .../arm/compute/resourceskus.go | 4 +- .../azure-sdk-for-go/arm/compute/snapshots.go | 17 +- .../azure-sdk-for-go/arm/compute/usage.go | 4 +- .../azure-sdk-for-go/arm/compute/version.go | 4 +- .../compute/virtualmachineextensionimages.go | 12 +- .../arm/compute/virtualmachineextensions.go | 6 +- .../arm/compute/virtualmachineimages.go | 20 +- .../arm/compute/virtualmachineruncommands.go | 8 +- .../arm/compute/virtualmachines.go | 35 +- .../virtualmachinescalesetextensions.go | 10 +- .../virtualmachinescalesetrollingupgrades.go | 6 +- .../arm/compute/virtualmachinescalesets.go | 31 +- .../arm/compute/virtualmachinescalesetvms.go | 19 +- .../arm/compute/virtualmachinesizes.go | 4 +- .../arm/containerinstance/containergroups.go | 20 +- .../arm/containerinstance/containerlogs.go | 4 +- .../arm/containerinstance/models.go | 24 +- .../arm/containerinstance/version.go | 4 +- .../arm/containerregistry/operations.go | 4 +- .../arm/containerregistry/registries.go | 31 +- .../arm/containerregistry/replications.go | 11 +- .../arm/containerregistry/version.go | 4 +- .../arm/containerregistry/webhooks.go | 23 +- .../arm/containerservice/containerservices.go | 14 +- .../arm/containerservice/version.go | 4 +- .../arm/cosmos-db/databaseaccounts.go | 33 +- .../arm/cosmos-db/operations.go | 4 +- .../azure-sdk-for-go/arm/cosmos-db/version.go | 4 +- .../azure-sdk-for-go/arm/dns/recordsets.go | 24 +- .../Azure/azure-sdk-for-go/arm/dns/version.go | 4 +- .../Azure/azure-sdk-for-go/arm/dns/zones.go | 17 +- .../arm/eventgrid/eventsubscriptions.go | 47 +- .../arm/eventgrid/operations.go | 4 +- .../azure-sdk-for-go/arm/eventgrid/topics.go | 26 +- .../arm/eventgrid/topictypes.go | 12 +- .../azure-sdk-for-go/arm/eventgrid/version.go | 4 +- .../arm/eventhub/consumergroups.go | 16 +- .../arm/eventhub/eventhubs.go | 40 +- .../azure-sdk-for-go/arm/eventhub/models.go | 46 +- .../arm/eventhub/namespaces.go | 46 +- .../arm/eventhub/operations.go | 4 +- .../azure-sdk-for-go/arm/eventhub/version.go | 4 +- .../arm/graphrbac/applications.go | 40 +- .../azure-sdk-for-go/arm/graphrbac/domains.go | 8 +- .../azure-sdk-for-go/arm/graphrbac/groups.go | 44 +- .../azure-sdk-for-go/arm/graphrbac/objects.go | 12 +- .../arm/graphrbac/serviceprincipals.go | 36 +- .../azure-sdk-for-go/arm/graphrbac/users.go | 28 +- .../azure-sdk-for-go/arm/graphrbac/version.go | 4 +- .../azure-sdk-for-go/arm/keyvault/vaults.go | 29 +- .../azure-sdk-for-go/arm/keyvault/version.go | 4 +- .../arm/mysql/configurations.go | 9 +- .../azure-sdk-for-go/arm/mysql/databases.go | 10 +- .../arm/mysql/firewallrules.go | 10 +- .../azure-sdk-for-go/arm/mysql/logfiles.go | 4 +- .../azure-sdk-for-go/arm/mysql/operations.go | 4 +- .../azure-sdk-for-go/arm/mysql/servers.go | 15 +- .../azure-sdk-for-go/arm/mysql/version.go | 4 +- .../arm/network/applicationgateways.go | 33 +- .../arm/network/applicationsecuritygroups.go | 14 +- .../arm/network/availableendpointservices.go | 4 +- .../arm/network/bgpservicecommunities.go | 4 +- .../azure-sdk-for-go/arm/network/client.go | 4 +- .../arm/network/defaultsecurityrules.go | 8 +- .../expressroutecircuitauthorizations.go | 10 +- .../network/expressroutecircuitpeerings.go | 10 +- .../arm/network/expressroutecircuits.go | 25 +- .../network/expressrouteserviceproviders.go | 4 +- .../arm/network/inboundnatrules.go | 10 +- .../arm/network/interfaceipconfigurations.go | 8 +- .../arm/network/interfaceloadbalancers.go | 4 +- .../arm/network/interfaces.go | 28 +- .../loadbalancerbackendaddresspools.go | 8 +- .../loadbalancerfrontendipconfigurations.go | 8 +- .../network/loadbalancerloadbalancingrules.go | 8 +- .../network/loadbalancernetworkinterfaces.go | 4 +- .../arm/network/loadbalancerprobes.go | 8 +- .../arm/network/loadbalancers.go | 14 +- .../arm/network/localnetworkgateways.go | 10 +- .../arm/network/packetcaptures.go | 12 +- .../arm/network/publicipaddresses.go | 26 +- .../arm/network/routefilterrules.go | 11 +- .../arm/network/routefilters.go | 15 +- .../azure-sdk-for-go/arm/network/routes.go | 10 +- .../arm/network/routetables.go | 14 +- .../arm/network/securitygroups.go | 14 +- .../arm/network/securityrules.go | 10 +- .../azure-sdk-for-go/arm/network/subnets.go | 10 +- .../azure-sdk-for-go/arm/network/usages.go | 4 +- .../azure-sdk-for-go/arm/network/version.go | 4 +- .../virtualnetworkgatewayconnections.go | 16 +- .../arm/network/virtualnetworkgateways.go | 29 +- .../arm/network/virtualnetworkpeerings.go | 10 +- .../arm/network/virtualnetworks.go | 22 +- .../azure-sdk-for-go/arm/network/watchers.go | 31 +- .../arm/operationalinsights/datasources.go | 16 +- .../arm/operationalinsights/linkedservices.go | 16 +- .../arm/operationalinsights/savedsearches.go | 20 +- .../operationalinsights/storageinsights.go | 16 +- .../arm/operationalinsights/version.go | 4 +- .../arm/operationalinsights/workspaces.go | 54 +- .../arm/postgresql/configurations.go | 9 +- .../arm/postgresql/databases.go | 10 +- .../arm/postgresql/firewallrules.go | 10 +- .../arm/postgresql/logfiles.go | 4 +- .../arm/postgresql/operations.go | 4 +- .../arm/postgresql/servers.go | 15 +- .../arm/postgresql/version.go | 4 +- .../arm/redis/firewallrule.go | 12 +- .../arm/redis/firewallrules.go | 4 +- .../Azure/azure-sdk-for-go/arm/redis/group.go | 32 +- .../azure-sdk-for-go/arm/redis/operations.go | 4 +- .../arm/redis/patchschedules.go | 12 +- .../azure-sdk-for-go/arm/redis/version.go | 4 +- .../arm/resources/locks/managementlocks.go | 60 +- .../arm/resources/locks/version.go | 4 +- .../resources/deploymentoperations.go | 8 +- .../arm/resources/resources/deployments.go | 26 +- .../arm/resources/resources/group.go | 30 +- .../arm/resources/resources/groups.go | 25 +- .../arm/resources/resources/providers.go | 16 +- .../arm/resources/resources/tags.go | 20 +- .../arm/resources/resources/version.go | 4 +- .../arm/resources/subscriptions/group.go | 12 +- .../arm/resources/subscriptions/tenants.go | 4 +- .../arm/resources/subscriptions/version.go | 4 +- .../arm/scheduler/jobcollections.go | 23 +- .../azure-sdk-for-go/arm/scheduler/jobs.go | 28 +- .../azure-sdk-for-go/arm/scheduler/version.go | 4 +- .../azure-sdk-for-go/arm/search/adminkeys.go | 8 +- .../azure-sdk-for-go/arm/search/querykeys.go | 12 +- .../azure-sdk-for-go/arm/search/services.go | 17 +- .../azure-sdk-for-go/arm/search/version.go | 4 +- .../arm/servicebus/eventhubs.go | 4 +- .../azure-sdk-for-go/arm/servicebus/models.go | 44 +- .../arm/servicebus/namespaces.go | 46 +- .../arm/servicebus/operations.go | 4 +- .../arm/servicebus/premiummessagingregions.go | 4 +- .../azure-sdk-for-go/arm/servicebus/queues.go | 40 +- .../arm/servicebus/regions.go | 4 +- .../azure-sdk-for-go/arm/servicebus/rules.go | 16 +- .../arm/servicebus/subscriptions.go | 16 +- .../azure-sdk-for-go/arm/servicebus/topics.go | 40 +- .../arm/servicebus/version.go | 4 +- .../sql/backuplongtermretentionpolicies.go | 5 +- .../arm/sql/backuplongtermretentionvaults.go | 5 +- .../azure-sdk-for-go/arm/sql/capabilities.go | 4 +- .../arm/sql/databaseblobauditingpolicies.go | 8 +- .../arm/sql/databaseoperations.go | 8 +- .../azure-sdk-for-go/arm/sql/databases.go | 43 +- .../sql/databasethreatdetectionpolicies.go | 8 +- .../arm/sql/databaseusages.go | 4 +- .../arm/sql/datamaskingpolicies.go | 8 +- .../arm/sql/datamaskingrules.go | 8 +- .../arm/sql/elasticpoolactivities.go | 4 +- .../arm/sql/elasticpooldatabaseactivities.go | 4 +- .../azure-sdk-for-go/arm/sql/elasticpools.go | 22 +- .../arm/sql/encryptionprotectors.go | 9 +- .../arm/sql/failovergroups.go | 13 +- .../azure-sdk-for-go/arm/sql/firewallrules.go | 16 +- .../arm/sql/geobackuppolicies.go | 12 +- .../azure-sdk-for-go/arm/sql/operations.go | 4 +- .../arm/sql/recommendedelasticpools.go | 12 +- .../arm/sql/recoverabledatabases.go | 8 +- .../arm/sql/replicationlinks.go | 14 +- .../arm/sql/restorabledroppeddatabases.go | 8 +- .../azure-sdk-for-go/arm/sql/restorepoints.go | 4 +- .../arm/sql/serverazureadadministrators.go | 10 +- .../arm/sql/servercommunicationlinks.go | 13 +- .../arm/sql/serverconnectionpolicies.go | 8 +- .../azure-sdk-for-go/arm/sql/serverkeys.go | 10 +- .../Azure/azure-sdk-for-go/arm/sql/servers.go | 19 +- .../azure-sdk-for-go/arm/sql/serverusages.go | 4 +- .../arm/sql/serviceobjectives.go | 8 +- .../arm/sql/servicetieradvisors.go | 8 +- .../azure-sdk-for-go/arm/sql/syncagents.go | 18 +- .../azure-sdk-for-go/arm/sql/syncgroups.go | 32 +- .../azure-sdk-for-go/arm/sql/syncmembers.go | 16 +- .../transparentdataencryptionactivities.go | 4 +- .../arm/sql/transparentdataencryptions.go | 8 +- .../Azure/azure-sdk-for-go/arm/sql/version.go | 4 +- .../arm/sql/virtualnetworkrules.go | 10 +- .../azure-sdk-for-go/arm/storage/accounts.go | 41 +- .../arm/storage/operations.go | 4 +- .../azure-sdk-for-go/arm/storage/skus.go | 4 +- .../azure-sdk-for-go/arm/storage/usage.go | 4 +- .../azure-sdk-for-go/arm/storage/version.go | 4 +- .../arm/trafficmanager/endpoints.go | 16 +- .../trafficmanager/geographichierarchies.go | 4 +- .../arm/trafficmanager/heatmap.go | 4 +- .../arm/trafficmanager/profiles.go | 28 +- .../arm/trafficmanager/usermetricskeys.go | 12 +- .../arm/trafficmanager/version.go | 4 +- .../Azure/azure-sdk-for-go/arm/web/apps.go | 1146 +++++++++++++---- .../arm/web/appservicecertificateorders.go | 66 +- .../arm/web/appserviceenvironments.go | 126 +- .../arm/web/appserviceplans.go | 101 +- .../azure-sdk-for-go/arm/web/certificates.go | 24 +- .../Azure/azure-sdk-for-go/arm/web/client.go | 48 +- .../arm/web/deletedwebapps.go | 4 +- .../Azure/azure-sdk-for-go/arm/web/domains.go | 49 +- .../Azure/azure-sdk-for-go/arm/web/models.go | 832 ++++++------ .../azure-sdk-for-go/arm/web/provider.go | 12 +- .../arm/web/recommendations.go | 28 +- .../arm/web/topleveldomains.go | 12 +- .../Azure/azure-sdk-for-go/arm/web/version.go | 4 +- .../dataplane/keyvault/client.go | 268 +++- .../dataplane/keyvault/version.go | 4 +- .../Azure/azure-sdk-for-go/storage/blob.go | 24 +- .../storage/blobserviceclient.go | 66 +- .../Azure/azure-sdk-for-go/storage/client.go | 58 +- .../azure-sdk-for-go/storage/container.go | 75 ++ .../azure-sdk-for-go/storage/pageblob.go | 6 +- .../Azure/azure-sdk-for-go/storage/util.go | 6 +- .../azure-sdk-for-go/storage/util_1.7.go | 26 - .../azure-sdk-for-go/storage/util_1.8.go | 32 - vendor/vendor.json | 318 ++--- 270 files changed, 4785 insertions(+), 1994 deletions(-) delete mode 100644 vendor/github.com/Azure/azure-sdk-for-go/storage/util_1.7.go delete mode 100644 vendor/github.com/Azure/azure-sdk-for-go/storage/util_1.8.go diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/appinsights/components.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/appinsights/components.go index 20fbda276923..7f9620f83f58 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/appinsights/components.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/appinsights/components.go @@ -98,7 +98,9 @@ func (client ComponentsClient) CreateOrUpdatePreparer(resourceGroupName string, // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client ComponentsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -164,7 +166,9 @@ func (client ComponentsClient) DeletePreparer(resourceGroupName string, resource // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client ComponentsClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -229,7 +233,9 @@ func (client ComponentsClient) GetPreparer(resourceGroupName string, resourceNam // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ComponentsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -290,7 +296,9 @@ func (client ComponentsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ComponentsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -423,7 +431,9 @@ func (client ComponentsClient) ListByResourceGroupPreparer(resourceGroupName str // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client ComponentsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -560,7 +570,9 @@ func (client ComponentsClient) UpdateTagsPreparer(resourceGroupName string, reso // UpdateTagsSender sends the UpdateTags request. The method will close the // http.Response Body if it receives an error. func (client ComponentsClient) UpdateTagsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateTagsResponder handles the response to the UpdateTags request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/appinsights/operations.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/appinsights/operations.go index 0c431b949915..3941e764fd08 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/appinsights/operations.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/appinsights/operations.go @@ -79,7 +79,9 @@ func (client OperationsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client OperationsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/appinsights/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/appinsights/version.go index c9fee01ba98f..761d5b148e94 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/appinsights/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/appinsights/version.go @@ -19,10 +19,10 @@ package appinsights // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-appinsights/2015-05-01" + return "Azure-SDK-For-Go/v11.1.1-beta arm-appinsights/2015-05-01" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/appinsights/webtests.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/appinsights/webtests.go index 77a0dafd4e07..fb06fe1b9bfa 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/appinsights/webtests.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/appinsights/webtests.go @@ -102,7 +102,9 @@ func (client WebTestsClient) CreateOrUpdatePreparer(resourceGroupName string, we // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client WebTestsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -168,7 +170,9 @@ func (client WebTestsClient) DeletePreparer(resourceGroupName string, webTestNam // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client WebTestsClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -233,7 +237,9 @@ func (client WebTestsClient) GetPreparer(resourceGroupName string, webTestName s // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client WebTestsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -294,7 +300,9 @@ func (client WebTestsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client WebTestsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -427,7 +435,9 @@ func (client WebTestsClient) ListByResourceGroupPreparer(resourceGroupName strin // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client WebTestsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -564,7 +574,9 @@ func (client WebTestsClient) UpdateTagsPreparer(resourceGroupName string, webTes // UpdateTagsSender sends the UpdateTags request. The method will close the // http.Response Body if it receives an error. func (client WebTestsClient) UpdateTagsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateTagsResponder handles the response to the UpdateTags request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/authorization/classicadministrators.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/authorization/classicadministrators.go index 34a4dd6942bb..e00d9c9bbd03 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/authorization/classicadministrators.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/authorization/classicadministrators.go @@ -86,7 +86,9 @@ func (client ClassicAdministratorsClient) ListPreparer() (*http.Request, error) // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ClassicAdministratorsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/authorization/permissions.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/authorization/permissions.go index 4080bc871ed8..4416b6ad4a29 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/authorization/permissions.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/authorization/permissions.go @@ -96,7 +96,9 @@ func (client PermissionsClient) ListForResourcePreparer(resourceGroupName string // ListForResourceSender sends the ListForResource request. The method will close the // http.Response Body if it receives an error. func (client PermissionsClient) ListForResourceSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListForResourceResponder handles the response to the ListForResource request. The method always @@ -229,7 +231,9 @@ func (client PermissionsClient) ListForResourceGroupPreparer(resourceGroupName s // ListForResourceGroupSender sends the ListForResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client PermissionsClient) ListForResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListForResourceGroupResponder handles the response to the ListForResourceGroup request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/authorization/provideroperationsmetadata.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/authorization/provideroperationsmetadata.go index 9a8b85b3a72d..b2460622a140 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/authorization/provideroperationsmetadata.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/authorization/provideroperationsmetadata.go @@ -92,7 +92,9 @@ func (client ProviderOperationsMetadataClient) GetPreparer(resourceProviderNames // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ProviderOperationsMetadataClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetResponder handles the response to the Get request. The method always @@ -154,7 +156,9 @@ func (client ProviderOperationsMetadataClient) ListPreparer(expand string) (*htt // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ProviderOperationsMetadataClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/authorization/roleassignments.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/authorization/roleassignments.go index 6306b0e535bb..24481cff72eb 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/authorization/roleassignments.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/authorization/roleassignments.go @@ -96,7 +96,9 @@ func (client RoleAssignmentsClient) CreatePreparer(scope string, roleAssignmentN // CreateSender sends the Create request. The method will close the // http.Response Body if it receives an error. func (client RoleAssignmentsClient) CreateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // CreateResponder handles the response to the Create request. The method always @@ -161,7 +163,9 @@ func (client RoleAssignmentsClient) CreateByIDPreparer(roleAssignmentID string, // CreateByIDSender sends the CreateByID request. The method will close the // http.Response Body if it receives an error. func (client RoleAssignmentsClient) CreateByIDSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // CreateByIDResponder handles the response to the CreateByID request. The method always @@ -226,7 +230,9 @@ func (client RoleAssignmentsClient) DeletePreparer(scope string, roleAssignmentN // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client RoleAssignmentsClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // DeleteResponder handles the response to the Delete request. The method always @@ -289,7 +295,9 @@ func (client RoleAssignmentsClient) DeleteByIDPreparer(roleAssignmentID string) // DeleteByIDSender sends the DeleteByID request. The method will close the // http.Response Body if it receives an error. func (client RoleAssignmentsClient) DeleteByIDSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // DeleteByIDResponder handles the response to the DeleteByID request. The method always @@ -353,7 +361,9 @@ func (client RoleAssignmentsClient) GetPreparer(scope string, roleAssignmentName // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client RoleAssignmentsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetResponder handles the response to the Get request. The method always @@ -416,7 +426,9 @@ func (client RoleAssignmentsClient) GetByIDPreparer(roleAssignmentID string) (*h // GetByIDSender sends the GetByID request. The method will close the // http.Response Body if it receives an error. func (client RoleAssignmentsClient) GetByIDSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetByIDResponder handles the response to the GetByID request. The method always @@ -484,7 +496,9 @@ func (client RoleAssignmentsClient) ListPreparer(filter string) (*http.Request, // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client RoleAssignmentsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -628,7 +642,9 @@ func (client RoleAssignmentsClient) ListForResourcePreparer(resourceGroupName st // ListForResourceSender sends the ListForResource request. The method will close the // http.Response Body if it receives an error. func (client RoleAssignmentsClient) ListForResourceSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListForResourceResponder handles the response to the ListForResource request. The method always @@ -766,7 +782,9 @@ func (client RoleAssignmentsClient) ListForResourceGroupPreparer(resourceGroupNa // ListForResourceGroupSender sends the ListForResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client RoleAssignmentsClient) ListForResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListForResourceGroupResponder handles the response to the ListForResourceGroup request. The method always @@ -903,7 +921,9 @@ func (client RoleAssignmentsClient) ListForScopePreparer(scope string, filter st // ListForScopeSender sends the ListForScope request. The method will close the // http.Response Body if it receives an error. func (client RoleAssignmentsClient) ListForScopeSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListForScopeResponder handles the response to the ListForScope request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/authorization/roledefinitions.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/authorization/roledefinitions.go index 2e48fdbe6b3f..5ed0683ae7d7 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/authorization/roledefinitions.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/authorization/roledefinitions.go @@ -92,7 +92,9 @@ func (client RoleDefinitionsClient) CreateOrUpdatePreparer(scope string, roleDef // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client RoleDefinitionsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -156,7 +158,9 @@ func (client RoleDefinitionsClient) DeletePreparer(scope string, roleDefinitionI // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client RoleDefinitionsClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // DeleteResponder handles the response to the Delete request. The method always @@ -220,7 +224,9 @@ func (client RoleDefinitionsClient) GetPreparer(scope string, roleDefinitionID s // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client RoleDefinitionsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetResponder handles the response to the Get request. The method always @@ -283,7 +289,9 @@ func (client RoleDefinitionsClient) GetByIDPreparer(roleDefinitionID string) (*h // GetByIDSender sends the GetByID request. The method will close the // http.Response Body if it receives an error. func (client RoleDefinitionsClient) GetByIDSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetByIDResponder handles the response to the GetByID request. The method always @@ -350,7 +358,9 @@ func (client RoleDefinitionsClient) ListPreparer(scope string, filter string) (* // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client RoleDefinitionsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/authorization/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/authorization/version.go index e41d47609cbb..8b49e435e4da 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/authorization/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/authorization/version.go @@ -19,10 +19,10 @@ package authorization // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-authorization/2015-07-01" + return "Azure-SDK-For-Go/v11.1.1-beta arm-authorization/2015-07-01" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/account.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/account.go index 9441db5b42c6..c7324f2c398f 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/account.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/account.go @@ -97,7 +97,9 @@ func (client AccountClient) CreateOrUpdatePreparer(resourceGroupName string, aut // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client AccountClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -168,7 +170,9 @@ func (client AccountClient) DeletePreparer(resourceGroupName string, automationA // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client AccountClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -238,7 +242,9 @@ func (client AccountClient) GetPreparer(resourceGroupName string, automationAcco // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client AccountClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -299,7 +305,9 @@ func (client AccountClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client AccountClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -438,7 +446,9 @@ func (client AccountClient) ListByResourceGroupPreparer(resourceGroupName string // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client AccountClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -581,7 +591,9 @@ func (client AccountClient) UpdatePreparer(resourceGroupName string, automationA // UpdateSender sends the Update request. The method will close the // http.Response Body if it receives an error. func (client AccountClient) UpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateResponder handles the response to the Update request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/activity.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/activity.go index 4e865773df70..320eb95818e3 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/activity.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/activity.go @@ -97,7 +97,9 @@ func (client ActivityClient) GetPreparer(resourceGroupName string, automationAcc // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ActivityClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -170,7 +172,9 @@ func (client ActivityClient) ListByModulePreparer(resourceGroupName string, auto // ListByModuleSender sends the ListByModule request. The method will close the // http.Response Body if it receives an error. func (client ActivityClient) ListByModuleSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByModuleResponder handles the response to the ListByModule request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/agentregistrationinformation.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/agentregistrationinformation.go index 996d67d7b40f..01591480c6b2 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/agentregistrationinformation.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/agentregistrationinformation.go @@ -95,7 +95,9 @@ func (client AgentRegistrationInformationClient) GetPreparer(resourceGroupName s // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client AgentRegistrationInformationClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -169,7 +171,9 @@ func (client AgentRegistrationInformationClient) RegenerateKeyPreparer(resourceG // RegenerateKeySender sends the RegenerateKey request. The method will close the // http.Response Body if it receives an error. func (client AgentRegistrationInformationClient) RegenerateKeySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RegenerateKeyResponder handles the response to the RegenerateKey request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/certificate.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/certificate.go index db2055ad6cb3..13ff5dfe870b 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/certificate.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/certificate.go @@ -103,7 +103,9 @@ func (client CertificateClient) CreateOrUpdatePreparer(resourceGroupName string, // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client CertificateClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -176,7 +178,9 @@ func (client CertificateClient) DeletePreparer(resourceGroupName string, automat // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client CertificateClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -248,7 +252,9 @@ func (client CertificateClient) GetPreparer(resourceGroupName string, automation // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client CertificateClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -319,7 +325,9 @@ func (client CertificateClient) ListByAutomationAccountPreparer(resourceGroupNam // ListByAutomationAccountSender sends the ListByAutomationAccount request. The method will close the // http.Response Body if it receives an error. func (client CertificateClient) ListByAutomationAccountSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByAutomationAccountResponder handles the response to the ListByAutomationAccount request. The method always @@ -464,7 +472,9 @@ func (client CertificateClient) UpdatePreparer(resourceGroupName string, automat // UpdateSender sends the Update request. The method will close the // http.Response Body if it receives an error. func (client CertificateClient) UpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateResponder handles the response to the Update request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/connection.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/connection.go index 8b97ce82ae74..10e4b4868501 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/connection.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/connection.go @@ -103,7 +103,9 @@ func (client ConnectionClient) CreateOrUpdatePreparer(resourceGroupName string, // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client ConnectionClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -176,7 +178,9 @@ func (client ConnectionClient) DeletePreparer(resourceGroupName string, automati // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client ConnectionClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -249,7 +253,9 @@ func (client ConnectionClient) GetPreparer(resourceGroupName string, automationA // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ConnectionClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -320,7 +326,9 @@ func (client ConnectionClient) ListByAutomationAccountPreparer(resourceGroupName // ListByAutomationAccountSender sends the ListByAutomationAccount request. The method will close the // http.Response Body if it receives an error. func (client ConnectionClient) ListByAutomationAccountSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByAutomationAccountResponder handles the response to the ListByAutomationAccount request. The method always @@ -465,7 +473,9 @@ func (client ConnectionClient) UpdatePreparer(resourceGroupName string, automati // UpdateSender sends the Update request. The method will close the // http.Response Body if it receives an error. func (client ConnectionClient) UpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateResponder handles the response to the Update request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/connectiontype.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/connectiontype.go index 94e88e98b8f8..832dddb1a622 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/connectiontype.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/connectiontype.go @@ -103,7 +103,9 @@ func (client ConnectionTypeClient) CreateOrUpdatePreparer(resourceGroupName stri // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client ConnectionTypeClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -176,7 +178,9 @@ func (client ConnectionTypeClient) DeletePreparer(resourceGroupName string, auto // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client ConnectionTypeClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -248,7 +252,9 @@ func (client ConnectionTypeClient) GetPreparer(resourceGroupName string, automat // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ConnectionTypeClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -319,7 +325,9 @@ func (client ConnectionTypeClient) ListByAutomationAccountPreparer(resourceGroup // ListByAutomationAccountSender sends the ListByAutomationAccount request. The method will close the // http.Response Body if it receives an error. func (client ConnectionTypeClient) ListByAutomationAccountSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByAutomationAccountResponder handles the response to the ListByAutomationAccount request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/credential.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/credential.go index 60acf232018a..2ca1b2605a3f 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/credential.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/credential.go @@ -105,7 +105,9 @@ func (client CredentialClient) CreateOrUpdatePreparer(resourceGroupName string, // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client CredentialClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -178,7 +180,9 @@ func (client CredentialClient) DeletePreparer(resourceGroupName string, automati // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client CredentialClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -250,7 +254,9 @@ func (client CredentialClient) GetPreparer(resourceGroupName string, automationA // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client CredentialClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -321,7 +327,9 @@ func (client CredentialClient) ListByAutomationAccountPreparer(resourceGroupName // ListByAutomationAccountSender sends the ListByAutomationAccount request. The method will close the // http.Response Body if it receives an error. func (client CredentialClient) ListByAutomationAccountSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByAutomationAccountResponder handles the response to the ListByAutomationAccount request. The method always @@ -466,7 +474,9 @@ func (client CredentialClient) UpdatePreparer(resourceGroupName string, automati // UpdateSender sends the Update request. The method will close the // http.Response Body if it receives an error. func (client CredentialClient) UpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateResponder handles the response to the Update request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/dsccompilationjob.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/dsccompilationjob.go index 67bd24f73119..4b71061ac7f6 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/dsccompilationjob.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/dsccompilationjob.go @@ -102,7 +102,9 @@ func (client DscCompilationJobClient) CreatePreparer(resourceGroupName string, a // CreateSender sends the Create request. The method will close the // http.Response Body if it receives an error. func (client DscCompilationJobClient) CreateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateResponder handles the response to the Create request. The method always @@ -175,7 +177,9 @@ func (client DscCompilationJobClient) GetPreparer(resourceGroupName string, auto // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client DscCompilationJobClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -249,7 +253,9 @@ func (client DscCompilationJobClient) GetStreamPreparer(resourceGroupName string // GetStreamSender sends the GetStream request. The method will close the // http.Response Body if it receives an error. func (client DscCompilationJobClient) GetStreamSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetStreamResponder handles the response to the GetStream request. The method always @@ -324,7 +330,9 @@ func (client DscCompilationJobClient) ListByAutomationAccountPreparer(resourceGr // ListByAutomationAccountSender sends the ListByAutomationAccount request. The method will close the // http.Response Body if it receives an error. func (client DscCompilationJobClient) ListByAutomationAccountSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByAutomationAccountResponder handles the response to the ListByAutomationAccount request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/dscconfiguration.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/dscconfiguration.go index c3af83ba26f9..5605bd2564f1 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/dscconfiguration.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/dscconfiguration.go @@ -108,7 +108,9 @@ func (client DscConfigurationClient) CreateOrUpdatePreparer(resourceGroupName st // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client DscConfigurationClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -181,7 +183,9 @@ func (client DscConfigurationClient) DeletePreparer(resourceGroupName string, au // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client DscConfigurationClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -253,7 +257,9 @@ func (client DscConfigurationClient) GetPreparer(resourceGroupName string, autom // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client DscConfigurationClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -326,7 +332,9 @@ func (client DscConfigurationClient) GetContentPreparer(resourceGroupName string // GetContentSender sends the GetContent request. The method will close the // http.Response Body if it receives an error. func (client DscConfigurationClient) GetContentSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetContentResponder handles the response to the GetContent request. The method always @@ -396,7 +404,9 @@ func (client DscConfigurationClient) ListByAutomationAccountPreparer(resourceGro // ListByAutomationAccountSender sends the ListByAutomationAccount request. The method will close the // http.Response Body if it receives an error. func (client DscConfigurationClient) ListByAutomationAccountSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByAutomationAccountResponder handles the response to the ListByAutomationAccount request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/dscnode.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/dscnode.go index 36aca87a9a80..9bdaaeeb6dad 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/dscnode.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/dscnode.go @@ -96,7 +96,9 @@ func (client DscNodeClient) DeletePreparer(resourceGroupName string, automationA // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client DscNodeClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -169,7 +171,9 @@ func (client DscNodeClient) GetPreparer(resourceGroupName string, automationAcco // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client DscNodeClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -244,7 +248,9 @@ func (client DscNodeClient) ListByAutomationAccountPreparer(resourceGroupName st // ListByAutomationAccountSender sends the ListByAutomationAccount request. The method will close the // http.Response Body if it receives an error. func (client DscNodeClient) ListByAutomationAccountSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByAutomationAccountResponder handles the response to the ListByAutomationAccount request. The method always @@ -388,7 +394,9 @@ func (client DscNodeClient) UpdatePreparer(resourceGroupName string, automationA // UpdateSender sends the Update request. The method will close the // http.Response Body if it receives an error. func (client DscNodeClient) UpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateResponder handles the response to the Update request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/dscnodeconfiguration.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/dscnodeconfiguration.go index 02449cd412b9..9ebfdd7990e0 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/dscnodeconfiguration.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/dscnodeconfiguration.go @@ -108,7 +108,9 @@ func (client DscNodeConfigurationClient) CreateOrUpdatePreparer(resourceGroupNam // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client DscNodeConfigurationClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -181,7 +183,9 @@ func (client DscNodeConfigurationClient) DeletePreparer(resourceGroupName string // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client DscNodeConfigurationClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -253,7 +257,9 @@ func (client DscNodeConfigurationClient) GetPreparer(resourceGroupName string, a // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client DscNodeConfigurationClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -328,7 +334,9 @@ func (client DscNodeConfigurationClient) ListByAutomationAccountPreparer(resourc // ListByAutomationAccountSender sends the ListByAutomationAccount request. The method will close the // http.Response Body if it receives an error. func (client DscNodeConfigurationClient) ListByAutomationAccountSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByAutomationAccountResponder handles the response to the ListByAutomationAccount request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/fields.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/fields.go index a8ac3c0603d7..08ffb92e3f97 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/fields.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/fields.go @@ -97,7 +97,9 @@ func (client FieldsClient) ListByTypePreparer(resourceGroupName string, automati // ListByTypeSender sends the ListByType request. The method will close the // http.Response Body if it receives an error. func (client FieldsClient) ListByTypeSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByTypeResponder handles the response to the ListByType request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/hybridrunbookworkergroup.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/hybridrunbookworkergroup.go index b3701a1ed18e..12da22f501d9 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/hybridrunbookworkergroup.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/hybridrunbookworkergroup.go @@ -96,7 +96,9 @@ func (client HybridRunbookWorkerGroupClient) DeletePreparer(resourceGroupName st // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client HybridRunbookWorkerGroupClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -168,7 +170,9 @@ func (client HybridRunbookWorkerGroupClient) GetPreparer(resourceGroupName strin // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client HybridRunbookWorkerGroupClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -239,7 +243,9 @@ func (client HybridRunbookWorkerGroupClient) ListByAutomationAccountPreparer(res // ListByAutomationAccountSender sends the ListByAutomationAccount request. The method will close the // http.Response Body if it receives an error. func (client HybridRunbookWorkerGroupClient) ListByAutomationAccountSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByAutomationAccountResponder handles the response to the ListByAutomationAccount request. The method always @@ -383,7 +389,9 @@ func (client HybridRunbookWorkerGroupClient) UpdatePreparer(resourceGroupName st // UpdateSender sends the Update request. The method will close the // http.Response Body if it receives an error. func (client HybridRunbookWorkerGroupClient) UpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateResponder handles the response to the Update request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/job.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/job.go index b99b38396613..51bb66a372eb 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/job.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/job.go @@ -102,7 +102,9 @@ func (client JobClient) CreatePreparer(resourceGroupName string, automationAccou // CreateSender sends the Create request. The method will close the // http.Response Body if it receives an error. func (client JobClient) CreateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateResponder handles the response to the Create request. The method always @@ -175,7 +177,9 @@ func (client JobClient) GetPreparer(resourceGroupName string, automationAccountN // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client JobClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -248,7 +252,9 @@ func (client JobClient) GetOutputPreparer(resourceGroupName string, automationAc // GetOutputSender sends the GetOutput request. The method will close the // http.Response Body if it receives an error. func (client JobClient) GetOutputSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetOutputResponder handles the response to the GetOutput request. The method always @@ -320,7 +326,9 @@ func (client JobClient) GetRunbookContentPreparer(resourceGroupName string, auto // GetRunbookContentSender sends the GetRunbookContent request. The method will close the // http.Response Body if it receives an error. func (client JobClient) GetRunbookContentSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetRunbookContentResponder handles the response to the GetRunbookContent request. The method always @@ -394,7 +402,9 @@ func (client JobClient) ListByAutomationAccountPreparer(resourceGroupName string // ListByAutomationAccountSender sends the ListByAutomationAccount request. The method will close the // http.Response Body if it receives an error. func (client JobClient) ListByAutomationAccountSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByAutomationAccountResponder handles the response to the ListByAutomationAccount request. The method always @@ -536,7 +546,9 @@ func (client JobClient) ResumePreparer(resourceGroupName string, automationAccou // ResumeSender sends the Resume request. The method will close the // http.Response Body if it receives an error. func (client JobClient) ResumeSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ResumeResponder handles the response to the Resume request. The method always @@ -608,7 +620,9 @@ func (client JobClient) StopPreparer(resourceGroupName string, automationAccount // StopSender sends the Stop request. The method will close the // http.Response Body if it receives an error. func (client JobClient) StopSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // StopResponder handles the response to the Stop request. The method always @@ -680,7 +694,9 @@ func (client JobClient) SuspendPreparer(resourceGroupName string, automationAcco // SuspendSender sends the Suspend request. The method will close the // http.Response Body if it receives an error. func (client JobClient) SuspendSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // SuspendResponder handles the response to the Suspend request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/jobschedule.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/jobschedule.go index 519223f97435..81ac25ef9758 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/jobschedule.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/jobschedule.go @@ -104,7 +104,9 @@ func (client JobScheduleClient) CreatePreparer(resourceGroupName string, automat // CreateSender sends the Create request. The method will close the // http.Response Body if it receives an error. func (client JobScheduleClient) CreateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateResponder handles the response to the Create request. The method always @@ -177,7 +179,9 @@ func (client JobScheduleClient) DeletePreparer(resourceGroupName string, automat // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client JobScheduleClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -249,7 +253,9 @@ func (client JobScheduleClient) GetPreparer(resourceGroupName string, automation // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client JobScheduleClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -320,7 +326,9 @@ func (client JobScheduleClient) ListByAutomationAccountPreparer(resourceGroupNam // ListByAutomationAccountSender sends the ListByAutomationAccount request. The method will close the // http.Response Body if it receives an error. func (client JobScheduleClient) ListByAutomationAccountSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByAutomationAccountResponder handles the response to the ListByAutomationAccount request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/jobstream.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/jobstream.go index 641c7558d772..eeb7e9da3d2c 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/jobstream.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/jobstream.go @@ -97,7 +97,9 @@ func (client JobStreamClient) GetPreparer(resourceGroupName string, automationAc // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client JobStreamClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -173,7 +175,9 @@ func (client JobStreamClient) ListByJobPreparer(resourceGroupName string, automa // ListByJobSender sends the ListByJob request. The method will close the // http.Response Body if it receives an error. func (client JobStreamClient) ListByJobSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByJobResponder handles the response to the ListByJob request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/module.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/module.go index 138c94c4af23..8538565f7e57 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/module.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/module.go @@ -107,7 +107,9 @@ func (client ModuleClient) CreateOrUpdatePreparer(resourceGroupName string, auto // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client ModuleClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -180,7 +182,9 @@ func (client ModuleClient) DeletePreparer(resourceGroupName string, automationAc // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client ModuleClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -252,7 +256,9 @@ func (client ModuleClient) GetPreparer(resourceGroupName string, automationAccou // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ModuleClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -323,7 +329,9 @@ func (client ModuleClient) ListByAutomationAccountPreparer(resourceGroupName str // ListByAutomationAccountSender sends the ListByAutomationAccount request. The method will close the // http.Response Body if it receives an error. func (client ModuleClient) ListByAutomationAccountSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByAutomationAccountResponder handles the response to the ListByAutomationAccount request. The method always @@ -467,7 +475,9 @@ func (client ModuleClient) UpdatePreparer(resourceGroupName string, automationAc // UpdateSender sends the Update request. The method will close the // http.Response Body if it receives an error. func (client ModuleClient) UpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateResponder handles the response to the Update request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/nodereports.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/nodereports.go index bafb26dc9da7..182d7af302e5 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/nodereports.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/nodereports.go @@ -97,7 +97,9 @@ func (client NodeReportsClient) GetPreparer(resourceGroupName string, automation // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client NodeReportsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -171,7 +173,9 @@ func (client NodeReportsClient) GetContentPreparer(resourceGroupName string, aut // GetContentSender sends the GetContent request. The method will close the // http.Response Body if it receives an error. func (client NodeReportsClient) GetContentSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetContentResponder handles the response to the GetContent request. The method always @@ -246,7 +250,9 @@ func (client NodeReportsClient) ListByNodePreparer(resourceGroupName string, aut // ListByNodeSender sends the ListByNode request. The method will close the // http.Response Body if it receives an error. func (client NodeReportsClient) ListByNodeSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByNodeResponder handles the response to the ListByNode request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/objectdatatypes.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/objectdatatypes.go index f5aed0ba9977..1f1097ae4f76 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/objectdatatypes.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/objectdatatypes.go @@ -97,7 +97,9 @@ func (client ObjectDataTypesClient) ListFieldsByModuleAndTypePreparer(resourceGr // ListFieldsByModuleAndTypeSender sends the ListFieldsByModuleAndType request. The method will close the // http.Response Body if it receives an error. func (client ObjectDataTypesClient) ListFieldsByModuleAndTypeSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListFieldsByModuleAndTypeResponder handles the response to the ListFieldsByModuleAndType request. The method always @@ -170,7 +172,9 @@ func (client ObjectDataTypesClient) ListFieldsByTypePreparer(resourceGroupName s // ListFieldsByTypeSender sends the ListFieldsByType request. The method will close the // http.Response Body if it receives an error. func (client ObjectDataTypesClient) ListFieldsByTypeSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListFieldsByTypeResponder handles the response to the ListFieldsByType request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/operations.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/operations.go index 4537d2d886a0..d1481f1e184a 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/operations.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/operations.go @@ -79,7 +79,9 @@ func (client OperationsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client OperationsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/runbook.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/runbook.go index 19e55f848e63..8298d5adaee9 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/runbook.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/runbook.go @@ -116,7 +116,9 @@ func (client RunbookClient) CreateOrUpdatePreparer(resourceGroupName string, aut // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client RunbookClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -188,7 +190,9 @@ func (client RunbookClient) DeletePreparer(resourceGroupName string, automationA // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client RunbookClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -260,7 +264,9 @@ func (client RunbookClient) GetPreparer(resourceGroupName string, automationAcco // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client RunbookClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -333,7 +339,9 @@ func (client RunbookClient) GetContentPreparer(resourceGroupName string, automat // GetContentSender sends the GetContent request. The method will close the // http.Response Body if it receives an error. func (client RunbookClient) GetContentSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetContentResponder handles the response to the GetContent request. The method always @@ -403,7 +411,9 @@ func (client RunbookClient) ListByAutomationAccountPreparer(resourceGroupName st // ListByAutomationAccountSender sends the ListByAutomationAccount request. The method will close the // http.Response Body if it receives an error. func (client RunbookClient) ListByAutomationAccountSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByAutomationAccountResponder handles the response to the ListByAutomationAccount request. The method always @@ -547,7 +557,9 @@ func (client RunbookClient) UpdatePreparer(resourceGroupName string, automationA // UpdateSender sends the Update request. The method will close the // http.Response Body if it receives an error. func (client RunbookClient) UpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateResponder handles the response to the Update request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/runbookdraft.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/runbookdraft.go index 5235164b5966..103f6ff49397 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/runbookdraft.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/runbookdraft.go @@ -119,6 +119,7 @@ func (client RunbookDraftClient) CreateOrUpdatePreparer(resourceGroupName string func (client RunbookDraftClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -191,7 +192,9 @@ func (client RunbookDraftClient) GetPreparer(resourceGroupName string, automatio // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client RunbookDraftClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -264,7 +267,9 @@ func (client RunbookDraftClient) GetContentPreparer(resourceGroupName string, au // GetContentSender sends the GetContent request. The method will close the // http.Response Body if it receives an error. func (client RunbookDraftClient) GetContentSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetContentResponder handles the response to the GetContent request. The method always @@ -355,6 +360,7 @@ func (client RunbookDraftClient) PublishPreparer(resourceGroupName string, autom func (client RunbookDraftClient) PublishSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -428,7 +434,9 @@ func (client RunbookDraftClient) UndoEditPreparer(resourceGroupName string, auto // UndoEditSender sends the UndoEdit request. The method will close the // http.Response Body if it receives an error. func (client RunbookDraftClient) UndoEditSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UndoEditResponder handles the response to the UndoEdit request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/schedule.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/schedule.go index a0b8a29f7b84..d50d9b13b6e5 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/schedule.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/schedule.go @@ -102,7 +102,9 @@ func (client ScheduleClient) CreateOrUpdatePreparer(resourceGroupName string, au // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client ScheduleClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -175,7 +177,9 @@ func (client ScheduleClient) DeletePreparer(resourceGroupName string, automation // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client ScheduleClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -247,7 +251,9 @@ func (client ScheduleClient) GetPreparer(resourceGroupName string, automationAcc // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ScheduleClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -318,7 +324,9 @@ func (client ScheduleClient) ListByAutomationAccountPreparer(resourceGroupName s // ListByAutomationAccountSender sends the ListByAutomationAccount request. The method will close the // http.Response Body if it receives an error. func (client ScheduleClient) ListByAutomationAccountSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByAutomationAccountResponder handles the response to the ListByAutomationAccount request. The method always @@ -462,7 +470,9 @@ func (client ScheduleClient) UpdatePreparer(resourceGroupName string, automation // UpdateSender sends the Update request. The method will close the // http.Response Body if it receives an error. func (client ScheduleClient) UpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateResponder handles the response to the Update request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/statistics.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/statistics.go index 2176811ad6d4..44a98bfabbd3 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/statistics.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/statistics.go @@ -98,7 +98,9 @@ func (client StatisticsClient) ListByAutomationAccountPreparer(resourceGroupName // ListByAutomationAccountSender sends the ListByAutomationAccount request. The method will close the // http.Response Body if it receives an error. func (client StatisticsClient) ListByAutomationAccountSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByAutomationAccountResponder handles the response to the ListByAutomationAccount request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/testjobs.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/testjobs.go index e22e3d026789..3a2b732cda6f 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/testjobs.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/testjobs.go @@ -101,7 +101,9 @@ func (client TestJobsClient) CreatePreparer(resourceGroupName string, automation // CreateSender sends the Create request. The method will close the // http.Response Body if it receives an error. func (client TestJobsClient) CreateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateResponder handles the response to the Create request. The method always @@ -174,7 +176,9 @@ func (client TestJobsClient) GetPreparer(resourceGroupName string, automationAcc // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client TestJobsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -247,7 +251,9 @@ func (client TestJobsClient) ResumePreparer(resourceGroupName string, automation // ResumeSender sends the Resume request. The method will close the // http.Response Body if it receives an error. func (client TestJobsClient) ResumeSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ResumeResponder handles the response to the Resume request. The method always @@ -319,7 +325,9 @@ func (client TestJobsClient) StopPreparer(resourceGroupName string, automationAc // StopSender sends the Stop request. The method will close the // http.Response Body if it receives an error. func (client TestJobsClient) StopSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // StopResponder handles the response to the Stop request. The method always @@ -391,7 +399,9 @@ func (client TestJobsClient) SuspendPreparer(resourceGroupName string, automatio // SuspendSender sends the Suspend request. The method will close the // http.Response Body if it receives an error. func (client TestJobsClient) SuspendSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // SuspendResponder handles the response to the Suspend request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/testjobstreams.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/testjobstreams.go index c557bd0753b2..2a2e7dae04c7 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/testjobstreams.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/testjobstreams.go @@ -97,7 +97,9 @@ func (client TestJobStreamsClient) GetPreparer(resourceGroupName string, automat // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client TestJobStreamsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -173,7 +175,9 @@ func (client TestJobStreamsClient) ListByTestJobPreparer(resourceGroupName strin // ListByTestJobSender sends the ListByTestJob request. The method will close the // http.Response Body if it receives an error. func (client TestJobStreamsClient) ListByTestJobSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByTestJobResponder handles the response to the ListByTestJob request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/usages.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/usages.go index 87452024853f..9486bfc38770 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/usages.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/usages.go @@ -94,7 +94,9 @@ func (client UsagesClient) ListByAutomationAccountPreparer(resourceGroupName str // ListByAutomationAccountSender sends the ListByAutomationAccount request. The method will close the // http.Response Body if it receives an error. func (client UsagesClient) ListByAutomationAccountSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByAutomationAccountResponder handles the response to the ListByAutomationAccount request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/variable.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/variable.go index d6cffd3f41ab..c31726138f62 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/variable.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/variable.go @@ -101,7 +101,9 @@ func (client VariableClient) CreateOrUpdatePreparer(resourceGroupName string, au // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client VariableClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -174,7 +176,9 @@ func (client VariableClient) DeletePreparer(resourceGroupName string, automation // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client VariableClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -246,7 +250,9 @@ func (client VariableClient) GetPreparer(resourceGroupName string, automationAcc // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client VariableClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -317,7 +323,9 @@ func (client VariableClient) ListByAutomationAccountPreparer(resourceGroupName s // ListByAutomationAccountSender sends the ListByAutomationAccount request. The method will close the // http.Response Body if it receives an error. func (client VariableClient) ListByAutomationAccountSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByAutomationAccountResponder handles the response to the ListByAutomationAccount request. The method always @@ -461,7 +469,9 @@ func (client VariableClient) UpdatePreparer(resourceGroupName string, automation // UpdateSender sends the Update request. The method will close the // http.Response Body if it receives an error. func (client VariableClient) UpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateResponder handles the response to the Update request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/version.go index f95f64497821..bffe077dca41 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/version.go @@ -19,10 +19,10 @@ package automation // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-automation/2015-10-31" + return "Azure-SDK-For-Go/v11.1.1-beta arm-automation/2015-10-31" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/webhook.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/webhook.go index 432c682bbea1..04876613792f 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/webhook.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/automation/webhook.go @@ -101,7 +101,9 @@ func (client WebhookClient) CreateOrUpdatePreparer(resourceGroupName string, aut // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client WebhookClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -174,7 +176,9 @@ func (client WebhookClient) DeletePreparer(resourceGroupName string, automationA // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client WebhookClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -244,7 +248,9 @@ func (client WebhookClient) GenerateURIPreparer(resourceGroupName string, automa // GenerateURISender sends the GenerateURI request. The method will close the // http.Response Body if it receives an error. func (client WebhookClient) GenerateURISender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GenerateURIResponder handles the response to the GenerateURI request. The method always @@ -317,7 +323,9 @@ func (client WebhookClient) GetPreparer(resourceGroupName string, automationAcco // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client WebhookClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -392,7 +400,9 @@ func (client WebhookClient) ListByAutomationAccountPreparer(resourceGroupName st // ListByAutomationAccountSender sends the ListByAutomationAccount request. The method will close the // http.Response Body if it receives an error. func (client WebhookClient) ListByAutomationAccountSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByAutomationAccountResponder handles the response to the ListByAutomationAccount request. The method always @@ -536,7 +546,9 @@ func (client WebhookClient) UpdatePreparer(resourceGroupName string, automationA // UpdateSender sends the Update request. The method will close the // http.Response Body if it receives an error. func (client WebhookClient) UpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateResponder handles the response to the Update request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/client.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/client.go index 695d08375e63..2270397616b2 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/client.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/client.go @@ -107,7 +107,9 @@ func (client ManagementClient) CheckNameAvailabilityPreparer(checkNameAvailabili // CheckNameAvailabilitySender sends the CheckNameAvailability request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) CheckNameAvailabilitySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // CheckNameAvailabilityResponder handles the response to the CheckNameAvailability request. The method always @@ -180,7 +182,9 @@ func (client ManagementClient) ValidateProbePreparer(validateProbeInput Validate // ValidateProbeSender sends the ValidateProbe request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) ValidateProbeSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ValidateProbeResponder handles the response to the ValidateProbe request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/customdomains.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/customdomains.go index 5eef2abaffc5..9f37dac51209 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/customdomains.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/customdomains.go @@ -127,6 +127,7 @@ func (client CustomDomainsClient) CreatePreparer(resourceGroupName string, profi func (client CustomDomainsClient) CreateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -224,6 +225,7 @@ func (client CustomDomainsClient) DeletePreparer(resourceGroupName string, profi func (client CustomDomainsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -301,7 +303,9 @@ func (client CustomDomainsClient) DisableCustomHTTPSPreparer(resourceGroupName s // DisableCustomHTTPSSender sends the DisableCustomHTTPS request. The method will close the // http.Response Body if it receives an error. func (client CustomDomainsClient) DisableCustomHTTPSSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DisableCustomHTTPSResponder handles the response to the DisableCustomHTTPS request. The method always @@ -378,7 +382,9 @@ func (client CustomDomainsClient) EnableCustomHTTPSPreparer(resourceGroupName st // EnableCustomHTTPSSender sends the EnableCustomHTTPS request. The method will close the // http.Response Body if it receives an error. func (client CustomDomainsClient) EnableCustomHTTPSSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // EnableCustomHTTPSResponder handles the response to the EnableCustomHTTPS request. The method always @@ -455,7 +461,9 @@ func (client CustomDomainsClient) GetPreparer(resourceGroupName string, profileN // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client CustomDomainsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -531,7 +539,9 @@ func (client CustomDomainsClient) ListByEndpointPreparer(resourceGroupName strin // ListByEndpointSender sends the ListByEndpoint request. The method will close the // http.Response Body if it receives an error. func (client CustomDomainsClient) ListByEndpointSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByEndpointResponder handles the response to the ListByEndpoint request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/edgenodes.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/edgenodes.go index 7310841507b4..6125b0d33356 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/edgenodes.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/edgenodes.go @@ -80,7 +80,9 @@ func (client EdgeNodesClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client EdgeNodesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/endpoints.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/endpoints.go index f53025c6046e..c89406321f54 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/endpoints.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/endpoints.go @@ -125,6 +125,7 @@ func (client EndpointsClient) CreatePreparer(resourceGroupName string, profileNa func (client EndpointsClient) CreateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -221,6 +222,7 @@ func (client EndpointsClient) DeletePreparer(resourceGroupName string, profileNa func (client EndpointsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -297,7 +299,9 @@ func (client EndpointsClient) GetPreparer(resourceGroupName string, profileName // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client EndpointsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -371,7 +375,9 @@ func (client EndpointsClient) ListByProfilePreparer(resourceGroupName string, pr // ListByProfileSender sends the ListByProfile request. The method will close the // http.Response Body if it receives an error. func (client EndpointsClient) ListByProfileSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByProfileResponder handles the response to the ListByProfile request. The method always @@ -516,7 +522,9 @@ func (client EndpointsClient) ListResourceUsagePreparer(resourceGroupName string // ListResourceUsageSender sends the ListResourceUsage request. The method will close the // http.Response Body if it receives an error. func (client EndpointsClient) ListResourceUsageSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResourceUsageResponder handles the response to the ListResourceUsage request. The method always @@ -686,6 +694,7 @@ func (client EndpointsClient) LoadContentPreparer(resourceGroupName string, prof func (client EndpointsClient) LoadContentSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -786,6 +795,7 @@ func (client EndpointsClient) PurgeContentPreparer(resourceGroupName string, pro func (client EndpointsClient) PurgeContentSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -881,6 +891,7 @@ func (client EndpointsClient) StartPreparer(resourceGroupName string, profileNam func (client EndpointsClient) StartSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -976,6 +987,7 @@ func (client EndpointsClient) StopPreparer(resourceGroupName string, profileName func (client EndpointsClient) StopSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1076,6 +1088,7 @@ func (client EndpointsClient) UpdatePreparer(resourceGroupName string, profileNa func (client EndpointsClient) UpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1156,7 +1169,9 @@ func (client EndpointsClient) ValidateCustomDomainPreparer(resourceGroupName str // ValidateCustomDomainSender sends the ValidateCustomDomain request. The method will close the // http.Response Body if it receives an error. func (client EndpointsClient) ValidateCustomDomainSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ValidateCustomDomainResponder handles the response to the ValidateCustomDomain request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/operations.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/operations.go index 3f67f31ff1a7..1b4402a7eeb4 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/operations.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/operations.go @@ -80,7 +80,9 @@ func (client OperationsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client OperationsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/origins.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/origins.go index 5e2c16511349..7e24dea8643e 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/origins.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/origins.go @@ -101,7 +101,9 @@ func (client OriginsClient) GetPreparer(resourceGroupName string, profileName st // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client OriginsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -177,7 +179,9 @@ func (client OriginsClient) ListByEndpointPreparer(resourceGroupName string, pro // ListByEndpointSender sends the ListByEndpoint request. The method will close the // http.Response Body if it receives an error. func (client OriginsClient) ListByEndpointSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByEndpointResponder handles the response to the ListByEndpoint request. The method always @@ -346,6 +350,7 @@ func (client OriginsClient) UpdatePreparer(resourceGroupName string, profileName func (client OriginsClient) UpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/profiles.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/profiles.go index 9c8929759646..56fd2373fe23 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/profiles.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/profiles.go @@ -122,6 +122,7 @@ func (client ProfilesClient) CreatePreparer(resourceGroupName string, profileNam func (client ProfilesClient) CreateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -217,6 +218,7 @@ func (client ProfilesClient) DeletePreparer(resourceGroupName string, profileNam func (client ProfilesClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -293,7 +295,9 @@ func (client ProfilesClient) GenerateSsoURIPreparer(resourceGroupName string, pr // GenerateSsoURISender sends the GenerateSsoURI request. The method will close the // http.Response Body if it receives an error. func (client ProfilesClient) GenerateSsoURISender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GenerateSsoURIResponder handles the response to the GenerateSsoURI request. The method always @@ -367,7 +371,9 @@ func (client ProfilesClient) GetPreparer(resourceGroupName string, profileName s // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ProfilesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -428,7 +434,9 @@ func (client ProfilesClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ProfilesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -569,7 +577,9 @@ func (client ProfilesClient) ListByResourceGroupPreparer(resourceGroupName strin // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client ProfilesClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -712,7 +722,9 @@ func (client ProfilesClient) ListResourceUsagePreparer(resourceGroupName string, // ListResourceUsageSender sends the ListResourceUsage request. The method will close the // http.Response Body if it receives an error. func (client ProfilesClient) ListResourceUsageSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResourceUsageResponder handles the response to the ListResourceUsage request. The method always @@ -856,7 +868,9 @@ func (client ProfilesClient) ListSupportedOptimizationTypesPreparer(resourceGrou // ListSupportedOptimizationTypesSender sends the ListSupportedOptimizationTypes request. The method will close the // http.Response Body if it receives an error. func (client ProfilesClient) ListSupportedOptimizationTypesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListSupportedOptimizationTypesResponder handles the response to the ListSupportedOptimizationTypes request. The method always @@ -953,6 +967,7 @@ func (client ProfilesClient) UpdatePreparer(resourceGroupName string, profileNam func (client ProfilesClient) UpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/resourceusage.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/resourceusage.go index 0a2868ea31af..d67c16fc9598 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/resourceusage.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/resourceusage.go @@ -84,7 +84,9 @@ func (client ResourceUsageClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ResourceUsageClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/version.go index dd6377c93a7f..58be63b6ff36 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/cdn/version.go @@ -19,10 +19,10 @@ package cdn // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-cdn/2017-04-02" + return "Azure-SDK-For-Go/v11.1.1-beta arm-cdn/2017-04-02" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/availabilitysets.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/availabilitysets.go index bf1a8fc34e38..76c20408fb13 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/availabilitysets.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/availabilitysets.go @@ -90,7 +90,9 @@ func (client AvailabilitySetsClient) CreateOrUpdatePreparer(resourceGroupName st // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client AvailabilitySetsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -155,7 +157,9 @@ func (client AvailabilitySetsClient) DeletePreparer(resourceGroupName string, av // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client AvailabilitySetsClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -220,7 +224,9 @@ func (client AvailabilitySetsClient) GetPreparer(resourceGroupName string, avail // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client AvailabilitySetsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -284,7 +290,9 @@ func (client AvailabilitySetsClient) ListPreparer(resourceGroupName string) (*ht // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client AvailabilitySetsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -350,7 +358,9 @@ func (client AvailabilitySetsClient) ListAvailableSizesPreparer(resourceGroupNam // ListAvailableSizesSender sends the ListAvailableSizes request. The method will close the // http.Response Body if it receives an error. func (client AvailabilitySetsClient) ListAvailableSizesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAvailableSizesResponder handles the response to the ListAvailableSizes request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/containerservices.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/containerservices.go index 98c1706eef7b..a09f4c3357f3 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/containerservices.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/containerservices.go @@ -144,6 +144,7 @@ func (client ContainerServicesClient) CreateOrUpdatePreparer(resourceGroupName s func (client ContainerServicesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -229,6 +230,7 @@ func (client ContainerServicesClient) DeletePreparer(resourceGroupName string, c func (client ContainerServicesClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -296,7 +298,9 @@ func (client ContainerServicesClient) GetPreparer(resourceGroupName string, cont // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ContainerServicesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -358,7 +362,9 @@ func (client ContainerServicesClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ContainerServicesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -493,7 +499,9 @@ func (client ContainerServicesClient) ListByResourceGroupPreparer(resourceGroupN // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client ContainerServicesClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/disks.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/disks.go index 47e9e4029ce7..18efc73b229d 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/disks.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/disks.go @@ -131,6 +131,7 @@ func (client DisksClient) CreateOrUpdatePreparer(resourceGroupName string, diskN func (client DisksClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -213,6 +214,7 @@ func (client DisksClient) DeletePreparer(resourceGroupName string, diskName stri func (client DisksClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -279,7 +281,9 @@ func (client DisksClient) GetPreparer(resourceGroupName string, diskName string) // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client DisksClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -372,6 +376,7 @@ func (client DisksClient) GrantAccessPreparer(resourceGroupName string, diskName func (client DisksClient) GrantAccessSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -433,7 +438,9 @@ func (client DisksClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client DisksClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -566,7 +573,9 @@ func (client DisksClient) ListByResourceGroupPreparer(resourceGroupName string) // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client DisksClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -717,6 +726,7 @@ func (client DisksClient) RevokeAccessPreparer(resourceGroupName string, diskNam func (client DisksClient) RevokeAccessSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -801,6 +811,7 @@ func (client DisksClient) UpdatePreparer(resourceGroupName string, diskName stri func (client DisksClient) UpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/images.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/images.go index bbde2bc7f95f..6a5c06ad1535 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/images.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/images.go @@ -119,6 +119,7 @@ func (client ImagesClient) CreateOrUpdatePreparer(resourceGroupName string, imag func (client ImagesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -200,6 +201,7 @@ func (client ImagesClient) DeletePreparer(resourceGroupName string, imageName st func (client ImagesClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -269,7 +271,9 @@ func (client ImagesClient) GetPreparer(resourceGroupName string, imageName strin // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ImagesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -331,7 +335,9 @@ func (client ImagesClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ImagesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -464,7 +470,9 @@ func (client ImagesClient) ListByResourceGroupPreparer(resourceGroupName string) // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client ImagesClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/resourceskus.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/resourceskus.go index 9dd7fffa8564..c92374bfaa5f 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/resourceskus.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/resourceskus.go @@ -83,7 +83,9 @@ func (client ResourceSkusClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ResourceSkusClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/snapshots.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/snapshots.go index 2c7135292156..2c77c51ce8e0 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/snapshots.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/snapshots.go @@ -131,6 +131,7 @@ func (client SnapshotsClient) CreateOrUpdatePreparer(resourceGroupName string, s func (client SnapshotsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -213,6 +214,7 @@ func (client SnapshotsClient) DeletePreparer(resourceGroupName string, snapshotN func (client SnapshotsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -279,7 +281,9 @@ func (client SnapshotsClient) GetPreparer(resourceGroupName string, snapshotName // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client SnapshotsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -373,6 +377,7 @@ func (client SnapshotsClient) GrantAccessPreparer(resourceGroupName string, snap func (client SnapshotsClient) GrantAccessSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -434,7 +439,9 @@ func (client SnapshotsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client SnapshotsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -567,7 +574,9 @@ func (client SnapshotsClient) ListByResourceGroupPreparer(resourceGroupName stri // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client SnapshotsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -718,6 +727,7 @@ func (client SnapshotsClient) RevokeAccessPreparer(resourceGroupName string, sna func (client SnapshotsClient) RevokeAccessSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -802,6 +812,7 @@ func (client SnapshotsClient) UpdatePreparer(resourceGroupName string, snapshotN func (client SnapshotsClient) UpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/usage.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/usage.go index 86e9ebabf3b7..ddf8917e3cbe 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/usage.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/usage.go @@ -94,7 +94,9 @@ func (client UsageClient) ListPreparer(location string) (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client UsageClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/version.go index 2f9cac6f3bc7..0ce1840a7581 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/version.go @@ -19,10 +19,10 @@ package compute // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-compute/" + return "Azure-SDK-For-Go/v11.1.1-beta arm-compute/" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachineextensionimages.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachineextensionimages.go index c486f63ced50..2a9a4d28930f 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachineextensionimages.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachineextensionimages.go @@ -90,7 +90,9 @@ func (client VirtualMachineExtensionImagesClient) GetPreparer(location string, p // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachineExtensionImagesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -155,7 +157,9 @@ func (client VirtualMachineExtensionImagesClient) ListTypesPreparer(location str // ListTypesSender sends the ListTypes request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachineExtensionImagesClient) ListTypesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListTypesResponder handles the response to the ListTypes request. The method always @@ -230,7 +234,9 @@ func (client VirtualMachineExtensionImagesClient) ListVersionsPreparer(location // ListVersionsSender sends the ListVersions request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachineExtensionImagesClient) ListVersionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListVersionsResponder handles the response to the ListVersions request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachineextensions.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachineextensions.go index e8f0b27f1b00..4b8af16c9018 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachineextensions.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachineextensions.go @@ -109,6 +109,7 @@ func (client VirtualMachineExtensionsClient) CreateOrUpdatePreparer(resourceGrou func (client VirtualMachineExtensionsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -192,6 +193,7 @@ func (client VirtualMachineExtensionsClient) DeletePreparer(resourceGroupName st func (client VirtualMachineExtensionsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -263,7 +265,9 @@ func (client VirtualMachineExtensionsClient) GetPreparer(resourceGroupName strin // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachineExtensionsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachineimages.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachineimages.go index 9eda416e9584..2e1e20b04424 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachineimages.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachineimages.go @@ -91,7 +91,9 @@ func (client VirtualMachineImagesClient) GetPreparer(location string, publisherN // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachineImagesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -168,7 +170,9 @@ func (client VirtualMachineImagesClient) ListPreparer(location string, publisher // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachineImagesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -233,7 +237,9 @@ func (client VirtualMachineImagesClient) ListOffersPreparer(location string, pub // ListOffersSender sends the ListOffers request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachineImagesClient) ListOffersSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListOffersResponder handles the response to the ListOffers request. The method always @@ -297,7 +303,9 @@ func (client VirtualMachineImagesClient) ListPublishersPreparer(location string) // ListPublishersSender sends the ListPublishers request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachineImagesClient) ListPublishersSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListPublishersResponder handles the response to the ListPublishers request. The method always @@ -364,7 +372,9 @@ func (client VirtualMachineImagesClient) ListSkusPreparer(location string, publi // ListSkusSender sends the ListSkus request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachineImagesClient) ListSkusSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListSkusResponder handles the response to the ListSkus request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachineruncommands.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachineruncommands.go index f422c92f58c0..287566a6a98f 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachineruncommands.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachineruncommands.go @@ -94,7 +94,9 @@ func (client VirtualMachineRunCommandsClient) GetPreparer(location string, comma // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachineRunCommandsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -164,7 +166,9 @@ func (client VirtualMachineRunCommandsClient) ListPreparer(location string) (*ht // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachineRunCommandsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachines.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachines.go index ad1d829d14dc..086463240a42 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachines.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachines.go @@ -119,6 +119,7 @@ func (client VirtualMachinesClient) CapturePreparer(resourceGroupName string, VM func (client VirtualMachinesClient) CaptureSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -201,6 +202,7 @@ func (client VirtualMachinesClient) ConvertToManagedDisksPreparer(resourceGroupN func (client VirtualMachinesClient) ConvertToManagedDisksSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -310,6 +312,7 @@ func (client VirtualMachinesClient) CreateOrUpdatePreparer(resourceGroupName str func (client VirtualMachinesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -392,6 +395,7 @@ func (client VirtualMachinesClient) DeallocatePreparer(resourceGroupName string, func (client VirtualMachinesClient) DeallocateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -473,6 +477,7 @@ func (client VirtualMachinesClient) DeletePreparer(resourceGroupName string, VMN func (client VirtualMachinesClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -538,7 +543,9 @@ func (client VirtualMachinesClient) GeneralizePreparer(resourceGroupName string, // GeneralizeSender sends the Generalize request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachinesClient) GeneralizeSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GeneralizeResponder handles the response to the Generalize request. The method always @@ -607,7 +614,9 @@ func (client VirtualMachinesClient) GetPreparer(resourceGroupName string, VMName // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachinesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -672,7 +681,9 @@ func (client VirtualMachinesClient) InstanceViewPreparer(resourceGroupName strin // InstanceViewSender sends the InstanceView request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachinesClient) InstanceViewSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // InstanceViewResponder handles the response to the InstanceView request. The method always @@ -737,7 +748,9 @@ func (client VirtualMachinesClient) ListPreparer(resourceGroupName string) (*htt // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachinesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -868,7 +881,9 @@ func (client VirtualMachinesClient) ListAllPreparer() (*http.Request, error) { // ListAllSender sends the ListAll request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachinesClient) ListAllSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAllResponder handles the response to the ListAll request. The method always @@ -1002,7 +1017,9 @@ func (client VirtualMachinesClient) ListAvailableSizesPreparer(resourceGroupName // ListAvailableSizesSender sends the ListAvailableSizes request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachinesClient) ListAvailableSizesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAvailableSizesResponder handles the response to the ListAvailableSizes request. The method always @@ -1084,6 +1101,7 @@ func (client VirtualMachinesClient) PerformMaintenancePreparer(resourceGroupName func (client VirtualMachinesClient) PerformMaintenanceSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1167,6 +1185,7 @@ func (client VirtualMachinesClient) PowerOffPreparer(resourceGroupName string, V func (client VirtualMachinesClient) PowerOffSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1249,6 +1268,7 @@ func (client VirtualMachinesClient) RedeployPreparer(resourceGroupName string, V func (client VirtualMachinesClient) RedeploySender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1330,6 +1350,7 @@ func (client VirtualMachinesClient) RestartPreparer(resourceGroupName string, VM func (client VirtualMachinesClient) RestartSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1423,6 +1444,7 @@ func (client VirtualMachinesClient) RunCommandPreparer(resourceGroupName string, func (client VirtualMachinesClient) RunCommandSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1504,6 +1526,7 @@ func (client VirtualMachinesClient) StartPreparer(resourceGroupName string, VMNa func (client VirtualMachinesClient) StartSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachinescalesetextensions.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachinescalesetextensions.go index 9a198f148d20..882339202b15 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachinescalesetextensions.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachinescalesetextensions.go @@ -110,6 +110,7 @@ func (client VirtualMachineScaleSetExtensionsClient) CreateOrUpdatePreparer(reso func (client VirtualMachineScaleSetExtensionsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -193,6 +194,7 @@ func (client VirtualMachineScaleSetExtensionsClient) DeletePreparer(resourceGrou func (client VirtualMachineScaleSetExtensionsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -264,7 +266,9 @@ func (client VirtualMachineScaleSetExtensionsClient) GetPreparer(resourceGroupNa // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachineScaleSetExtensionsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -330,7 +334,9 @@ func (client VirtualMachineScaleSetExtensionsClient) ListPreparer(resourceGroupN // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachineScaleSetExtensionsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachinescalesetrollingupgrades.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachinescalesetrollingupgrades.go index 45cc6e5c51cb..230b5da939c1 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachinescalesetrollingupgrades.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachinescalesetrollingupgrades.go @@ -106,6 +106,7 @@ func (client VirtualMachineScaleSetRollingUpgradesClient) CancelPreparer(resourc func (client VirtualMachineScaleSetRollingUpgradesClient) CancelSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -171,7 +172,9 @@ func (client VirtualMachineScaleSetRollingUpgradesClient) GetLatestPreparer(reso // GetLatestSender sends the GetLatest request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachineScaleSetRollingUpgradesClient) GetLatestSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetLatestResponder handles the response to the GetLatest request. The method always @@ -254,6 +257,7 @@ func (client VirtualMachineScaleSetRollingUpgradesClient) StartOSUpgradePreparer func (client VirtualMachineScaleSetRollingUpgradesClient) StartOSUpgradeSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachinescalesets.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachinescalesets.go index 72a868579acb..64c5c6d7a17f 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachinescalesets.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachinescalesets.go @@ -133,6 +133,7 @@ func (client VirtualMachineScaleSetsClient) CreateOrUpdatePreparer(resourceGroup func (client VirtualMachineScaleSetsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -222,6 +223,7 @@ func (client VirtualMachineScaleSetsClient) DeallocatePreparer(resourceGroupName func (client VirtualMachineScaleSetsClient) DeallocateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -303,6 +305,7 @@ func (client VirtualMachineScaleSetsClient) DeletePreparer(resourceGroupName str func (client VirtualMachineScaleSetsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -397,6 +400,7 @@ func (client VirtualMachineScaleSetsClient) DeleteInstancesPreparer(resourceGrou func (client VirtualMachineScaleSetsClient) DeleteInstancesSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -462,7 +466,9 @@ func (client VirtualMachineScaleSetsClient) GetPreparer(resourceGroupName string // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachineScaleSetsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -527,7 +533,9 @@ func (client VirtualMachineScaleSetsClient) GetInstanceViewPreparer(resourceGrou // GetInstanceViewSender sends the GetInstanceView request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachineScaleSetsClient) GetInstanceViewSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetInstanceViewResponder handles the response to the GetInstanceView request. The method always @@ -591,7 +599,9 @@ func (client VirtualMachineScaleSetsClient) ListPreparer(resourceGroupName strin // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachineScaleSetsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -723,7 +733,9 @@ func (client VirtualMachineScaleSetsClient) ListAllPreparer() (*http.Request, er // ListAllSender sends the ListAll request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachineScaleSetsClient) ListAllSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAllResponder handles the response to the ListAll request. The method always @@ -858,7 +870,9 @@ func (client VirtualMachineScaleSetsClient) ListSkusPreparer(resourceGroupName s // ListSkusSender sends the ListSkus request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachineScaleSetsClient) ListSkusSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListSkusResponder handles the response to the ListSkus request. The method always @@ -1016,6 +1030,7 @@ func (client VirtualMachineScaleSetsClient) PowerOffPreparer(resourceGroupName s func (client VirtualMachineScaleSetsClient) PowerOffSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1104,6 +1119,7 @@ func (client VirtualMachineScaleSetsClient) ReimagePreparer(resourceGroupName st func (client VirtualMachineScaleSetsClient) ReimageSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1192,6 +1208,7 @@ func (client VirtualMachineScaleSetsClient) ReimageAllPreparer(resourceGroupName func (client VirtualMachineScaleSetsClient) ReimageAllSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1280,6 +1297,7 @@ func (client VirtualMachineScaleSetsClient) RestartPreparer(resourceGroupName st func (client VirtualMachineScaleSetsClient) RestartSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1368,6 +1386,7 @@ func (client VirtualMachineScaleSetsClient) StartPreparer(resourceGroupName stri func (client VirtualMachineScaleSetsClient) StartSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1452,6 +1471,7 @@ func (client VirtualMachineScaleSetsClient) UpdatePreparer(resourceGroupName str func (client VirtualMachineScaleSetsClient) UpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1546,6 +1566,7 @@ func (client VirtualMachineScaleSetsClient) UpdateInstancesPreparer(resourceGrou func (client VirtualMachineScaleSetsClient) UpdateInstancesSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachinescalesetvms.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachinescalesetvms.go index 5a15edae9131..0be36c9ac63a 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachinescalesetvms.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachinescalesetvms.go @@ -107,6 +107,7 @@ func (client VirtualMachineScaleSetVMsClient) DeallocatePreparer(resourceGroupNa func (client VirtualMachineScaleSetVMsClient) DeallocateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -191,6 +192,7 @@ func (client VirtualMachineScaleSetVMsClient) DeletePreparer(resourceGroupName s func (client VirtualMachineScaleSetVMsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -258,7 +260,9 @@ func (client VirtualMachineScaleSetVMsClient) GetPreparer(resourceGroupName stri // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachineScaleSetVMsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -325,7 +329,9 @@ func (client VirtualMachineScaleSetVMsClient) GetInstanceViewPreparer(resourceGr // GetInstanceViewSender sends the GetInstanceView request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachineScaleSetVMsClient) GetInstanceViewSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetInstanceViewResponder handles the response to the GetInstanceView request. The method always @@ -401,7 +407,9 @@ func (client VirtualMachineScaleSetVMsClient) ListPreparer(resourceGroupName str // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachineScaleSetVMsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -555,6 +563,7 @@ func (client VirtualMachineScaleSetVMsClient) PowerOffPreparer(resourceGroupName func (client VirtualMachineScaleSetVMsClient) PowerOffSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -639,6 +648,7 @@ func (client VirtualMachineScaleSetVMsClient) ReimagePreparer(resourceGroupName func (client VirtualMachineScaleSetVMsClient) ReimageSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -723,6 +733,7 @@ func (client VirtualMachineScaleSetVMsClient) ReimageAllPreparer(resourceGroupNa func (client VirtualMachineScaleSetVMsClient) ReimageAllSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -807,6 +818,7 @@ func (client VirtualMachineScaleSetVMsClient) RestartPreparer(resourceGroupName func (client VirtualMachineScaleSetVMsClient) RestartSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -890,6 +902,7 @@ func (client VirtualMachineScaleSetVMsClient) StartPreparer(resourceGroupName st func (client VirtualMachineScaleSetVMsClient) StartSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachinesizes.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachinesizes.go index dc2f2778bea2..0833578d5a6c 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachinesizes.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/compute/virtualmachinesizes.go @@ -93,7 +93,9 @@ func (client VirtualMachineSizesClient) ListPreparer(location string) (*http.Req // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client VirtualMachineSizesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/containerinstance/containergroups.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/containerinstance/containergroups.go index 14c243329500..1f36f96b0f4b 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/containerinstance/containergroups.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/containerinstance/containergroups.go @@ -103,7 +103,9 @@ func (client ContainerGroupsClient) CreateOrUpdatePreparer(resourceGroupName str // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client ContainerGroupsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -170,7 +172,9 @@ func (client ContainerGroupsClient) DeletePreparer(resourceGroupName string, con // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client ContainerGroupsClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -238,7 +242,9 @@ func (client ContainerGroupsClient) GetPreparer(resourceGroupName string, contai // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ContainerGroupsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -301,7 +307,9 @@ func (client ContainerGroupsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ContainerGroupsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -436,7 +444,9 @@ func (client ContainerGroupsClient) ListByResourceGroupPreparer(resourceGroupNam // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client ContainerGroupsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/containerinstance/containerlogs.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/containerinstance/containerlogs.go index 9f742dd79755..93b1109a77e9 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/containerinstance/containerlogs.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/containerinstance/containerlogs.go @@ -94,7 +94,9 @@ func (client ContainerLogsClient) ListPreparer(resourceGroupName string, contain // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ContainerLogsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/containerinstance/models.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/containerinstance/models.go index f04bedfcf372..78dad19f3b24 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/containerinstance/models.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/containerinstance/models.go @@ -86,18 +86,6 @@ type ContainerGroup struct { *ContainerGroupProperties `json:"properties,omitempty"` } -// ContainerGroupProperties is -type ContainerGroupProperties struct { - ProvisioningState *string `json:"provisioningState,omitempty"` - Containers *[]Container `json:"containers,omitempty"` - ImageRegistryCredentials *[]ImageRegistryCredential `json:"imageRegistryCredentials,omitempty"` - RestartPolicy ContainerRestartPolicy `json:"restartPolicy,omitempty"` - IPAddress *IPAddress `json:"ipAddress,omitempty"` - OsType OperatingSystemTypes `json:"osType,omitempty"` - State *string `json:"state,omitempty"` - Volumes *[]Volume `json:"volumes,omitempty"` -} - // ContainerGroupListResult is the container group list response that contains the container group properties. type ContainerGroupListResult struct { autorest.Response `json:"-"` @@ -117,6 +105,18 @@ func (client ContainerGroupListResult) ContainerGroupListResultPreparer() (*http autorest.WithBaseURL(to.String(client.NextLink))) } +// ContainerGroupProperties is +type ContainerGroupProperties struct { + ProvisioningState *string `json:"provisioningState,omitempty"` + Containers *[]Container `json:"containers,omitempty"` + ImageRegistryCredentials *[]ImageRegistryCredential `json:"imageRegistryCredentials,omitempty"` + RestartPolicy ContainerRestartPolicy `json:"restartPolicy,omitempty"` + IPAddress *IPAddress `json:"ipAddress,omitempty"` + OsType OperatingSystemTypes `json:"osType,omitempty"` + State *string `json:"state,omitempty"` + Volumes *[]Volume `json:"volumes,omitempty"` +} + // ContainerPort is the port exposed on the container instance. type ContainerPort struct { Port *int32 `json:"port,omitempty"` diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/containerinstance/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/containerinstance/version.go index 86834aed5bee..e8c5807ce4b4 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/containerinstance/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/containerinstance/version.go @@ -19,10 +19,10 @@ package containerinstance // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-containerinstance/2017-08-01-preview" + return "Azure-SDK-For-Go/v11.1.1-beta arm-containerinstance/2017-08-01-preview" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/containerregistry/operations.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/containerregistry/operations.go index a9143e739664..5a5aa26f42c3 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/containerregistry/operations.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/containerregistry/operations.go @@ -79,7 +79,9 @@ func (client OperationsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client OperationsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/containerregistry/registries.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/containerregistry/registries.go index c1c9af59e838..955b6ae1c439 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/containerregistry/registries.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/containerregistry/registries.go @@ -100,7 +100,9 @@ func (client RegistriesClient) CheckNameAvailabilityPreparer(registryNameCheckRe // CheckNameAvailabilitySender sends the CheckNameAvailability request. The method will close the // http.Response Body if it receives an error. func (client RegistriesClient) CheckNameAvailabilitySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CheckNameAvailabilityResponder handles the response to the CheckNameAvailability request. The method always @@ -202,6 +204,7 @@ func (client RegistriesClient) CreatePreparer(resourceGroupName string, registry func (client RegistriesClient) CreateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -295,6 +298,7 @@ func (client RegistriesClient) DeletePreparer(resourceGroupName string, registry func (client RegistriesClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -368,7 +372,9 @@ func (client RegistriesClient) GetPreparer(resourceGroupName string, registryNam // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client RegistriesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -429,7 +435,9 @@ func (client RegistriesClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client RegistriesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -562,7 +570,9 @@ func (client RegistriesClient) ListByResourceGroupPreparer(resourceGroupName str // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client RegistriesClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -705,7 +715,9 @@ func (client RegistriesClient) ListCredentialsPreparer(resourceGroupName string, // ListCredentialsSender sends the ListCredentials request. The method will close the // http.Response Body if it receives an error. func (client RegistriesClient) ListCredentialsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListCredentialsResponder handles the response to the ListCredentials request. The method always @@ -779,7 +791,9 @@ func (client RegistriesClient) ListUsagesPreparer(resourceGroupName string, regi // ListUsagesSender sends the ListUsages request. The method will close the // http.Response Body if it receives an error. func (client RegistriesClient) ListUsagesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListUsagesResponder handles the response to the ListUsages request. The method always @@ -856,7 +870,9 @@ func (client RegistriesClient) RegenerateCredentialPreparer(resourceGroupName st // RegenerateCredentialSender sends the RegenerateCredential request. The method will close the // http.Response Body if it receives an error. func (client RegistriesClient) RegenerateCredentialSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RegenerateCredentialResponder handles the response to the RegenerateCredential request. The method always @@ -952,6 +968,7 @@ func (client RegistriesClient) UpdatePreparer(resourceGroupName string, registry func (client RegistriesClient) UpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/containerregistry/replications.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/containerregistry/replications.go index 79fce2d21ee8..5b82038ef1d7 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/containerregistry/replications.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/containerregistry/replications.go @@ -125,6 +125,7 @@ func (client ReplicationsClient) CreatePreparer(resourceGroupName string, regist func (client ReplicationsClient) CreateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -224,6 +225,7 @@ func (client ReplicationsClient) DeletePreparer(resourceGroupName string, regist func (client ReplicationsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -302,7 +304,9 @@ func (client ReplicationsClient) GetPreparer(resourceGroupName string, registryN // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ReplicationsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -376,7 +380,9 @@ func (client ReplicationsClient) ListPreparer(resourceGroupName string, registry // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ReplicationsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -547,6 +553,7 @@ func (client ReplicationsClient) UpdatePreparer(resourceGroupName string, regist func (client ReplicationsClient) UpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/containerregistry/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/containerregistry/version.go index 6e3ee863831d..64b4c2bbc18d 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/containerregistry/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/containerregistry/version.go @@ -19,10 +19,10 @@ package containerregistry // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.1.0-beta arm-containerregistry/2017-10-01" + return "Azure-SDK-For-Go/v11.1.1-beta arm-containerregistry/2017-10-01" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.1.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/containerregistry/webhooks.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/containerregistry/webhooks.go index ff5f9ce7844d..e61ce83a9739 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/containerregistry/webhooks.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/containerregistry/webhooks.go @@ -131,6 +131,7 @@ func (client WebhooksClient) CreatePreparer(resourceGroupName string, registryNa func (client WebhooksClient) CreateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -229,6 +230,7 @@ func (client WebhooksClient) DeletePreparer(resourceGroupName string, registryNa func (client WebhooksClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -307,7 +309,9 @@ func (client WebhooksClient) GetPreparer(resourceGroupName string, registryName // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client WebhooksClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -386,7 +390,9 @@ func (client WebhooksClient) GetCallbackConfigPreparer(resourceGroupName string, // GetCallbackConfigSender sends the GetCallbackConfig request. The method will close the // http.Response Body if it receives an error. func (client WebhooksClient) GetCallbackConfigSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetCallbackConfigResponder handles the response to the GetCallbackConfig request. The method always @@ -460,7 +466,9 @@ func (client WebhooksClient) ListPreparer(resourceGroupName string, registryName // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client WebhooksClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -608,7 +616,9 @@ func (client WebhooksClient) ListEventsPreparer(resourceGroupName string, regist // ListEventsSender sends the ListEvents request. The method will close the // http.Response Body if it receives an error. func (client WebhooksClient) ListEventsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListEventsResponder handles the response to the ListEvents request. The method always @@ -756,7 +766,9 @@ func (client WebhooksClient) PingPreparer(resourceGroupName string, registryName // PingSender sends the Ping request. The method will close the // http.Response Body if it receives an error. func (client WebhooksClient) PingSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // PingResponder handles the response to the Ping request. The method always @@ -858,6 +870,7 @@ func (client WebhooksClient) UpdatePreparer(resourceGroupName string, registryNa func (client WebhooksClient) UpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/containerservice/containerservices.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/containerservice/containerservices.go index e5c67e5f5033..5fa5c80d5d55 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/containerservice/containerservices.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/containerservice/containerservices.go @@ -144,6 +144,7 @@ func (client ContainerServicesClient) CreateOrUpdatePreparer(resourceGroupName s func (client ContainerServicesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -229,6 +230,7 @@ func (client ContainerServicesClient) DeletePreparer(resourceGroupName string, c func (client ContainerServicesClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -296,7 +298,9 @@ func (client ContainerServicesClient) GetPreparer(resourceGroupName string, cont // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ContainerServicesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -358,7 +362,9 @@ func (client ContainerServicesClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ContainerServicesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -493,7 +499,9 @@ func (client ContainerServicesClient) ListByResourceGroupPreparer(resourceGroupN // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client ContainerServicesClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/containerservice/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/containerservice/version.go index d926c410ad5b..6968ce807972 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/containerservice/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/containerservice/version.go @@ -19,10 +19,10 @@ package containerservice // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-containerservice/2017-01-31" + return "Azure-SDK-For-Go/v11.1.1-beta arm-containerservice/2017-01-31" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/cosmos-db/databaseaccounts.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/cosmos-db/databaseaccounts.go index 8bbfc52caef5..a7119a0191c5 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/cosmos-db/databaseaccounts.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/cosmos-db/databaseaccounts.go @@ -94,7 +94,9 @@ func (client DatabaseAccountsClient) CheckNameExistsPreparer(accountName string) // CheckNameExistsSender sends the CheckNameExists request. The method will close the // http.Response Body if it receives an error. func (client DatabaseAccountsClient) CheckNameExistsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // CheckNameExistsResponder handles the response to the CheckNameExists request. The method always @@ -207,6 +209,7 @@ func (client DatabaseAccountsClient) CreateOrUpdatePreparer(resourceGroupName st func (client DatabaseAccountsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -303,6 +306,7 @@ func (client DatabaseAccountsClient) DeletePreparer(resourceGroupName string, ac func (client DatabaseAccountsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -403,6 +407,7 @@ func (client DatabaseAccountsClient) FailoverPriorityChangePreparer(resourceGrou func (client DatabaseAccountsClient) FailoverPriorityChangeSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -478,7 +483,9 @@ func (client DatabaseAccountsClient) GetPreparer(resourceGroupName string, accou // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client DatabaseAccountsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -539,7 +546,9 @@ func (client DatabaseAccountsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client DatabaseAccountsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -611,7 +620,9 @@ func (client DatabaseAccountsClient) ListByResourceGroupPreparer(resourceGroupNa // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client DatabaseAccountsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -687,7 +698,9 @@ func (client DatabaseAccountsClient) ListConnectionStringsPreparer(resourceGroup // ListConnectionStringsSender sends the ListConnectionStrings request. The method will close the // http.Response Body if it receives an error. func (client DatabaseAccountsClient) ListConnectionStringsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListConnectionStringsResponder handles the response to the ListConnectionStrings request. The method always @@ -763,7 +776,9 @@ func (client DatabaseAccountsClient) ListKeysPreparer(resourceGroupName string, // ListKeysSender sends the ListKeys request. The method will close the // http.Response Body if it receives an error. func (client DatabaseAccountsClient) ListKeysSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListKeysResponder handles the response to the ListKeys request. The method always @@ -839,7 +854,9 @@ func (client DatabaseAccountsClient) ListReadOnlyKeysPreparer(resourceGroupName // ListReadOnlyKeysSender sends the ListReadOnlyKeys request. The method will close the // http.Response Body if it receives an error. func (client DatabaseAccountsClient) ListReadOnlyKeysSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListReadOnlyKeysResponder handles the response to the ListReadOnlyKeys request. The method always @@ -938,6 +955,7 @@ func (client DatabaseAccountsClient) PatchPreparer(resourceGroupName string, acc func (client DatabaseAccountsClient) PatchSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1037,6 +1055,7 @@ func (client DatabaseAccountsClient) RegenerateKeyPreparer(resourceGroupName str func (client DatabaseAccountsClient) RegenerateKeySender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/cosmos-db/operations.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/cosmos-db/operations.go index 305a47122832..c119ca695815 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/cosmos-db/operations.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/cosmos-db/operations.go @@ -79,7 +79,9 @@ func (client OperationsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client OperationsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/cosmos-db/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/cosmos-db/version.go index fa55b1042731..3638bdebba16 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/cosmos-db/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/cosmos-db/version.go @@ -19,10 +19,10 @@ package cosmosdb // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-cosmosdb/2015-04-08" + return "Azure-SDK-For-Go/v11.1.1-beta arm-cosmosdb/2015-04-08" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/dns/recordsets.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/dns/recordsets.go index 8d59929f7a63..1eb779cc97bc 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/dns/recordsets.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/dns/recordsets.go @@ -105,7 +105,9 @@ func (client RecordSetsClient) CreateOrUpdatePreparer(resourceGroupName string, // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client RecordSetsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -180,7 +182,9 @@ func (client RecordSetsClient) DeletePreparer(resourceGroupName string, zoneName // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client RecordSetsClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -248,7 +252,9 @@ func (client RecordSetsClient) GetPreparer(resourceGroupName string, zoneName st // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client RecordSetsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -323,7 +329,9 @@ func (client RecordSetsClient) ListByDNSZonePreparer(resourceGroupName string, z // ListByDNSZoneSender sends the ListByDNSZone request. The method will close the // http.Response Body if it receives an error. func (client RecordSetsClient) ListByDNSZoneSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByDNSZoneResponder handles the response to the ListByDNSZone request. The method always @@ -468,7 +476,9 @@ func (client RecordSetsClient) ListByTypePreparer(resourceGroupName string, zone // ListByTypeSender sends the ListByType request. The method will close the // http.Response Body if it receives an error. func (client RecordSetsClient) ListByTypeSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByTypeResponder handles the response to the ListByType request. The method always @@ -614,7 +624,9 @@ func (client RecordSetsClient) UpdatePreparer(resourceGroupName string, zoneName // UpdateSender sends the Update request. The method will close the // http.Response Body if it receives an error. func (client RecordSetsClient) UpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateResponder handles the response to the Update request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/dns/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/dns/version.go index d5ade9afd6fa..d757f944a38f 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/dns/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/dns/version.go @@ -19,10 +19,10 @@ package dns // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-dns/2016-04-01" + return "Azure-SDK-For-Go/v11.1.1-beta arm-dns/2016-04-01" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/dns/zones.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/dns/zones.go index 33b230b03ae5..644ecfd0d590 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/dns/zones.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/dns/zones.go @@ -101,7 +101,9 @@ func (client ZonesClient) CreateOrUpdatePreparer(resourceGroupName string, zoneN // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client ZonesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -189,6 +191,7 @@ func (client ZonesClient) DeletePreparer(resourceGroupName string, zoneName stri func (client ZonesClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -255,7 +258,9 @@ func (client ZonesClient) GetPreparer(resourceGroupName string, zoneName string) // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ZonesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -321,7 +326,9 @@ func (client ZonesClient) ListPreparer(top *int32) (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ZonesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -458,7 +465,9 @@ func (client ZonesClient) ListByResourceGroupPreparer(resourceGroupName string, // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client ZonesClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/eventgrid/eventsubscriptions.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/eventgrid/eventsubscriptions.go index 5f7152014f50..e374aaf6d8e6 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/eventgrid/eventsubscriptions.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/eventgrid/eventsubscriptions.go @@ -115,6 +115,7 @@ func (client EventSubscriptionsClient) CreatePreparer(scope string, eventSubscri func (client EventSubscriptionsClient) CreateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -202,6 +203,7 @@ func (client EventSubscriptionsClient) DeletePreparer(scope string, eventSubscri func (client EventSubscriptionsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -272,7 +274,9 @@ func (client EventSubscriptionsClient) GetPreparer(scope string, eventSubscripti // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client EventSubscriptionsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetResponder handles the response to the Get request. The method always @@ -343,7 +347,9 @@ func (client EventSubscriptionsClient) GetFullURLPreparer(scope string, eventSub // GetFullURLSender sends the GetFullURL request. The method will close the // http.Response Body if it receives an error. func (client EventSubscriptionsClient) GetFullURLSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetFullURLResponder handles the response to the GetFullURL request. The method always @@ -411,7 +417,9 @@ func (client EventSubscriptionsClient) ListByResourcePreparer(resourceGroupName // ListByResourceSender sends the ListByResource request. The method will close the // http.Response Body if it receives an error. func (client EventSubscriptionsClient) ListByResourceSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceResponder handles the response to the ListByResource request. The method always @@ -475,7 +483,9 @@ func (client EventSubscriptionsClient) ListGlobalByResourceGroupPreparer(resourc // ListGlobalByResourceGroupSender sends the ListGlobalByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client EventSubscriptionsClient) ListGlobalByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListGlobalByResourceGroupResponder handles the response to the ListGlobalByResourceGroup request. The method always @@ -542,7 +552,9 @@ func (client EventSubscriptionsClient) ListGlobalByResourceGroupForTopicTypePrep // ListGlobalByResourceGroupForTopicTypeSender sends the ListGlobalByResourceGroupForTopicType request. The method will close the // http.Response Body if it receives an error. func (client EventSubscriptionsClient) ListGlobalByResourceGroupForTopicTypeSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListGlobalByResourceGroupForTopicTypeResponder handles the response to the ListGlobalByResourceGroupForTopicType request. The method always @@ -603,7 +615,9 @@ func (client EventSubscriptionsClient) ListGlobalBySubscriptionPreparer() (*http // ListGlobalBySubscriptionSender sends the ListGlobalBySubscription request. The method will close the // http.Response Body if it receives an error. func (client EventSubscriptionsClient) ListGlobalBySubscriptionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListGlobalBySubscriptionResponder handles the response to the ListGlobalBySubscription request. The method always @@ -668,7 +682,9 @@ func (client EventSubscriptionsClient) ListGlobalBySubscriptionForTopicTypePrepa // ListGlobalBySubscriptionForTopicTypeSender sends the ListGlobalBySubscriptionForTopicType request. The method will close the // http.Response Body if it receives an error. func (client EventSubscriptionsClient) ListGlobalBySubscriptionForTopicTypeSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListGlobalBySubscriptionForTopicTypeResponder handles the response to the ListGlobalBySubscriptionForTopicType request. The method always @@ -734,7 +750,9 @@ func (client EventSubscriptionsClient) ListRegionalByResourceGroupPreparer(resou // ListRegionalByResourceGroupSender sends the ListRegionalByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client EventSubscriptionsClient) ListRegionalByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListRegionalByResourceGroupResponder handles the response to the ListRegionalByResourceGroup request. The method always @@ -802,7 +820,9 @@ func (client EventSubscriptionsClient) ListRegionalByResourceGroupForTopicTypePr // ListRegionalByResourceGroupForTopicTypeSender sends the ListRegionalByResourceGroupForTopicType request. The method will close the // http.Response Body if it receives an error. func (client EventSubscriptionsClient) ListRegionalByResourceGroupForTopicTypeSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListRegionalByResourceGroupForTopicTypeResponder handles the response to the ListRegionalByResourceGroupForTopicType request. The method always @@ -866,7 +886,9 @@ func (client EventSubscriptionsClient) ListRegionalBySubscriptionPreparer(locati // ListRegionalBySubscriptionSender sends the ListRegionalBySubscription request. The method will close the // http.Response Body if it receives an error. func (client EventSubscriptionsClient) ListRegionalBySubscriptionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListRegionalBySubscriptionResponder handles the response to the ListRegionalBySubscription request. The method always @@ -932,7 +954,9 @@ func (client EventSubscriptionsClient) ListRegionalBySubscriptionForTopicTypePre // ListRegionalBySubscriptionForTopicTypeSender sends the ListRegionalBySubscriptionForTopicType request. The method will close the // http.Response Body if it receives an error. func (client EventSubscriptionsClient) ListRegionalBySubscriptionForTopicTypeSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListRegionalBySubscriptionForTopicTypeResponder handles the response to the ListRegionalBySubscriptionForTopicType request. The method always @@ -1023,6 +1047,7 @@ func (client EventSubscriptionsClient) UpdatePreparer(scope string, eventSubscri func (client EventSubscriptionsClient) UpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/eventgrid/operations.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/eventgrid/operations.go index 915992d07cc6..1cd0f53aba75 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/eventgrid/operations.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/eventgrid/operations.go @@ -79,7 +79,9 @@ func (client OperationsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client OperationsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/eventgrid/topics.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/eventgrid/topics.go index 8e3920bc7b8e..75c7cabd56a4 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/eventgrid/topics.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/eventgrid/topics.go @@ -108,6 +108,7 @@ func (client TopicsClient) CreateOrUpdatePreparer(resourceGroupName string, topi func (client TopicsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -189,6 +190,7 @@ func (client TopicsClient) DeletePreparer(resourceGroupName string, topicName st func (client TopicsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -253,7 +255,9 @@ func (client TopicsClient) GetPreparer(resourceGroupName string, topicName strin // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client TopicsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -317,7 +321,9 @@ func (client TopicsClient) ListByResourceGroupPreparer(resourceGroupName string) // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client TopicsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -378,7 +384,9 @@ func (client TopicsClient) ListBySubscriptionPreparer() (*http.Request, error) { // ListBySubscriptionSender sends the ListBySubscription request. The method will close the // http.Response Body if it receives an error. func (client TopicsClient) ListBySubscriptionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListBySubscriptionResponder handles the response to the ListBySubscription request. The method always @@ -446,7 +454,9 @@ func (client TopicsClient) ListEventTypesPreparer(resourceGroupName string, prov // ListEventTypesSender sends the ListEventTypes request. The method will close the // http.Response Body if it receives an error. func (client TopicsClient) ListEventTypesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListEventTypesResponder handles the response to the ListEventTypes request. The method always @@ -511,7 +521,9 @@ func (client TopicsClient) ListSharedAccessKeysPreparer(resourceGroupName string // ListSharedAccessKeysSender sends the ListSharedAccessKeys request. The method will close the // http.Response Body if it receives an error. func (client TopicsClient) ListSharedAccessKeysSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListSharedAccessKeysResponder handles the response to the ListSharedAccessKeys request. The method always @@ -585,7 +597,9 @@ func (client TopicsClient) RegenerateKeyPreparer(resourceGroupName string, topic // RegenerateKeySender sends the RegenerateKey request. The method will close the // http.Response Body if it receives an error. func (client TopicsClient) RegenerateKeySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RegenerateKeyResponder handles the response to the RegenerateKey request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/eventgrid/topictypes.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/eventgrid/topictypes.go index 3f4e39990fe9..057d5204628b 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/eventgrid/topictypes.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/eventgrid/topictypes.go @@ -85,7 +85,9 @@ func (client TopicTypesClient) GetPreparer(topicTypeName string) (*http.Request, // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client TopicTypesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetResponder handles the response to the Get request. The method always @@ -142,7 +144,9 @@ func (client TopicTypesClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client TopicTypesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListResponder handles the response to the List request. The method always @@ -205,7 +209,9 @@ func (client TopicTypesClient) ListEventTypesPreparer(topicTypeName string) (*ht // ListEventTypesSender sends the ListEventTypes request. The method will close the // http.Response Body if it receives an error. func (client TopicTypesClient) ListEventTypesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListEventTypesResponder handles the response to the ListEventTypes request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/eventgrid/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/eventgrid/version.go index 741dabd27ead..1b11e9193f1f 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/eventgrid/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/eventgrid/version.go @@ -19,10 +19,10 @@ package eventgrid // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-eventgrid/2017-09-15-preview" + return "Azure-SDK-For-Go/v11.1.1-beta arm-eventgrid/2017-09-15-preview" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/eventhub/consumergroups.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/eventhub/consumergroups.go index eebbc20c9f16..54395c8327bd 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/eventhub/consumergroups.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/eventhub/consumergroups.go @@ -108,7 +108,9 @@ func (client ConsumerGroupsClient) CreateOrUpdatePreparer(resourceGroupName stri // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client ConsumerGroupsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -190,7 +192,9 @@ func (client ConsumerGroupsClient) DeletePreparer(resourceGroupName string, name // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client ConsumerGroupsClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -271,7 +275,9 @@ func (client ConsumerGroupsClient) GetPreparer(resourceGroupName string, namespa // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ConsumerGroupsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -351,7 +357,9 @@ func (client ConsumerGroupsClient) ListByEventHubPreparer(resourceGroupName stri // ListByEventHubSender sends the ListByEventHub request. The method will close the // http.Response Body if it receives an error. func (client ConsumerGroupsClient) ListByEventHubSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByEventHubResponder handles the response to the ListByEventHub request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/eventhub/eventhubs.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/eventhub/eventhubs.go index c0236fe5490f..b0e82ebf5fa7 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/eventhub/eventhubs.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/eventhub/eventhubs.go @@ -125,7 +125,9 @@ func (client EventHubsClient) CreateOrUpdatePreparer(resourceGroupName string, n // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client EventHubsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -210,7 +212,9 @@ func (client EventHubsClient) CreateOrUpdateAuthorizationRulePreparer(resourceGr // CreateOrUpdateAuthorizationRuleSender sends the CreateOrUpdateAuthorizationRule request. The method will close the // http.Response Body if it receives an error. func (client EventHubsClient) CreateOrUpdateAuthorizationRuleSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateAuthorizationRuleResponder handles the response to the CreateOrUpdateAuthorizationRule request. The method always @@ -289,7 +293,9 @@ func (client EventHubsClient) DeletePreparer(resourceGroupName string, namespace // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client EventHubsClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -370,7 +376,9 @@ func (client EventHubsClient) DeleteAuthorizationRulePreparer(resourceGroupName // DeleteAuthorizationRuleSender sends the DeleteAuthorizationRule request. The method will close the // http.Response Body if it receives an error. func (client EventHubsClient) DeleteAuthorizationRuleSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteAuthorizationRuleResponder handles the response to the DeleteAuthorizationRule request. The method always @@ -448,7 +456,9 @@ func (client EventHubsClient) GetPreparer(resourceGroupName string, namespaceNam // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client EventHubsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -530,7 +540,9 @@ func (client EventHubsClient) GetAuthorizationRulePreparer(resourceGroupName str // GetAuthorizationRuleSender sends the GetAuthorizationRule request. The method will close the // http.Response Body if it receives an error. func (client EventHubsClient) GetAuthorizationRuleSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetAuthorizationRuleResponder handles the response to the GetAuthorizationRule request. The method always @@ -609,7 +621,9 @@ func (client EventHubsClient) ListAuthorizationRulesPreparer(resourceGroupName s // ListAuthorizationRulesSender sends the ListAuthorizationRules request. The method will close the // http.Response Body if it receives an error. func (client EventHubsClient) ListAuthorizationRulesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAuthorizationRulesResponder handles the response to the ListAuthorizationRules request. The method always @@ -753,7 +767,9 @@ func (client EventHubsClient) ListByNamespacePreparer(resourceGroupName string, // ListByNamespaceSender sends the ListByNamespace request. The method will close the // http.Response Body if it receives an error. func (client EventHubsClient) ListByNamespaceSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByNamespaceResponder handles the response to the ListByNamespace request. The method always @@ -904,7 +920,9 @@ func (client EventHubsClient) ListKeysPreparer(resourceGroupName string, namespa // ListKeysSender sends the ListKeys request. The method will close the // http.Response Body if it receives an error. func (client EventHubsClient) ListKeysSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListKeysResponder handles the response to the ListKeys request. The method always @@ -989,7 +1007,9 @@ func (client EventHubsClient) RegenerateKeysPreparer(resourceGroupName string, n // RegenerateKeysSender sends the RegenerateKeys request. The method will close the // http.Response Body if it receives an error. func (client EventHubsClient) RegenerateKeysSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RegenerateKeysResponder handles the response to the RegenerateKeys request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/eventhub/models.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/eventhub/models.go index afef330a050e..c43045d8c690 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/eventhub/models.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/eventhub/models.go @@ -138,11 +138,6 @@ type AuthorizationRule struct { *AuthorizationRuleProperties `json:"properties,omitempty"` } -// AuthorizationRuleProperties is properties supplied to create or update AuthorizationRule -type AuthorizationRuleProperties struct { - Rights *[]AccessRights `json:"rights,omitempty"` -} - // AuthorizationRuleListResult is the response from the List namespace operation. type AuthorizationRuleListResult struct { autorest.Response `json:"-"` @@ -162,6 +157,11 @@ func (client AuthorizationRuleListResult) AuthorizationRuleListResultPreparer() autorest.WithBaseURL(to.String(client.NextLink))) } +// AuthorizationRuleProperties is properties supplied to create or update AuthorizationRule +type AuthorizationRuleProperties struct { + Rights *[]AccessRights `json:"rights,omitempty"` +} + // CaptureDescription is properties to configure capture description for eventhub type CaptureDescription struct { Enabled *bool `json:"enabled,omitempty"` @@ -193,13 +193,6 @@ type ConsumerGroup struct { *ConsumerGroupProperties `json:"properties,omitempty"` } -// ConsumerGroupProperties is single item in List or Get Consumer group operation -type ConsumerGroupProperties struct { - CreatedAt *date.Time `json:"createdAt,omitempty"` - UpdatedAt *date.Time `json:"updatedAt,omitempty"` - UserMetadata *string `json:"userMetadata,omitempty"` -} - // ConsumerGroupListResult is the result to the List Consumer Group operation. type ConsumerGroupListResult struct { autorest.Response `json:"-"` @@ -219,6 +212,13 @@ func (client ConsumerGroupListResult) ConsumerGroupListResultPreparer() (*http.R autorest.WithBaseURL(to.String(client.NextLink))) } +// ConsumerGroupProperties is single item in List or Get Consumer group operation +type ConsumerGroupProperties struct { + CreatedAt *date.Time `json:"createdAt,omitempty"` + UpdatedAt *date.Time `json:"updatedAt,omitempty"` + UserMetadata *string `json:"userMetadata,omitempty"` +} + // Destination is capture storage details for capture description type Destination struct { Name *string `json:"name,omitempty"` @@ -245,17 +245,6 @@ type EHNamespace struct { *EHNamespaceProperties `json:"properties,omitempty"` } -// EHNamespaceProperties is namespace properties supplied for create namespace operation. -type EHNamespaceProperties struct { - ProvisioningState *string `json:"provisioningState,omitempty"` - CreatedAt *date.Time `json:"createdAt,omitempty"` - UpdatedAt *date.Time `json:"updatedAt,omitempty"` - ServiceBusEndpoint *string `json:"serviceBusEndpoint,omitempty"` - MetricID *string `json:"metricId,omitempty"` - IsAutoInflateEnabled *bool `json:"isAutoInflateEnabled,omitempty"` - MaximumThroughputUnits *int32 `json:"maximumThroughputUnits,omitempty"` -} - // EHNamespaceListResult is the response of the List Namespace operation type EHNamespaceListResult struct { autorest.Response `json:"-"` @@ -275,6 +264,17 @@ func (client EHNamespaceListResult) EHNamespaceListResultPreparer() (*http.Reque autorest.WithBaseURL(to.String(client.NextLink))) } +// EHNamespaceProperties is namespace properties supplied for create namespace operation. +type EHNamespaceProperties struct { + ProvisioningState *string `json:"provisioningState,omitempty"` + CreatedAt *date.Time `json:"createdAt,omitempty"` + UpdatedAt *date.Time `json:"updatedAt,omitempty"` + ServiceBusEndpoint *string `json:"serviceBusEndpoint,omitempty"` + MetricID *string `json:"metricId,omitempty"` + IsAutoInflateEnabled *bool `json:"isAutoInflateEnabled,omitempty"` + MaximumThroughputUnits *int32 `json:"maximumThroughputUnits,omitempty"` +} + // ErrorResponse is error reponse indicates EventHub service is not able to process the incoming request. The reason is // provided in the error message. type ErrorResponse struct { diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/eventhub/namespaces.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/eventhub/namespaces.go index 90a80c39c9f1..7edec361c58c 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/eventhub/namespaces.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/eventhub/namespaces.go @@ -94,7 +94,9 @@ func (client NamespacesClient) CheckNameAvailabilityPreparer(parameters CheckNam // CheckNameAvailabilitySender sends the CheckNameAvailability request. The method will close the // http.Response Body if it receives an error. func (client NamespacesClient) CheckNameAvailabilitySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CheckNameAvailabilityResponder handles the response to the CheckNameAvailability request. The method always @@ -205,6 +207,7 @@ func (client NamespacesClient) CreateOrUpdatePreparer(resourceGroupName string, func (client NamespacesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -286,7 +289,9 @@ func (client NamespacesClient) CreateOrUpdateAuthorizationRulePreparer(resourceG // CreateOrUpdateAuthorizationRuleSender sends the CreateOrUpdateAuthorizationRule request. The method will close the // http.Response Body if it receives an error. func (client NamespacesClient) CreateOrUpdateAuthorizationRuleSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateAuthorizationRuleResponder handles the response to the CreateOrUpdateAuthorizationRule request. The method always @@ -381,6 +386,7 @@ func (client NamespacesClient) DeletePreparer(resourceGroupName string, namespac func (client NamespacesClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -459,7 +465,9 @@ func (client NamespacesClient) DeleteAuthorizationRulePreparer(resourceGroupName // DeleteAuthorizationRuleSender sends the DeleteAuthorizationRule request. The method will close the // http.Response Body if it receives an error. func (client NamespacesClient) DeleteAuthorizationRuleSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteAuthorizationRuleResponder handles the response to the DeleteAuthorizationRule request. The method always @@ -533,7 +541,9 @@ func (client NamespacesClient) GetPreparer(resourceGroupName string, namespaceNa // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client NamespacesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -612,7 +622,9 @@ func (client NamespacesClient) GetAuthorizationRulePreparer(resourceGroupName st // GetAuthorizationRuleSender sends the GetAuthorizationRule request. The method will close the // http.Response Body if it receives an error. func (client NamespacesClient) GetAuthorizationRuleSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetAuthorizationRuleResponder handles the response to the GetAuthorizationRule request. The method always @@ -673,7 +685,9 @@ func (client NamespacesClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client NamespacesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -817,7 +831,9 @@ func (client NamespacesClient) ListAuthorizationRulesPreparer(resourceGroupName // ListAuthorizationRulesSender sends the ListAuthorizationRules request. The method will close the // http.Response Body if it receives an error. func (client NamespacesClient) ListAuthorizationRulesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAuthorizationRulesResponder handles the response to the ListAuthorizationRules request. The method always @@ -957,7 +973,9 @@ func (client NamespacesClient) ListByResourceGroupPreparer(resourceGroupName str // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client NamespacesClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -1105,7 +1123,9 @@ func (client NamespacesClient) ListKeysPreparer(resourceGroupName string, namesp // ListKeysSender sends the ListKeys request. The method will close the // http.Response Body if it receives an error. func (client NamespacesClient) ListKeysSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListKeysResponder handles the response to the ListKeys request. The method always @@ -1187,7 +1207,9 @@ func (client NamespacesClient) RegenerateKeysPreparer(resourceGroupName string, // RegenerateKeysSender sends the RegenerateKeys request. The method will close the // http.Response Body if it receives an error. func (client NamespacesClient) RegenerateKeysSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RegenerateKeysResponder handles the response to the RegenerateKeys request. The method always @@ -1266,7 +1288,9 @@ func (client NamespacesClient) UpdatePreparer(resourceGroupName string, namespac // UpdateSender sends the Update request. The method will close the // http.Response Body if it receives an error. func (client NamespacesClient) UpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateResponder handles the response to the Update request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/eventhub/operations.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/eventhub/operations.go index 6f3ea2c8a920..c10c9218be88 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/eventhub/operations.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/eventhub/operations.go @@ -79,7 +79,9 @@ func (client OperationsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client OperationsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/eventhub/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/eventhub/version.go index 45040aed7bc0..3c81d51224a0 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/eventhub/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/eventhub/version.go @@ -19,10 +19,10 @@ package eventhub // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-eventhub/2017-04-01" + return "Azure-SDK-For-Go/v11.1.1-beta arm-eventhub/2017-04-01" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/applications.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/applications.go index 7c43c4a20380..a01081da6a42 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/applications.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/applications.go @@ -96,7 +96,9 @@ func (client ApplicationsClient) CreatePreparer(parameters ApplicationCreatePara // CreateSender sends the Create request. The method will close the // http.Response Body if it receives an error. func (client ApplicationsClient) CreateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // CreateResponder handles the response to the Create request. The method always @@ -160,7 +162,9 @@ func (client ApplicationsClient) DeletePreparer(applicationObjectID string) (*ht // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client ApplicationsClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // DeleteResponder handles the response to the Delete request. The method always @@ -223,7 +227,9 @@ func (client ApplicationsClient) GetPreparer(applicationObjectID string) (*http. // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ApplicationsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetResponder handles the response to the Get request. The method always @@ -289,7 +295,9 @@ func (client ApplicationsClient) ListPreparer(filter string) (*http.Request, err // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ApplicationsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListResponder handles the response to the List request. The method always @@ -398,7 +406,9 @@ func (client ApplicationsClient) ListKeyCredentialsPreparer(applicationObjectID // ListKeyCredentialsSender sends the ListKeyCredentials request. The method will close the // http.Response Body if it receives an error. func (client ApplicationsClient) ListKeyCredentialsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListKeyCredentialsResponder handles the response to the ListKeyCredentials request. The method always @@ -462,7 +472,9 @@ func (client ApplicationsClient) ListNextPreparer(nextLink string) (*http.Reques // ListNextSender sends the ListNext request. The method will close the // http.Response Body if it receives an error. func (client ApplicationsClient) ListNextSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListNextResponder handles the response to the ListNext request. The method always @@ -526,7 +538,9 @@ func (client ApplicationsClient) ListPasswordCredentialsPreparer(applicationObje // ListPasswordCredentialsSender sends the ListPasswordCredentials request. The method will close the // http.Response Body if it receives an error. func (client ApplicationsClient) ListPasswordCredentialsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListPasswordCredentialsResponder handles the response to the ListPasswordCredentials request. The method always @@ -592,7 +606,9 @@ func (client ApplicationsClient) PatchPreparer(applicationObjectID string, param // PatchSender sends the Patch request. The method will close the // http.Response Body if it receives an error. func (client ApplicationsClient) PatchSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // PatchResponder handles the response to the Patch request. The method always @@ -658,7 +674,9 @@ func (client ApplicationsClient) UpdateKeyCredentialsPreparer(applicationObjectI // UpdateKeyCredentialsSender sends the UpdateKeyCredentials request. The method will close the // http.Response Body if it receives an error. func (client ApplicationsClient) UpdateKeyCredentialsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // UpdateKeyCredentialsResponder handles the response to the UpdateKeyCredentials request. The method always @@ -724,7 +742,9 @@ func (client ApplicationsClient) UpdatePasswordCredentialsPreparer(applicationOb // UpdatePasswordCredentialsSender sends the UpdatePasswordCredentials request. The method will close the // http.Response Body if it receives an error. func (client ApplicationsClient) UpdatePasswordCredentialsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // UpdatePasswordCredentialsResponder handles the response to the UpdatePasswordCredentials request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/domains.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/domains.go index 78a34dcc76a1..a515dbc88b71 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/domains.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/domains.go @@ -86,7 +86,9 @@ func (client DomainsClient) GetPreparer(domainName string) (*http.Request, error // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client DomainsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetResponder handles the response to the Get request. The method always @@ -152,7 +154,9 @@ func (client DomainsClient) ListPreparer(filter string) (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client DomainsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/groups.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/groups.go index 2a450837e344..b0fba1b41dd3 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/groups.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/groups.go @@ -97,7 +97,9 @@ func (client GroupsClient) AddMemberPreparer(groupObjectID string, parameters Gr // AddMemberSender sends the AddMember request. The method will close the // http.Response Body if it receives an error. func (client GroupsClient) AddMemberSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // AddMemberResponder handles the response to the AddMember request. The method always @@ -170,7 +172,9 @@ func (client GroupsClient) CreatePreparer(parameters GroupCreateParameters) (*ht // CreateSender sends the Create request. The method will close the // http.Response Body if it receives an error. func (client GroupsClient) CreateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // CreateResponder handles the response to the Create request. The method always @@ -234,7 +238,9 @@ func (client GroupsClient) DeletePreparer(groupObjectID string) (*http.Request, // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client GroupsClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // DeleteResponder handles the response to the Delete request. The method always @@ -297,7 +303,9 @@ func (client GroupsClient) GetPreparer(objectID string) (*http.Request, error) { // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client GroupsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetResponder handles the response to the Get request. The method always @@ -361,7 +369,9 @@ func (client GroupsClient) GetGroupMembersPreparer(objectID string) (*http.Reque // GetGroupMembersSender sends the GetGroupMembers request. The method will close the // http.Response Body if it receives an error. func (client GroupsClient) GetGroupMembersSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetGroupMembersResponder handles the response to the GetGroupMembers request. The method always @@ -470,7 +480,9 @@ func (client GroupsClient) GetGroupMembersNextPreparer(nextLink string) (*http.R // GetGroupMembersNextSender sends the GetGroupMembersNext request. The method will close the // http.Response Body if it receives an error. func (client GroupsClient) GetGroupMembersNextSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetGroupMembersNextResponder handles the response to the GetGroupMembersNext request. The method always @@ -542,7 +554,9 @@ func (client GroupsClient) GetMemberGroupsPreparer(objectID string, parameters G // GetMemberGroupsSender sends the GetMemberGroups request. The method will close the // http.Response Body if it receives an error. func (client GroupsClient) GetMemberGroupsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetMemberGroupsResponder handles the response to the GetMemberGroups request. The method always @@ -615,7 +629,9 @@ func (client GroupsClient) IsMemberOfPreparer(parameters CheckGroupMembershipPar // IsMemberOfSender sends the IsMemberOf request. The method will close the // http.Response Body if it receives an error. func (client GroupsClient) IsMemberOfSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // IsMemberOfResponder handles the response to the IsMemberOf request. The method always @@ -681,7 +697,9 @@ func (client GroupsClient) ListPreparer(filter string) (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client GroupsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListResponder handles the response to the List request. The method always @@ -790,7 +808,9 @@ func (client GroupsClient) ListNextPreparer(nextLink string) (*http.Request, err // ListNextSender sends the ListNext request. The method will close the // http.Response Body if it receives an error. func (client GroupsClient) ListNextSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListNextResponder handles the response to the ListNext request. The method always @@ -855,7 +875,9 @@ func (client GroupsClient) RemoveMemberPreparer(groupObjectID string, memberObje // RemoveMemberSender sends the RemoveMember request. The method will close the // http.Response Body if it receives an error. func (client GroupsClient) RemoveMemberSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // RemoveMemberResponder handles the response to the RemoveMember request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/objects.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/objects.go index 4d6c6f1d8f58..ea317072cebb 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/objects.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/objects.go @@ -84,7 +84,9 @@ func (client ObjectsClient) GetCurrentUserPreparer() (*http.Request, error) { // GetCurrentUserSender sends the GetCurrentUser request. The method will close the // http.Response Body if it receives an error. func (client ObjectsClient) GetCurrentUserSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetCurrentUserResponder handles the response to the GetCurrentUser request. The method always @@ -155,7 +157,9 @@ func (client ObjectsClient) GetObjectsByObjectIdsPreparer(parameters GetObjectsP // GetObjectsByObjectIdsSender sends the GetObjectsByObjectIds request. The method will close the // http.Response Body if it receives an error. func (client ObjectsClient) GetObjectsByObjectIdsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetObjectsByObjectIdsResponder handles the response to the GetObjectsByObjectIds request. The method always @@ -264,7 +268,9 @@ func (client ObjectsClient) GetObjectsByObjectIdsNextPreparer(nextLink string) ( // GetObjectsByObjectIdsNextSender sends the GetObjectsByObjectIdsNext request. The method will close the // http.Response Body if it receives an error. func (client ObjectsClient) GetObjectsByObjectIdsNextSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetObjectsByObjectIdsNextResponder handles the response to the GetObjectsByObjectIdsNext request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/serviceprincipals.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/serviceprincipals.go index 215f8f96c8de..2cd549781179 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/serviceprincipals.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/serviceprincipals.go @@ -95,7 +95,9 @@ func (client ServicePrincipalsClient) CreatePreparer(parameters ServicePrincipal // CreateSender sends the Create request. The method will close the // http.Response Body if it receives an error. func (client ServicePrincipalsClient) CreateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // CreateResponder handles the response to the Create request. The method always @@ -159,7 +161,9 @@ func (client ServicePrincipalsClient) DeletePreparer(objectID string) (*http.Req // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client ServicePrincipalsClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // DeleteResponder handles the response to the Delete request. The method always @@ -222,7 +226,9 @@ func (client ServicePrincipalsClient) GetPreparer(objectID string) (*http.Reques // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ServicePrincipalsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetResponder handles the response to the Get request. The method always @@ -288,7 +294,9 @@ func (client ServicePrincipalsClient) ListPreparer(filter string) (*http.Request // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ServicePrincipalsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListResponder handles the response to the List request. The method always @@ -397,7 +405,9 @@ func (client ServicePrincipalsClient) ListKeyCredentialsPreparer(objectID string // ListKeyCredentialsSender sends the ListKeyCredentials request. The method will close the // http.Response Body if it receives an error. func (client ServicePrincipalsClient) ListKeyCredentialsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListKeyCredentialsResponder handles the response to the ListKeyCredentials request. The method always @@ -461,7 +471,9 @@ func (client ServicePrincipalsClient) ListNextPreparer(nextLink string) (*http.R // ListNextSender sends the ListNext request. The method will close the // http.Response Body if it receives an error. func (client ServicePrincipalsClient) ListNextSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListNextResponder handles the response to the ListNext request. The method always @@ -525,7 +537,9 @@ func (client ServicePrincipalsClient) ListPasswordCredentialsPreparer(objectID s // ListPasswordCredentialsSender sends the ListPasswordCredentials request. The method will close the // http.Response Body if it receives an error. func (client ServicePrincipalsClient) ListPasswordCredentialsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListPasswordCredentialsResponder handles the response to the ListPasswordCredentials request. The method always @@ -592,7 +606,9 @@ func (client ServicePrincipalsClient) UpdateKeyCredentialsPreparer(objectID stri // UpdateKeyCredentialsSender sends the UpdateKeyCredentials request. The method will close the // http.Response Body if it receives an error. func (client ServicePrincipalsClient) UpdateKeyCredentialsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // UpdateKeyCredentialsResponder handles the response to the UpdateKeyCredentials request. The method always @@ -658,7 +674,9 @@ func (client ServicePrincipalsClient) UpdatePasswordCredentialsPreparer(objectID // UpdatePasswordCredentialsSender sends the UpdatePasswordCredentials request. The method will close the // http.Response Body if it receives an error. func (client ServicePrincipalsClient) UpdatePasswordCredentialsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // UpdatePasswordCredentialsResponder handles the response to the UpdatePasswordCredentials request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/users.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/users.go index 242dc7354186..acf2fbea9fcd 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/users.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/users.go @@ -99,7 +99,9 @@ func (client UsersClient) CreatePreparer(parameters UserCreateParameters) (*http // CreateSender sends the Create request. The method will close the // http.Response Body if it receives an error. func (client UsersClient) CreateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // CreateResponder handles the response to the Create request. The method always @@ -163,7 +165,9 @@ func (client UsersClient) DeletePreparer(upnOrObjectID string) (*http.Request, e // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client UsersClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // DeleteResponder handles the response to the Delete request. The method always @@ -226,7 +230,9 @@ func (client UsersClient) GetPreparer(upnOrObjectID string) (*http.Request, erro // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client UsersClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetResponder handles the response to the Get request. The method always @@ -298,7 +304,9 @@ func (client UsersClient) GetMemberGroupsPreparer(objectID string, parameters Us // GetMemberGroupsSender sends the GetMemberGroups request. The method will close the // http.Response Body if it receives an error. func (client UsersClient) GetMemberGroupsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetMemberGroupsResponder handles the response to the GetMemberGroups request. The method always @@ -364,7 +372,9 @@ func (client UsersClient) ListPreparer(filter string) (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client UsersClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListResponder handles the response to the List request. The method always @@ -473,7 +483,9 @@ func (client UsersClient) ListNextPreparer(nextLink string) (*http.Request, erro // ListNextSender sends the ListNext request. The method will close the // http.Response Body if it receives an error. func (client UsersClient) ListNextSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListNextResponder handles the response to the ListNext request. The method always @@ -540,7 +552,9 @@ func (client UsersClient) UpdatePreparer(upnOrObjectID string, parameters UserUp // UpdateSender sends the Update request. The method will close the // http.Response Body if it receives an error. func (client UsersClient) UpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // UpdateResponder handles the response to the Update request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/version.go index 84c93105bf31..979851a48802 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/graphrbac/version.go @@ -19,10 +19,10 @@ package graphrbac // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-graphrbac/1.6" + return "Azure-SDK-For-Go/v11.1.1-beta arm-graphrbac/1.6" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/keyvault/vaults.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/keyvault/vaults.go index 47638d20626e..fb8648dd2ac6 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/keyvault/vaults.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/keyvault/vaults.go @@ -107,7 +107,9 @@ func (client VaultsClient) CreateOrUpdatePreparer(resourceGroupName string, vaul // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client VaultsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -173,7 +175,9 @@ func (client VaultsClient) DeletePreparer(resourceGroupName string, vaultName st // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client VaultsClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -237,7 +241,9 @@ func (client VaultsClient) GetPreparer(resourceGroupName string, vaultName strin // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client VaultsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -302,7 +308,9 @@ func (client VaultsClient) GetDeletedPreparer(vaultName string, location string) // GetDeletedSender sends the GetDeleted request. The method will close the // http.Response Body if it receives an error. func (client VaultsClient) GetDeletedSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetDeletedResponder handles the response to the GetDeleted request. The method always @@ -369,7 +377,9 @@ func (client VaultsClient) ListPreparer(filter string, top *int32) (*http.Reques // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client VaultsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -507,7 +517,9 @@ func (client VaultsClient) ListByResourceGroupPreparer(resourceGroupName string, // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client VaultsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -637,7 +649,9 @@ func (client VaultsClient) ListDeletedPreparer() (*http.Request, error) { // ListDeletedSender sends the ListDeleted request. The method will close the // http.Response Body if it receives an error. func (client VaultsClient) ListDeletedSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListDeletedResponder handles the response to the ListDeleted request. The method always @@ -788,6 +802,7 @@ func (client VaultsClient) PurgeDeletedPreparer(vaultName string, location strin func (client VaultsClient) PurgeDeletedSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/keyvault/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/keyvault/version.go index 64ff8541e0e5..6b0efe68e0b2 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/keyvault/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/keyvault/version.go @@ -19,10 +19,10 @@ package keyvault // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-keyvault/2016-10-01" + return "Azure-SDK-For-Go/v11.1.1-beta arm-keyvault/2016-10-01" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/configurations.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/configurations.go index 216451e62ffe..8f3f7baef1c1 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/configurations.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/configurations.go @@ -109,6 +109,7 @@ func (client ConfigurationsClient) CreateOrUpdatePreparer(resourceGroupName stri func (client ConfigurationsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -177,7 +178,9 @@ func (client ConfigurationsClient) GetPreparer(resourceGroupName string, serverN // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ConfigurationsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -243,7 +246,9 @@ func (client ConfigurationsClient) ListByServerPreparer(resourceGroupName string // ListByServerSender sends the ListByServer request. The method will close the // http.Response Body if it receives an error. func (client ConfigurationsClient) ListByServerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByServerResponder handles the response to the ListByServer request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/databases.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/databases.go index 864b6e4d1e63..9ef872605813 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/databases.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/databases.go @@ -110,6 +110,7 @@ func (client DatabasesClient) CreateOrUpdatePreparer(resourceGroupName string, s func (client DatabasesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -194,6 +195,7 @@ func (client DatabasesClient) DeletePreparer(resourceGroupName string, serverNam func (client DatabasesClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -261,7 +263,9 @@ func (client DatabasesClient) GetPreparer(resourceGroupName string, serverName s // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client DatabasesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -327,7 +331,9 @@ func (client DatabasesClient) ListByServerPreparer(resourceGroupName string, ser // ListByServerSender sends the ListByServer request. The method will close the // http.Response Body if it receives an error. func (client DatabasesClient) ListByServerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByServerResponder handles the response to the ListByServer request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/firewallrules.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/firewallrules.go index 67c4b473347d..98ca7d90c0a1 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/firewallrules.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/firewallrules.go @@ -125,6 +125,7 @@ func (client FirewallRulesClient) CreateOrUpdatePreparer(resourceGroupName strin func (client FirewallRulesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -209,6 +210,7 @@ func (client FirewallRulesClient) DeletePreparer(resourceGroupName string, serve func (client FirewallRulesClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -276,7 +278,9 @@ func (client FirewallRulesClient) GetPreparer(resourceGroupName string, serverNa // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client FirewallRulesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -342,7 +346,9 @@ func (client FirewallRulesClient) ListByServerPreparer(resourceGroupName string, // ListByServerSender sends the ListByServer request. The method will close the // http.Response Body if it receives an error. func (client FirewallRulesClient) ListByServerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByServerResponder handles the response to the ListByServer request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/logfiles.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/logfiles.go index 87eed6acaf99..4abee3a87883 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/logfiles.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/logfiles.go @@ -89,7 +89,9 @@ func (client LogFilesClient) ListByServerPreparer(resourceGroupName string, serv // ListByServerSender sends the ListByServer request. The method will close the // http.Response Body if it receives an error. func (client LogFilesClient) ListByServerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByServerResponder handles the response to the ListByServer request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/operations.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/operations.go index 59946f8fee35..5337b20b4f1a 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/operations.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/operations.go @@ -80,7 +80,9 @@ func (client OperationsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client OperationsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/servers.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/servers.go index ee01c0ae227d..8cfe7a9c303e 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/servers.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/servers.go @@ -127,6 +127,7 @@ func (client ServersClient) CreateOrUpdatePreparer(resourceGroupName string, ser func (client ServersClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -209,6 +210,7 @@ func (client ServersClient) DeletePreparer(resourceGroupName string, serverName func (client ServersClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -274,7 +276,9 @@ func (client ServersClient) GetPreparer(resourceGroupName string, serverName str // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ServersClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -335,7 +339,9 @@ func (client ServersClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ServersClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -400,7 +406,9 @@ func (client ServersClient) ListByResourceGroupPreparer(resourceGroupName string // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client ServersClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -486,6 +494,7 @@ func (client ServersClient) UpdatePreparer(resourceGroupName string, serverName func (client ServersClient) UpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/version.go index d61968f2b6e6..e5f9786ad092 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/mysql/version.go @@ -19,10 +19,10 @@ package mysql // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-mysql/2017-04-30-preview" + return "Azure-SDK-For-Go/v11.1.1-beta arm-mysql/2017-04-30-preview" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/applicationgateways.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/applicationgateways.go index c000be117bcd..0d1605ac2975 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/applicationgateways.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/applicationgateways.go @@ -109,6 +109,7 @@ func (client ApplicationGatewaysClient) BackendHealthPreparer(resourceGroupName func (client ApplicationGatewaysClient) BackendHealthSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -209,6 +210,7 @@ func (client ApplicationGatewaysClient) CreateOrUpdatePreparer(resourceGroupName func (client ApplicationGatewaysClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -290,6 +292,7 @@ func (client ApplicationGatewaysClient) DeletePreparer(resourceGroupName string, func (client ApplicationGatewaysClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -354,7 +357,9 @@ func (client ApplicationGatewaysClient) GetPreparer(resourceGroupName string, ap // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ApplicationGatewaysClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -418,7 +423,9 @@ func (client ApplicationGatewaysClient) GetSslPredefinedPolicyPreparer(predefine // GetSslPredefinedPolicySender sends the GetSslPredefinedPolicy request. The method will close the // http.Response Body if it receives an error. func (client ApplicationGatewaysClient) GetSslPredefinedPolicySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetSslPredefinedPolicyResponder handles the response to the GetSslPredefinedPolicy request. The method always @@ -482,7 +489,9 @@ func (client ApplicationGatewaysClient) ListPreparer(resourceGroupName string) ( // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ApplicationGatewaysClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -612,7 +621,9 @@ func (client ApplicationGatewaysClient) ListAllPreparer() (*http.Request, error) // ListAllSender sends the ListAll request. The method will close the // http.Response Body if it receives an error. func (client ApplicationGatewaysClient) ListAllSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAllResponder handles the response to the ListAll request. The method always @@ -742,7 +753,9 @@ func (client ApplicationGatewaysClient) ListAvailableSslOptionsPreparer() (*http // ListAvailableSslOptionsSender sends the ListAvailableSslOptions request. The method will close the // http.Response Body if it receives an error. func (client ApplicationGatewaysClient) ListAvailableSslOptionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAvailableSslOptionsResponder handles the response to the ListAvailableSslOptions request. The method always @@ -803,7 +816,9 @@ func (client ApplicationGatewaysClient) ListAvailableSslPredefinedPoliciesPrepar // ListAvailableSslPredefinedPoliciesSender sends the ListAvailableSslPredefinedPolicies request. The method will close the // http.Response Body if it receives an error. func (client ApplicationGatewaysClient) ListAvailableSslPredefinedPoliciesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAvailableSslPredefinedPoliciesResponder handles the response to the ListAvailableSslPredefinedPolicies request. The method always @@ -933,7 +948,9 @@ func (client ApplicationGatewaysClient) ListAvailableWafRuleSetsPreparer() (*htt // ListAvailableWafRuleSetsSender sends the ListAvailableWafRuleSets request. The method will close the // http.Response Body if it receives an error. func (client ApplicationGatewaysClient) ListAvailableWafRuleSetsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAvailableWafRuleSetsResponder handles the response to the ListAvailableWafRuleSets request. The method always @@ -1014,6 +1031,7 @@ func (client ApplicationGatewaysClient) StartPreparer(resourceGroupName string, func (client ApplicationGatewaysClient) StartSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1095,6 +1113,7 @@ func (client ApplicationGatewaysClient) StopPreparer(resourceGroupName string, a func (client ApplicationGatewaysClient) StopSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/applicationsecuritygroups.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/applicationsecuritygroups.go index 1e84e706466f..954b113d4228 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/applicationsecuritygroups.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/applicationsecuritygroups.go @@ -107,6 +107,7 @@ func (client ApplicationSecurityGroupsClient) CreateOrUpdatePreparer(resourceGro func (client ApplicationSecurityGroupsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -190,6 +191,7 @@ func (client ApplicationSecurityGroupsClient) DeletePreparer(resourceGroupName s func (client ApplicationSecurityGroupsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -255,7 +257,9 @@ func (client ApplicationSecurityGroupsClient) GetPreparer(resourceGroupName stri // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ApplicationSecurityGroupsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -319,7 +323,9 @@ func (client ApplicationSecurityGroupsClient) ListPreparer(resourceGroupName str // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ApplicationSecurityGroupsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -449,7 +455,9 @@ func (client ApplicationSecurityGroupsClient) ListAllPreparer() (*http.Request, // ListAllSender sends the ListAll request. The method will close the // http.Response Body if it receives an error. func (client ApplicationSecurityGroupsClient) ListAllSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAllResponder handles the response to the ListAll request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/availableendpointservices.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/availableendpointservices.go index 26bcaf8b647c..a010418e9ded 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/availableendpointservices.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/availableendpointservices.go @@ -86,7 +86,9 @@ func (client AvailableEndpointServicesClient) ListPreparer(location string) (*ht // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client AvailableEndpointServicesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/bgpservicecommunities.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/bgpservicecommunities.go index 10cfa2cdd558..5c4f4786a90e 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/bgpservicecommunities.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/bgpservicecommunities.go @@ -83,7 +83,9 @@ func (client BgpServiceCommunitiesClient) ListPreparer() (*http.Request, error) // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client BgpServiceCommunitiesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/client.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/client.go index a3576c393aa9..59fc2a569b33 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/client.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/client.go @@ -102,7 +102,9 @@ func (client ManagementClient) CheckDNSNameAvailabilityPreparer(location string, // CheckDNSNameAvailabilitySender sends the CheckDNSNameAvailability request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) CheckDNSNameAvailabilitySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CheckDNSNameAvailabilityResponder handles the response to the CheckDNSNameAvailability request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/defaultsecurityrules.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/defaultsecurityrules.go index 9a3ded19d5c2..1fd3e18d92aa 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/defaultsecurityrules.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/defaultsecurityrules.go @@ -89,7 +89,9 @@ func (client DefaultSecurityRulesClient) GetPreparer(resourceGroupName string, n // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client DefaultSecurityRulesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -155,7 +157,9 @@ func (client DefaultSecurityRulesClient) ListPreparer(resourceGroupName string, // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client DefaultSecurityRulesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/expressroutecircuitauthorizations.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/expressroutecircuitauthorizations.go index 9b7fd524e73c..3ea822813dc1 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/expressroutecircuitauthorizations.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/expressroutecircuitauthorizations.go @@ -111,6 +111,7 @@ func (client ExpressRouteCircuitAuthorizationsClient) CreateOrUpdatePreparer(res func (client ExpressRouteCircuitAuthorizationsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -195,6 +196,7 @@ func (client ExpressRouteCircuitAuthorizationsClient) DeletePreparer(resourceGro func (client ExpressRouteCircuitAuthorizationsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -261,7 +263,9 @@ func (client ExpressRouteCircuitAuthorizationsClient) GetPreparer(resourceGroupN // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ExpressRouteCircuitAuthorizationsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -326,7 +330,9 @@ func (client ExpressRouteCircuitAuthorizationsClient) ListPreparer(resourceGroup // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ExpressRouteCircuitAuthorizationsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/expressroutecircuitpeerings.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/expressroutecircuitpeerings.go index af9fc67e0394..c454167020dc 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/expressroutecircuitpeerings.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/expressroutecircuitpeerings.go @@ -109,6 +109,7 @@ func (client ExpressRouteCircuitPeeringsClient) CreateOrUpdatePreparer(resourceG func (client ExpressRouteCircuitPeeringsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -193,6 +194,7 @@ func (client ExpressRouteCircuitPeeringsClient) DeletePreparer(resourceGroupName func (client ExpressRouteCircuitPeeringsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -259,7 +261,9 @@ func (client ExpressRouteCircuitPeeringsClient) GetPreparer(resourceGroupName st // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ExpressRouteCircuitPeeringsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -324,7 +328,9 @@ func (client ExpressRouteCircuitPeeringsClient) ListPreparer(resourceGroupName s // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ExpressRouteCircuitPeeringsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/expressroutecircuits.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/expressroutecircuits.go index 63cfeff9e0a1..8a497d166afc 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/expressroutecircuits.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/expressroutecircuits.go @@ -107,6 +107,7 @@ func (client ExpressRouteCircuitsClient) CreateOrUpdatePreparer(resourceGroupNam func (client ExpressRouteCircuitsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -188,6 +189,7 @@ func (client ExpressRouteCircuitsClient) DeletePreparer(resourceGroupName string func (client ExpressRouteCircuitsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -252,7 +254,9 @@ func (client ExpressRouteCircuitsClient) GetPreparer(resourceGroupName string, c // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ExpressRouteCircuitsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -319,7 +323,9 @@ func (client ExpressRouteCircuitsClient) GetPeeringStatsPreparer(resourceGroupNa // GetPeeringStatsSender sends the GetPeeringStats request. The method will close the // http.Response Body if it receives an error. func (client ExpressRouteCircuitsClient) GetPeeringStatsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetPeeringStatsResponder handles the response to the GetPeeringStats request. The method always @@ -384,7 +390,9 @@ func (client ExpressRouteCircuitsClient) GetStatsPreparer(resourceGroupName stri // GetStatsSender sends the GetStats request. The method will close the // http.Response Body if it receives an error. func (client ExpressRouteCircuitsClient) GetStatsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetStatsResponder handles the response to the GetStats request. The method always @@ -448,7 +456,9 @@ func (client ExpressRouteCircuitsClient) ListPreparer(resourceGroupName string) // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ExpressRouteCircuitsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -578,7 +588,9 @@ func (client ExpressRouteCircuitsClient) ListAllPreparer() (*http.Request, error // ListAllSender sends the ListAll request. The method will close the // http.Response Body if it receives an error. func (client ExpressRouteCircuitsClient) ListAllSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAllResponder handles the response to the ListAll request. The method always @@ -732,6 +744,7 @@ func (client ExpressRouteCircuitsClient) ListArpTablePreparer(resourceGroupName func (client ExpressRouteCircuitsClient) ListArpTableSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -817,6 +830,7 @@ func (client ExpressRouteCircuitsClient) ListRoutesTablePreparer(resourceGroupNa func (client ExpressRouteCircuitsClient) ListRoutesTableSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -902,6 +916,7 @@ func (client ExpressRouteCircuitsClient) ListRoutesTableSummaryPreparer(resource func (client ExpressRouteCircuitsClient) ListRoutesTableSummarySender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/expressrouteserviceproviders.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/expressrouteserviceproviders.go index 5e39087b2a5c..ccd76e9968d4 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/expressrouteserviceproviders.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/expressrouteserviceproviders.go @@ -84,7 +84,9 @@ func (client ExpressRouteServiceProvidersClient) ListPreparer() (*http.Request, // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ExpressRouteServiceProvidersClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/inboundnatrules.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/inboundnatrules.go index eab80ac57669..8a43aee1b914 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/inboundnatrules.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/inboundnatrules.go @@ -132,6 +132,7 @@ func (client InboundNatRulesClient) CreateOrUpdatePreparer(resourceGroupName str func (client InboundNatRulesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -216,6 +217,7 @@ func (client InboundNatRulesClient) DeletePreparer(resourceGroupName string, loa func (client InboundNatRulesClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -285,7 +287,9 @@ func (client InboundNatRulesClient) GetPreparer(resourceGroupName string, loadBa // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client InboundNatRulesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -350,7 +354,9 @@ func (client InboundNatRulesClient) ListPreparer(resourceGroupName string, loadB // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client InboundNatRulesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/interfaceipconfigurations.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/interfaceipconfigurations.go index ca0359f09006..4885110b27f9 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/interfaceipconfigurations.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/interfaceipconfigurations.go @@ -89,7 +89,9 @@ func (client InterfaceIPConfigurationsClient) GetPreparer(resourceGroupName stri // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client InterfaceIPConfigurationsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -154,7 +156,9 @@ func (client InterfaceIPConfigurationsClient) ListPreparer(resourceGroupName str // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client InterfaceIPConfigurationsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/interfaceloadbalancers.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/interfaceloadbalancers.go index c7b7d272f729..e9f00e491e50 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/interfaceloadbalancers.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/interfaceloadbalancers.go @@ -87,7 +87,9 @@ func (client InterfaceLoadBalancersClient) ListPreparer(resourceGroupName string // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client InterfaceLoadBalancersClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/interfaces.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/interfaces.go index c2fdb3e901b7..cfe3238c53aa 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/interfaces.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/interfaces.go @@ -107,6 +107,7 @@ func (client InterfacesClient) CreateOrUpdatePreparer(resourceGroupName string, func (client InterfacesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -188,6 +189,7 @@ func (client InterfacesClient) DeletePreparer(resourceGroupName string, networkI func (client InterfacesClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -256,7 +258,9 @@ func (client InterfacesClient) GetPreparer(resourceGroupName string, networkInte // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client InterfacesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -338,6 +342,7 @@ func (client InterfacesClient) GetEffectiveRouteTablePreparer(resourceGroupName func (client InterfacesClient) GetEffectiveRouteTableSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -410,7 +415,9 @@ func (client InterfacesClient) GetVirtualMachineScaleSetNetworkInterfacePreparer // GetVirtualMachineScaleSetNetworkInterfaceSender sends the GetVirtualMachineScaleSetNetworkInterface request. The method will close the // http.Response Body if it receives an error. func (client InterfacesClient) GetVirtualMachineScaleSetNetworkInterfaceSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetVirtualMachineScaleSetNetworkInterfaceResponder handles the response to the GetVirtualMachineScaleSetNetworkInterface request. The method always @@ -474,7 +481,9 @@ func (client InterfacesClient) ListPreparer(resourceGroupName string) (*http.Req // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client InterfacesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -604,7 +613,9 @@ func (client InterfacesClient) ListAllPreparer() (*http.Request, error) { // ListAllSender sends the ListAll request. The method will close the // http.Response Body if it receives an error. func (client InterfacesClient) ListAllSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAllResponder handles the response to the ListAll request. The method always @@ -755,6 +766,7 @@ func (client InterfacesClient) ListEffectiveNetworkSecurityGroupsPreparer(resour func (client InterfacesClient) ListEffectiveNetworkSecurityGroupsSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -821,7 +833,9 @@ func (client InterfacesClient) ListVirtualMachineScaleSetNetworkInterfacesPrepar // ListVirtualMachineScaleSetNetworkInterfacesSender sends the ListVirtualMachineScaleSetNetworkInterfaces request. The method will close the // http.Response Body if it receives an error. func (client InterfacesClient) ListVirtualMachineScaleSetNetworkInterfacesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListVirtualMachineScaleSetNetworkInterfacesResponder handles the response to the ListVirtualMachineScaleSetNetworkInterfaces request. The method always @@ -958,7 +972,9 @@ func (client InterfacesClient) ListVirtualMachineScaleSetVMNetworkInterfacesPrep // ListVirtualMachineScaleSetVMNetworkInterfacesSender sends the ListVirtualMachineScaleSetVMNetworkInterfaces request. The method will close the // http.Response Body if it receives an error. func (client InterfacesClient) ListVirtualMachineScaleSetVMNetworkInterfacesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListVirtualMachineScaleSetVMNetworkInterfacesResponder handles the response to the ListVirtualMachineScaleSetVMNetworkInterfaces request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/loadbalancerbackendaddresspools.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/loadbalancerbackendaddresspools.go index de14c3556084..e15b18fc5835 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/loadbalancerbackendaddresspools.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/loadbalancerbackendaddresspools.go @@ -90,7 +90,9 @@ func (client LoadBalancerBackendAddressPoolsClient) GetPreparer(resourceGroupNam // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client LoadBalancerBackendAddressPoolsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -155,7 +157,9 @@ func (client LoadBalancerBackendAddressPoolsClient) ListPreparer(resourceGroupNa // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client LoadBalancerBackendAddressPoolsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/loadbalancerfrontendipconfigurations.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/loadbalancerfrontendipconfigurations.go index 515b875a1831..7ba6f72fb532 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/loadbalancerfrontendipconfigurations.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/loadbalancerfrontendipconfigurations.go @@ -91,7 +91,9 @@ func (client LoadBalancerFrontendIPConfigurationsClient) GetPreparer(resourceGro // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client LoadBalancerFrontendIPConfigurationsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -156,7 +158,9 @@ func (client LoadBalancerFrontendIPConfigurationsClient) ListPreparer(resourceGr // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client LoadBalancerFrontendIPConfigurationsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/loadbalancerloadbalancingrules.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/loadbalancerloadbalancingrules.go index 2ecd6be0d4f0..4a4747ccda11 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/loadbalancerloadbalancingrules.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/loadbalancerloadbalancingrules.go @@ -90,7 +90,9 @@ func (client LoadBalancerLoadBalancingRulesClient) GetPreparer(resourceGroupName // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client LoadBalancerLoadBalancingRulesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -155,7 +157,9 @@ func (client LoadBalancerLoadBalancingRulesClient) ListPreparer(resourceGroupNam // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client LoadBalancerLoadBalancingRulesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/loadbalancernetworkinterfaces.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/loadbalancernetworkinterfaces.go index 35650354255b..def71135275e 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/loadbalancernetworkinterfaces.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/loadbalancernetworkinterfaces.go @@ -88,7 +88,9 @@ func (client LoadBalancerNetworkInterfacesClient) ListPreparer(resourceGroupName // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client LoadBalancerNetworkInterfacesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/loadbalancerprobes.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/loadbalancerprobes.go index daee51e0f355..2b43d041b026 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/loadbalancerprobes.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/loadbalancerprobes.go @@ -89,7 +89,9 @@ func (client LoadBalancerProbesClient) GetPreparer(resourceGroupName string, loa // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client LoadBalancerProbesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -154,7 +156,9 @@ func (client LoadBalancerProbesClient) ListPreparer(resourceGroupName string, lo // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client LoadBalancerProbesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/loadbalancers.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/loadbalancers.go index 3a2528d85f4b..980478937e8d 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/loadbalancers.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/loadbalancers.go @@ -106,6 +106,7 @@ func (client LoadBalancersClient) CreateOrUpdatePreparer(resourceGroupName strin func (client LoadBalancersClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -187,6 +188,7 @@ func (client LoadBalancersClient) DeletePreparer(resourceGroupName string, loadB func (client LoadBalancersClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -255,7 +257,9 @@ func (client LoadBalancersClient) GetPreparer(resourceGroupName string, loadBala // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client LoadBalancersClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -319,7 +323,9 @@ func (client LoadBalancersClient) ListPreparer(resourceGroupName string) (*http. // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client LoadBalancersClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -449,7 +455,9 @@ func (client LoadBalancersClient) ListAllPreparer() (*http.Request, error) { // ListAllSender sends the ListAll request. The method will close the // http.Response Body if it receives an error. func (client LoadBalancersClient) ListAllSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAllResponder handles the response to the ListAll request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/localnetworkgateways.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/localnetworkgateways.go index 64cdea20a72b..5431d244efe9 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/localnetworkgateways.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/localnetworkgateways.go @@ -119,6 +119,7 @@ func (client LocalNetworkGatewaysClient) CreateOrUpdatePreparer(resourceGroupNam func (client LocalNetworkGatewaysClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -210,6 +211,7 @@ func (client LocalNetworkGatewaysClient) DeletePreparer(resourceGroupName string func (client LocalNetworkGatewaysClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -281,7 +283,9 @@ func (client LocalNetworkGatewaysClient) GetPreparer(resourceGroupName string, l // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client LocalNetworkGatewaysClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -345,7 +349,9 @@ func (client LocalNetworkGatewaysClient) ListPreparer(resourceGroupName string) // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client LocalNetworkGatewaysClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/packetcaptures.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/packetcaptures.go index 1ad97a5e2aa1..d089ca61dbb6 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/packetcaptures.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/packetcaptures.go @@ -122,6 +122,7 @@ func (client PacketCapturesClient) CreatePreparer(resourceGroupName string, netw func (client PacketCapturesClient) CreateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -205,6 +206,7 @@ func (client PacketCapturesClient) DeletePreparer(resourceGroupName string, netw func (client PacketCapturesClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -271,7 +273,9 @@ func (client PacketCapturesClient) GetPreparer(resourceGroupName string, network // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client PacketCapturesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -355,6 +359,7 @@ func (client PacketCapturesClient) GetStatusPreparer(resourceGroupName string, n func (client PacketCapturesClient) GetStatusSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -420,7 +425,9 @@ func (client PacketCapturesClient) ListPreparer(resourceGroupName string, networ // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client PacketCapturesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -503,6 +510,7 @@ func (client PacketCapturesClient) StopPreparer(resourceGroupName string, networ func (client PacketCapturesClient) StopSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/publicipaddresses.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/publicipaddresses.go index af7e7ec85b66..63733fbd4824 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/publicipaddresses.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/publicipaddresses.go @@ -122,6 +122,7 @@ func (client PublicIPAddressesClient) CreateOrUpdatePreparer(resourceGroupName s func (client PublicIPAddressesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -203,6 +204,7 @@ func (client PublicIPAddressesClient) DeletePreparer(resourceGroupName string, p func (client PublicIPAddressesClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -271,7 +273,9 @@ func (client PublicIPAddressesClient) GetPreparer(resourceGroupName string, publ // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client PublicIPAddressesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -346,7 +350,9 @@ func (client PublicIPAddressesClient) GetVirtualMachineScaleSetPublicIPAddressPr // GetVirtualMachineScaleSetPublicIPAddressSender sends the GetVirtualMachineScaleSetPublicIPAddress request. The method will close the // http.Response Body if it receives an error. func (client PublicIPAddressesClient) GetVirtualMachineScaleSetPublicIPAddressSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetVirtualMachineScaleSetPublicIPAddressResponder handles the response to the GetVirtualMachineScaleSetPublicIPAddress request. The method always @@ -410,7 +416,9 @@ func (client PublicIPAddressesClient) ListPreparer(resourceGroupName string) (*h // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client PublicIPAddressesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -540,7 +548,9 @@ func (client PublicIPAddressesClient) ListAllPreparer() (*http.Request, error) { // ListAllSender sends the ListAll request. The method will close the // http.Response Body if it receives an error. func (client PublicIPAddressesClient) ListAllSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAllResponder handles the response to the ListAll request. The method always @@ -676,7 +686,9 @@ func (client PublicIPAddressesClient) ListVirtualMachineScaleSetPublicIPAddresse // ListVirtualMachineScaleSetPublicIPAddressesSender sends the ListVirtualMachineScaleSetPublicIPAddresses request. The method will close the // http.Response Body if it receives an error. func (client PublicIPAddressesClient) ListVirtualMachineScaleSetPublicIPAddressesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListVirtualMachineScaleSetPublicIPAddressesResponder handles the response to the ListVirtualMachineScaleSetPublicIPAddresses request. The method always @@ -816,7 +828,9 @@ func (client PublicIPAddressesClient) ListVirtualMachineScaleSetVMPublicIPAddres // ListVirtualMachineScaleSetVMPublicIPAddressesSender sends the ListVirtualMachineScaleSetVMPublicIPAddresses request. The method will close the // http.Response Body if it receives an error. func (client PublicIPAddressesClient) ListVirtualMachineScaleSetVMPublicIPAddressesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListVirtualMachineScaleSetVMPublicIPAddressesResponder handles the response to the ListVirtualMachineScaleSetVMPublicIPAddresses request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/routefilterrules.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/routefilterrules.go index 7c0ab17904c8..b3dc3883bec4 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/routefilterrules.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/routefilterrules.go @@ -122,6 +122,7 @@ func (client RouteFilterRulesClient) CreateOrUpdatePreparer(resourceGroupName st func (client RouteFilterRulesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -206,6 +207,7 @@ func (client RouteFilterRulesClient) DeletePreparer(resourceGroupName string, ro func (client RouteFilterRulesClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -272,7 +274,9 @@ func (client RouteFilterRulesClient) GetPreparer(resourceGroupName string, route // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client RouteFilterRulesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -337,7 +341,9 @@ func (client RouteFilterRulesClient) ListByRouteFilterPreparer(resourceGroupName // ListByRouteFilterSender sends the ListByRouteFilter request. The method will close the // http.Response Body if it receives an error. func (client RouteFilterRulesClient) ListByRouteFilterSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByRouteFilterResponder handles the response to the ListByRouteFilter request. The method always @@ -493,6 +499,7 @@ func (client RouteFilterRulesClient) UpdatePreparer(resourceGroupName string, ro func (client RouteFilterRulesClient) UpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/routefilters.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/routefilters.go index 711e58fc9c98..0d35b6d9c06c 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/routefilters.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/routefilters.go @@ -107,6 +107,7 @@ func (client RouteFiltersClient) CreateOrUpdatePreparer(resourceGroupName string func (client RouteFiltersClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -188,6 +189,7 @@ func (client RouteFiltersClient) DeletePreparer(resourceGroupName string, routeF func (client RouteFiltersClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -256,7 +258,9 @@ func (client RouteFiltersClient) GetPreparer(resourceGroupName string, routeFilt // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client RouteFiltersClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -317,7 +321,9 @@ func (client RouteFiltersClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client RouteFiltersClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -450,7 +456,9 @@ func (client RouteFiltersClient) ListByResourceGroupPreparer(resourceGroupName s // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client RouteFiltersClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -604,6 +612,7 @@ func (client RouteFiltersClient) UpdatePreparer(resourceGroupName string, routeF func (client RouteFiltersClient) UpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/routes.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/routes.go index 0dcde6fa01d0..48d11f3afce2 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/routes.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/routes.go @@ -108,6 +108,7 @@ func (client RoutesClient) CreateOrUpdatePreparer(resourceGroupName string, rout func (client RoutesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -192,6 +193,7 @@ func (client RoutesClient) DeletePreparer(resourceGroupName string, routeTableNa func (client RoutesClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -258,7 +260,9 @@ func (client RoutesClient) GetPreparer(resourceGroupName string, routeTableName // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client RoutesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -323,7 +327,9 @@ func (client RoutesClient) ListPreparer(resourceGroupName string, routeTableName // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client RoutesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/routetables.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/routetables.go index e9b557bc0b37..3a2f4ca69e6c 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/routetables.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/routetables.go @@ -107,6 +107,7 @@ func (client RouteTablesClient) CreateOrUpdatePreparer(resourceGroupName string, func (client RouteTablesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -188,6 +189,7 @@ func (client RouteTablesClient) DeletePreparer(resourceGroupName string, routeTa func (client RouteTablesClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -256,7 +258,9 @@ func (client RouteTablesClient) GetPreparer(resourceGroupName string, routeTable // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client RouteTablesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -320,7 +324,9 @@ func (client RouteTablesClient) ListPreparer(resourceGroupName string) (*http.Re // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client RouteTablesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -450,7 +456,9 @@ func (client RouteTablesClient) ListAllPreparer() (*http.Request, error) { // ListAllSender sends the ListAll request. The method will close the // http.Response Body if it receives an error. func (client RouteTablesClient) ListAllSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAllResponder handles the response to the ListAll request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/securitygroups.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/securitygroups.go index b1a5ae4a6e29..3606e6d82c89 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/securitygroups.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/securitygroups.go @@ -107,6 +107,7 @@ func (client SecurityGroupsClient) CreateOrUpdatePreparer(resourceGroupName stri func (client SecurityGroupsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -189,6 +190,7 @@ func (client SecurityGroupsClient) DeletePreparer(resourceGroupName string, netw func (client SecurityGroupsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -257,7 +259,9 @@ func (client SecurityGroupsClient) GetPreparer(resourceGroupName string, network // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client SecurityGroupsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -321,7 +325,9 @@ func (client SecurityGroupsClient) ListPreparer(resourceGroupName string) (*http // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client SecurityGroupsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -451,7 +457,9 @@ func (client SecurityGroupsClient) ListAllPreparer() (*http.Request, error) { // ListAllSender sends the ListAll request. The method will close the // http.Response Body if it receives an error. func (client SecurityGroupsClient) ListAllSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAllResponder handles the response to the ListAll request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/securityrules.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/securityrules.go index 9c76ef54e8b9..6fcecae5f9c1 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/securityrules.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/securityrules.go @@ -122,6 +122,7 @@ func (client SecurityRulesClient) CreateOrUpdatePreparer(resourceGroupName strin func (client SecurityRulesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -205,6 +206,7 @@ func (client SecurityRulesClient) DeletePreparer(resourceGroupName string, netwo func (client SecurityRulesClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -271,7 +273,9 @@ func (client SecurityRulesClient) GetPreparer(resourceGroupName string, networkS // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client SecurityRulesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -337,7 +341,9 @@ func (client SecurityRulesClient) ListPreparer(resourceGroupName string, network // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client SecurityRulesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/subnets.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/subnets.go index 62a1789e591d..298cb989ffa8 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/subnets.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/subnets.go @@ -109,6 +109,7 @@ func (client SubnetsClient) CreateOrUpdatePreparer(resourceGroupName string, vir func (client SubnetsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -192,6 +193,7 @@ func (client SubnetsClient) DeletePreparer(resourceGroupName string, virtualNetw func (client SubnetsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -261,7 +263,9 @@ func (client SubnetsClient) GetPreparer(resourceGroupName string, virtualNetwork // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client SubnetsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -326,7 +330,9 @@ func (client SubnetsClient) ListPreparer(resourceGroupName string, virtualNetwor // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client SubnetsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/usages.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/usages.go index 85c220065404..ab2c9b8fcb3e 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/usages.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/usages.go @@ -93,7 +93,9 @@ func (client UsagesClient) ListPreparer(location string) (*http.Request, error) // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client UsagesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/version.go index 7f510b4e4c6d..e4c3729cafb8 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/version.go @@ -19,10 +19,10 @@ package network // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-network/" + return "Azure-SDK-For-Go/v11.1.1-beta arm-network/" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/virtualnetworkgatewayconnections.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/virtualnetworkgatewayconnections.go index 7db4d5de6c38..faac6f8a6797 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/virtualnetworkgatewayconnections.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/virtualnetworkgatewayconnections.go @@ -126,6 +126,7 @@ func (client VirtualNetworkGatewayConnectionsClient) CreateOrUpdatePreparer(reso func (client VirtualNetworkGatewayConnectionsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -209,6 +210,7 @@ func (client VirtualNetworkGatewayConnectionsClient) DeletePreparer(resourceGrou func (client VirtualNetworkGatewayConnectionsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -274,7 +276,9 @@ func (client VirtualNetworkGatewayConnectionsClient) GetPreparer(resourceGroupNa // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client VirtualNetworkGatewayConnectionsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -341,7 +345,9 @@ func (client VirtualNetworkGatewayConnectionsClient) GetSharedKeyPreparer(resour // GetSharedKeySender sends the GetSharedKey request. The method will close the // http.Response Body if it receives an error. func (client VirtualNetworkGatewayConnectionsClient) GetSharedKeySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetSharedKeyResponder handles the response to the GetSharedKey request. The method always @@ -406,7 +412,9 @@ func (client VirtualNetworkGatewayConnectionsClient) ListPreparer(resourceGroupN // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client VirtualNetworkGatewayConnectionsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -574,6 +582,7 @@ func (client VirtualNetworkGatewayConnectionsClient) ResetSharedKeyPreparer(reso func (client VirtualNetworkGatewayConnectionsClient) ResetSharedKeySender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -670,6 +679,7 @@ func (client VirtualNetworkGatewayConnectionsClient) SetSharedKeyPreparer(resour func (client VirtualNetworkGatewayConnectionsClient) SetSharedKeySender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/virtualnetworkgateways.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/virtualnetworkgateways.go index 5f56a204badf..6edd19644c5b 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/virtualnetworkgateways.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/virtualnetworkgateways.go @@ -117,6 +117,7 @@ func (client VirtualNetworkGatewaysClient) CreateOrUpdatePreparer(resourceGroupN func (client VirtualNetworkGatewaysClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -200,6 +201,7 @@ func (client VirtualNetworkGatewaysClient) DeletePreparer(resourceGroupName stri func (client VirtualNetworkGatewaysClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -284,6 +286,7 @@ func (client VirtualNetworkGatewaysClient) GeneratevpnclientpackagePreparer(reso func (client VirtualNetworkGatewaysClient) GeneratevpnclientpackageSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -370,6 +373,7 @@ func (client VirtualNetworkGatewaysClient) GenerateVpnProfilePreparer(resourceGr func (client VirtualNetworkGatewaysClient) GenerateVpnProfileSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -436,7 +440,9 @@ func (client VirtualNetworkGatewaysClient) GetPreparer(resourceGroupName string, // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client VirtualNetworkGatewaysClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -520,6 +526,7 @@ func (client VirtualNetworkGatewaysClient) GetAdvertisedRoutesPreparer(resourceG func (client VirtualNetworkGatewaysClient) GetAdvertisedRoutesSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -606,6 +613,7 @@ func (client VirtualNetworkGatewaysClient) GetBgpPeerStatusPreparer(resourceGrou func (client VirtualNetworkGatewaysClient) GetBgpPeerStatusSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -689,6 +697,7 @@ func (client VirtualNetworkGatewaysClient) GetLearnedRoutesPreparer(resourceGrou func (client VirtualNetworkGatewaysClient) GetLearnedRoutesSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -773,6 +782,7 @@ func (client VirtualNetworkGatewaysClient) GetVpnProfilePackageURLPreparer(resou func (client VirtualNetworkGatewaysClient) GetVpnProfilePackageURLSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -837,7 +847,9 @@ func (client VirtualNetworkGatewaysClient) ListPreparer(resourceGroupName string // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client VirtualNetworkGatewaysClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -972,7 +984,9 @@ func (client VirtualNetworkGatewaysClient) ListConnectionsPreparer(resourceGroup // ListConnectionsSender sends the ListConnections request. The method will close the // http.Response Body if it receives an error. func (client VirtualNetworkGatewaysClient) ListConnectionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListConnectionsResponder handles the response to the ListConnections request. The method always @@ -1128,6 +1142,7 @@ func (client VirtualNetworkGatewaysClient) ResetPreparer(resourceGroupName strin func (client VirtualNetworkGatewaysClient) ResetSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1194,7 +1209,9 @@ func (client VirtualNetworkGatewaysClient) SupportedVpnDevicesPreparer(resourceG // SupportedVpnDevicesSender sends the SupportedVpnDevices request. The method will close the // http.Response Body if it receives an error. func (client VirtualNetworkGatewaysClient) SupportedVpnDevicesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // SupportedVpnDevicesResponder handles the response to the SupportedVpnDevices request. The method always @@ -1263,7 +1280,9 @@ func (client VirtualNetworkGatewaysClient) VpnDeviceConfigurationScriptPreparer( // VpnDeviceConfigurationScriptSender sends the VpnDeviceConfigurationScript request. The method will close the // http.Response Body if it receives an error. func (client VirtualNetworkGatewaysClient) VpnDeviceConfigurationScriptSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // VpnDeviceConfigurationScriptResponder handles the response to the VpnDeviceConfigurationScript request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/virtualnetworkpeerings.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/virtualnetworkpeerings.go index 0a945c1bb8d7..30bed99c02cd 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/virtualnetworkpeerings.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/virtualnetworkpeerings.go @@ -109,6 +109,7 @@ func (client VirtualNetworkPeeringsClient) CreateOrUpdatePreparer(resourceGroupN func (client VirtualNetworkPeeringsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -193,6 +194,7 @@ func (client VirtualNetworkPeeringsClient) DeletePreparer(resourceGroupName stri func (client VirtualNetworkPeeringsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -259,7 +261,9 @@ func (client VirtualNetworkPeeringsClient) GetPreparer(resourceGroupName string, // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client VirtualNetworkPeeringsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -324,7 +328,9 @@ func (client VirtualNetworkPeeringsClient) ListPreparer(resourceGroupName string // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client VirtualNetworkPeeringsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/virtualnetworks.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/virtualnetworks.go index 58ac8ab11229..47c71480661f 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/virtualnetworks.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/virtualnetworks.go @@ -91,7 +91,9 @@ func (client VirtualNetworksClient) CheckIPAddressAvailabilityPreparer(resourceG // CheckIPAddressAvailabilitySender sends the CheckIPAddressAvailability request. The method will close the // http.Response Body if it receives an error. func (client VirtualNetworksClient) CheckIPAddressAvailabilitySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CheckIPAddressAvailabilityResponder handles the response to the CheckIPAddressAvailability request. The method always @@ -176,6 +178,7 @@ func (client VirtualNetworksClient) CreateOrUpdatePreparer(resourceGroupName str func (client VirtualNetworksClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -257,6 +260,7 @@ func (client VirtualNetworksClient) DeletePreparer(resourceGroupName string, vir func (client VirtualNetworksClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -325,7 +329,9 @@ func (client VirtualNetworksClient) GetPreparer(resourceGroupName string, virtua // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client VirtualNetworksClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -389,7 +395,9 @@ func (client VirtualNetworksClient) ListPreparer(resourceGroupName string) (*htt // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client VirtualNetworksClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -519,7 +527,9 @@ func (client VirtualNetworksClient) ListAllPreparer() (*http.Request, error) { // ListAllSender sends the ListAll request. The method will close the // http.Response Body if it receives an error. func (client VirtualNetworksClient) ListAllSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAllResponder handles the response to the ListAll request. The method always @@ -653,7 +663,9 @@ func (client VirtualNetworksClient) ListUsagePreparer(resourceGroupName string, // ListUsageSender sends the ListUsage request. The method will close the // http.Response Body if it receives an error. func (client VirtualNetworksClient) ListUsageSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListUsageResponder handles the response to the ListUsage request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/watchers.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/watchers.go index 798d8c1bb221..b075417ddbee 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/network/watchers.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/network/watchers.go @@ -120,6 +120,7 @@ func (client WatchersClient) CheckConnectivityPreparer(resourceGroupName string, func (client WatchersClient) CheckConnectivitySender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -188,7 +189,9 @@ func (client WatchersClient) CreateOrUpdatePreparer(resourceGroupName string, ne // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client WatchersClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -270,6 +273,7 @@ func (client WatchersClient) DeletePreparer(resourceGroupName string, networkWat func (client WatchersClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -334,7 +338,9 @@ func (client WatchersClient) GetPreparer(resourceGroupName string, networkWatche // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client WatchersClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -431,6 +437,7 @@ func (client WatchersClient) GetAzureReachabilityReportPreparer(resourceGroupNam func (client WatchersClient) GetAzureReachabilityReportSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -525,6 +532,7 @@ func (client WatchersClient) GetFlowLogStatusPreparer(resourceGroupName string, func (client WatchersClient) GetFlowLogStatusSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -620,6 +628,7 @@ func (client WatchersClient) GetNextHopPreparer(resourceGroupName string, networ func (client WatchersClient) GetNextHopSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -694,7 +703,9 @@ func (client WatchersClient) GetTopologyPreparer(resourceGroupName string, netwo // GetTopologySender sends the GetTopology request. The method will close the // http.Response Body if it receives an error. func (client WatchersClient) GetTopologySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetTopologyResponder handles the response to the GetTopology request. The method always @@ -792,6 +803,7 @@ func (client WatchersClient) GetTroubleshootingPreparer(resourceGroupName string func (client WatchersClient) GetTroubleshootingSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -886,6 +898,7 @@ func (client WatchersClient) GetTroubleshootingResultPreparer(resourceGroupName func (client WatchersClient) GetTroubleshootingResultSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -980,6 +993,7 @@ func (client WatchersClient) GetVMSecurityRulesPreparer(resourceGroupName string func (client WatchersClient) GetVMSecurityRulesSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1044,7 +1058,9 @@ func (client WatchersClient) ListPreparer(resourceGroupName string) (*http.Reque // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client WatchersClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -1105,7 +1121,9 @@ func (client WatchersClient) ListAllPreparer() (*http.Request, error) { // ListAllSender sends the ListAll request. The method will close the // http.Response Body if it receives an error. func (client WatchersClient) ListAllSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAllResponder handles the response to the ListAll request. The method always @@ -1190,6 +1208,7 @@ func (client WatchersClient) ListAvailableProvidersPreparer(resourceGroupName st func (client WatchersClient) ListAvailableProvidersSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1288,6 +1307,7 @@ func (client WatchersClient) SetFlowLogConfigurationPreparer(resourceGroupName s func (client WatchersClient) SetFlowLogConfigurationSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1386,6 +1406,7 @@ func (client WatchersClient) VerifyIPFlowPreparer(resourceGroupName string, netw func (client WatchersClient) VerifyIPFlowSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/operationalinsights/datasources.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/operationalinsights/datasources.go index 5b3ad40bb92d..f5f473e9b78c 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/operationalinsights/datasources.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/operationalinsights/datasources.go @@ -103,7 +103,9 @@ func (client DataSourcesClient) CreateOrUpdatePreparer(resourceGroupName string, // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client DataSourcesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -178,7 +180,9 @@ func (client DataSourcesClient) DeletePreparer(resourceGroupName string, workspa // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client DataSourcesClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -252,7 +256,9 @@ func (client DataSourcesClient) GetPreparer(resourceGroupName string, workspaceN // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client DataSourcesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -331,7 +337,9 @@ func (client DataSourcesClient) ListByWorkspacePreparer(resourceGroupName string // ListByWorkspaceSender sends the ListByWorkspace request. The method will close the // http.Response Body if it receives an error. func (client DataSourcesClient) ListByWorkspaceSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByWorkspaceResponder handles the response to the ListByWorkspace request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/operationalinsights/linkedservices.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/operationalinsights/linkedservices.go index 0493090e9461..917931a5da2e 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/operationalinsights/linkedservices.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/operationalinsights/linkedservices.go @@ -104,7 +104,9 @@ func (client LinkedServicesClient) CreateOrUpdatePreparer(resourceGroupName stri // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client LinkedServicesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -180,7 +182,9 @@ func (client LinkedServicesClient) DeletePreparer(resourceGroupName string, work // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client LinkedServicesClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -255,7 +259,9 @@ func (client LinkedServicesClient) GetPreparer(resourceGroupName string, workspa // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client LinkedServicesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -329,7 +335,9 @@ func (client LinkedServicesClient) ListByWorkspacePreparer(resourceGroupName str // ListByWorkspaceSender sends the ListByWorkspace request. The method will close the // http.Response Body if it receives an error. func (client LinkedServicesClient) ListByWorkspaceSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByWorkspaceResponder handles the response to the ListByWorkspace request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/operationalinsights/savedsearches.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/operationalinsights/savedsearches.go index ea6cc997b9d2..facf4ee4a5b6 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/operationalinsights/savedsearches.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/operationalinsights/savedsearches.go @@ -111,7 +111,9 @@ func (client SavedSearchesClient) CreateOrUpdatePreparer(resourceGroupName strin // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client SavedSearchesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -186,7 +188,9 @@ func (client SavedSearchesClient) DeletePreparer(resourceGroupName string, works // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client SavedSearchesClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -260,7 +264,9 @@ func (client SavedSearchesClient) GetPreparer(resourceGroupName string, workspac // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client SavedSearchesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -335,7 +341,9 @@ func (client SavedSearchesClient) GetResultsPreparer(resourceGroupName string, w // GetResultsSender sends the GetResults request. The method will close the // http.Response Body if it receives an error. func (client SavedSearchesClient) GetResultsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResultsResponder handles the response to the GetResults request. The method always @@ -409,7 +417,9 @@ func (client SavedSearchesClient) ListByWorkspacePreparer(resourceGroupName stri // ListByWorkspaceSender sends the ListByWorkspace request. The method will close the // http.Response Body if it receives an error. func (client SavedSearchesClient) ListByWorkspaceSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByWorkspaceResponder handles the response to the ListByWorkspace request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/operationalinsights/storageinsights.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/operationalinsights/storageinsights.go index 0486080141d3..4ca992b2360f 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/operationalinsights/storageinsights.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/operationalinsights/storageinsights.go @@ -108,7 +108,9 @@ func (client StorageInsightsClient) CreateOrUpdatePreparer(resourceGroupName str // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client StorageInsightsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -184,7 +186,9 @@ func (client StorageInsightsClient) DeletePreparer(resourceGroupName string, wor // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client StorageInsightsClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -259,7 +263,9 @@ func (client StorageInsightsClient) GetPreparer(resourceGroupName string, worksp // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client StorageInsightsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -333,7 +339,9 @@ func (client StorageInsightsClient) ListByWorkspacePreparer(resourceGroupName st // ListByWorkspaceSender sends the ListByWorkspace request. The method will close the // http.Response Body if it receives an error. func (client StorageInsightsClient) ListByWorkspaceSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByWorkspaceResponder handles the response to the ListByWorkspace request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/operationalinsights/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/operationalinsights/version.go index cce635f1b27b..6fd6bb626809 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/operationalinsights/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/operationalinsights/version.go @@ -19,10 +19,10 @@ package operationalinsights // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-operationalinsights/" + return "Azure-SDK-For-Go/v11.1.1-beta arm-operationalinsights/" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/operationalinsights/workspaces.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/operationalinsights/workspaces.go index f67542e8e097..8c940570ad78 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/operationalinsights/workspaces.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/operationalinsights/workspaces.go @@ -125,6 +125,7 @@ func (client WorkspacesClient) CreateOrUpdatePreparer(resourceGroupName string, func (client WorkspacesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -190,7 +191,9 @@ func (client WorkspacesClient) DeletePreparer(resourceGroupName string, workspac // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client WorkspacesClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -264,7 +267,9 @@ func (client WorkspacesClient) DisableIntelligencePackPreparer(resourceGroupName // DisableIntelligencePackSender sends the DisableIntelligencePack request. The method will close the // http.Response Body if it receives an error. func (client WorkspacesClient) DisableIntelligencePackSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DisableIntelligencePackResponder handles the response to the DisableIntelligencePack request. The method always @@ -338,7 +343,9 @@ func (client WorkspacesClient) EnableIntelligencePackPreparer(resourceGroupName // EnableIntelligencePackSender sends the EnableIntelligencePack request. The method will close the // http.Response Body if it receives an error. func (client WorkspacesClient) EnableIntelligencePackSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // EnableIntelligencePackResponder handles the response to the EnableIntelligencePack request. The method always @@ -402,7 +409,9 @@ func (client WorkspacesClient) GetPreparer(resourceGroupName string, workspaceNa // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client WorkspacesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -476,7 +485,9 @@ func (client WorkspacesClient) GetSchemaPreparer(resourceGroupName string, works // GetSchemaSender sends the GetSchema request. The method will close the // http.Response Body if it receives an error. func (client WorkspacesClient) GetSchemaSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetSchemaResponder handles the response to the GetSchema request. The method always @@ -575,6 +586,7 @@ func (client WorkspacesClient) GetSearchResultsPreparer(resourceGroupName string func (client WorkspacesClient) GetSearchResultsSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -649,7 +661,9 @@ func (client WorkspacesClient) GetSharedKeysPreparer(resourceGroupName string, w // GetSharedKeysSender sends the GetSharedKeys request. The method will close the // http.Response Body if it receives an error. func (client WorkspacesClient) GetSharedKeysSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetSharedKeysResponder handles the response to the GetSharedKeys request. The method always @@ -710,7 +724,9 @@ func (client WorkspacesClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client WorkspacesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -782,7 +798,9 @@ func (client WorkspacesClient) ListByResourceGroupPreparer(resourceGroupName str // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client WorkspacesClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -857,7 +875,9 @@ func (client WorkspacesClient) ListIntelligencePacksPreparer(resourceGroupName s // ListIntelligencePacksSender sends the ListIntelligencePacks request. The method will close the // http.Response Body if it receives an error. func (client WorkspacesClient) ListIntelligencePacksSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListIntelligencePacksResponder handles the response to the ListIntelligencePacks request. The method always @@ -919,7 +939,9 @@ func (client WorkspacesClient) ListLinkTargetsPreparer() (*http.Request, error) // ListLinkTargetsSender sends the ListLinkTargets request. The method will close the // http.Response Body if it receives an error. func (client WorkspacesClient) ListLinkTargetsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListLinkTargetsResponder handles the response to the ListLinkTargets request. The method always @@ -993,7 +1015,9 @@ func (client WorkspacesClient) ListManagementGroupsPreparer(resourceGroupName st // ListManagementGroupsSender sends the ListManagementGroups request. The method will close the // http.Response Body if it receives an error. func (client WorkspacesClient) ListManagementGroupsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListManagementGroupsResponder handles the response to the ListManagementGroups request. The method always @@ -1067,7 +1091,9 @@ func (client WorkspacesClient) ListUsagesPreparer(resourceGroupName string, work // ListUsagesSender sends the ListUsages request. The method will close the // http.Response Body if it receives an error. func (client WorkspacesClient) ListUsagesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListUsagesResponder handles the response to the ListUsages request. The method always @@ -1143,7 +1169,9 @@ func (client WorkspacesClient) UpdateSearchResultsPreparer(resourceGroupName str // UpdateSearchResultsSender sends the UpdateSearchResults request. The method will close the // http.Response Body if it receives an error. func (client WorkspacesClient) UpdateSearchResultsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateSearchResultsResponder handles the response to the UpdateSearchResults request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/configurations.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/configurations.go index 168e0ebc1fd2..bc78709b4a4e 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/configurations.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/configurations.go @@ -110,6 +110,7 @@ func (client ConfigurationsClient) CreateOrUpdatePreparer(resourceGroupName stri func (client ConfigurationsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -178,7 +179,9 @@ func (client ConfigurationsClient) GetPreparer(resourceGroupName string, serverN // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ConfigurationsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -244,7 +247,9 @@ func (client ConfigurationsClient) ListByServerPreparer(resourceGroupName string // ListByServerSender sends the ListByServer request. The method will close the // http.Response Body if it receives an error. func (client ConfigurationsClient) ListByServerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByServerResponder handles the response to the ListByServer request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/databases.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/databases.go index 6f8bcb196a87..8a3a1dafcea5 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/databases.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/databases.go @@ -110,6 +110,7 @@ func (client DatabasesClient) CreateOrUpdatePreparer(resourceGroupName string, s func (client DatabasesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -194,6 +195,7 @@ func (client DatabasesClient) DeletePreparer(resourceGroupName string, serverNam func (client DatabasesClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -261,7 +263,9 @@ func (client DatabasesClient) GetPreparer(resourceGroupName string, serverName s // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client DatabasesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -327,7 +331,9 @@ func (client DatabasesClient) ListByServerPreparer(resourceGroupName string, ser // ListByServerSender sends the ListByServer request. The method will close the // http.Response Body if it receives an error. func (client DatabasesClient) ListByServerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByServerResponder handles the response to the ListByServer request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/firewallrules.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/firewallrules.go index 88cf63e23706..3f36166e0a52 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/firewallrules.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/firewallrules.go @@ -126,6 +126,7 @@ func (client FirewallRulesClient) CreateOrUpdatePreparer(resourceGroupName strin func (client FirewallRulesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -210,6 +211,7 @@ func (client FirewallRulesClient) DeletePreparer(resourceGroupName string, serve func (client FirewallRulesClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -277,7 +279,9 @@ func (client FirewallRulesClient) GetPreparer(resourceGroupName string, serverNa // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client FirewallRulesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -343,7 +347,9 @@ func (client FirewallRulesClient) ListByServerPreparer(resourceGroupName string, // ListByServerSender sends the ListByServer request. The method will close the // http.Response Body if it receives an error. func (client FirewallRulesClient) ListByServerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByServerResponder handles the response to the ListByServer request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/logfiles.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/logfiles.go index 6959aad09d6a..c0113540bc18 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/logfiles.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/logfiles.go @@ -89,7 +89,9 @@ func (client LogFilesClient) ListByServerPreparer(resourceGroupName string, serv // ListByServerSender sends the ListByServer request. The method will close the // http.Response Body if it receives an error. func (client LogFilesClient) ListByServerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByServerResponder handles the response to the ListByServer request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/operations.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/operations.go index 003e5f50f8eb..c3ac7ffcce71 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/operations.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/operations.go @@ -80,7 +80,9 @@ func (client OperationsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client OperationsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/servers.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/servers.go index 43dbf10689b6..5cf6c4823021 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/servers.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/servers.go @@ -127,6 +127,7 @@ func (client ServersClient) CreatePreparer(resourceGroupName string, serverName func (client ServersClient) CreateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -209,6 +210,7 @@ func (client ServersClient) DeletePreparer(resourceGroupName string, serverName func (client ServersClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -274,7 +276,9 @@ func (client ServersClient) GetPreparer(resourceGroupName string, serverName str // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ServersClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -335,7 +339,9 @@ func (client ServersClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ServersClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -400,7 +406,9 @@ func (client ServersClient) ListByResourceGroupPreparer(resourceGroupName string // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client ServersClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -486,6 +494,7 @@ func (client ServersClient) UpdatePreparer(resourceGroupName string, serverName func (client ServersClient) UpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/version.go index ad996f2e2913..4c48d9bafd0d 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/postgresql/version.go @@ -19,10 +19,10 @@ package postgresql // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-postgresql/2017-04-30-preview" + return "Azure-SDK-For-Go/v11.1.1-beta arm-postgresql/2017-04-30-preview" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/redis/firewallrule.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/redis/firewallrule.go index aa21f17d3c04..edbd3011ccb3 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/redis/firewallrule.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/redis/firewallrule.go @@ -101,7 +101,9 @@ func (client FirewallRuleClient) CreateOrUpdatePreparer(resourceGroupName string // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client FirewallRuleClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -168,7 +170,9 @@ func (client FirewallRuleClient) DeletePreparer(resourceGroupName string, cacheN // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client FirewallRuleClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -234,7 +238,9 @@ func (client FirewallRuleClient) GetPreparer(resourceGroupName string, cacheName // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client FirewallRuleClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/redis/firewallrules.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/redis/firewallrules.go index d46bcbfde6f0..77d0ef93f74d 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/redis/firewallrules.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/redis/firewallrules.go @@ -87,7 +87,9 @@ func (client FirewallRulesClient) ListPreparer(resourceGroupName string, cacheNa // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client FirewallRulesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/redis/group.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/redis/group.go index e3c1cbf1f3e4..f06ab65c4b1e 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/redis/group.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/redis/group.go @@ -120,6 +120,7 @@ func (client GroupClient) CreatePreparer(resourceGroupName string, name string, func (client GroupClient) CreateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -201,6 +202,7 @@ func (client GroupClient) DeletePreparer(resourceGroupName string, name string, func (client GroupClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -295,6 +297,7 @@ func (client GroupClient) ExportDataPreparer(resourceGroupName string, name stri func (client GroupClient) ExportDataSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -363,7 +366,9 @@ func (client GroupClient) ForceRebootPreparer(resourceGroupName string, name str // ForceRebootSender sends the ForceReboot request. The method will close the // http.Response Body if it receives an error. func (client GroupClient) ForceRebootSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ForceRebootResponder handles the response to the ForceReboot request. The method always @@ -428,7 +433,9 @@ func (client GroupClient) GetPreparer(resourceGroupName string, name string) (*h // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client GroupClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -521,6 +528,7 @@ func (client GroupClient) ImportDataPreparer(resourceGroupName string, name stri func (client GroupClient) ImportDataSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -581,7 +589,9 @@ func (client GroupClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client GroupClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -714,7 +724,9 @@ func (client GroupClient) ListByResourceGroupPreparer(resourceGroupName string) // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client GroupClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -848,7 +860,9 @@ func (client GroupClient) ListKeysPreparer(resourceGroupName string, name string // ListKeysSender sends the ListKeys request. The method will close the // http.Response Body if it receives an error. func (client GroupClient) ListKeysSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListKeysResponder handles the response to the ListKeys request. The method always @@ -916,7 +930,9 @@ func (client GroupClient) RegenerateKeyPreparer(resourceGroupName string, name s // RegenerateKeySender sends the RegenerateKey request. The method will close the // http.Response Body if it receives an error. func (client GroupClient) RegenerateKeySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RegenerateKeyResponder handles the response to the RegenerateKey request. The method always @@ -984,7 +1000,9 @@ func (client GroupClient) UpdatePreparer(resourceGroupName string, name string, // UpdateSender sends the Update request. The method will close the // http.Response Body if it receives an error. func (client GroupClient) UpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateResponder handles the response to the Update request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/redis/operations.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/redis/operations.go index 897382b758bb..e8aa126bde3d 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/redis/operations.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/redis/operations.go @@ -79,7 +79,9 @@ func (client OperationsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client OperationsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/redis/patchschedules.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/redis/patchschedules.go index 760585c91a5e..ff3ae09277f3 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/redis/patchschedules.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/redis/patchschedules.go @@ -98,7 +98,9 @@ func (client PatchSchedulesClient) CreateOrUpdatePreparer(resourceGroupName stri // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client PatchSchedulesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -163,7 +165,9 @@ func (client PatchSchedulesClient) DeletePreparer(resourceGroupName string, name // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client PatchSchedulesClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -227,7 +231,9 @@ func (client PatchSchedulesClient) GetPreparer(resourceGroupName string, name st // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client PatchSchedulesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/redis/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/redis/version.go index a5d8e142794a..42da5cbdb724 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/redis/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/redis/version.go @@ -19,10 +19,10 @@ package redis // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-redis/2016-04-01" + return "Azure-SDK-For-Go/v11.1.1-beta arm-redis/2016-04-01" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/locks/managementlocks.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/locks/managementlocks.go index 6f4699dc5375..82df51de5771 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/locks/managementlocks.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/locks/managementlocks.go @@ -106,7 +106,9 @@ func (client ManagementLocksClient) CreateOrUpdateAtResourceGroupLevelPreparer(r // CreateOrUpdateAtResourceGroupLevelSender sends the CreateOrUpdateAtResourceGroupLevel request. The method will close the // http.Response Body if it receives an error. func (client ManagementLocksClient) CreateOrUpdateAtResourceGroupLevelSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateAtResourceGroupLevelResponder handles the response to the CreateOrUpdateAtResourceGroupLevel request. The method always @@ -193,7 +195,9 @@ func (client ManagementLocksClient) CreateOrUpdateAtResourceLevelPreparer(resour // CreateOrUpdateAtResourceLevelSender sends the CreateOrUpdateAtResourceLevel request. The method will close the // http.Response Body if it receives an error. func (client ManagementLocksClient) CreateOrUpdateAtResourceLevelSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateAtResourceLevelResponder handles the response to the CreateOrUpdateAtResourceLevel request. The method always @@ -269,7 +273,9 @@ func (client ManagementLocksClient) CreateOrUpdateAtSubscriptionLevelPreparer(lo // CreateOrUpdateAtSubscriptionLevelSender sends the CreateOrUpdateAtSubscriptionLevel request. The method will close the // http.Response Body if it receives an error. func (client ManagementLocksClient) CreateOrUpdateAtSubscriptionLevelSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateAtSubscriptionLevelResponder handles the response to the CreateOrUpdateAtSubscriptionLevel request. The method always @@ -344,7 +350,9 @@ func (client ManagementLocksClient) CreateOrUpdateByScopePreparer(scope string, // CreateOrUpdateByScopeSender sends the CreateOrUpdateByScope request. The method will close the // http.Response Body if it receives an error. func (client ManagementLocksClient) CreateOrUpdateByScopeSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // CreateOrUpdateByScopeResponder handles the response to the CreateOrUpdateByScope request. The method always @@ -419,7 +427,9 @@ func (client ManagementLocksClient) DeleteAtResourceGroupLevelPreparer(resourceG // DeleteAtResourceGroupLevelSender sends the DeleteAtResourceGroupLevel request. The method will close the // http.Response Body if it receives an error. func (client ManagementLocksClient) DeleteAtResourceGroupLevelSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteAtResourceGroupLevelResponder handles the response to the DeleteAtResourceGroupLevel request. The method always @@ -501,7 +511,9 @@ func (client ManagementLocksClient) DeleteAtResourceLevelPreparer(resourceGroupN // DeleteAtResourceLevelSender sends the DeleteAtResourceLevel request. The method will close the // http.Response Body if it receives an error. func (client ManagementLocksClient) DeleteAtResourceLevelSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteAtResourceLevelResponder handles the response to the DeleteAtResourceLevel request. The method always @@ -566,7 +578,9 @@ func (client ManagementLocksClient) DeleteAtSubscriptionLevelPreparer(lockName s // DeleteAtSubscriptionLevelSender sends the DeleteAtSubscriptionLevel request. The method will close the // http.Response Body if it receives an error. func (client ManagementLocksClient) DeleteAtSubscriptionLevelSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteAtSubscriptionLevelResponder handles the response to the DeleteAtSubscriptionLevel request. The method always @@ -629,7 +643,9 @@ func (client ManagementLocksClient) DeleteByScopePreparer(scope string, lockName // DeleteByScopeSender sends the DeleteByScope request. The method will close the // http.Response Body if it receives an error. func (client ManagementLocksClient) DeleteByScopeSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // DeleteByScopeResponder handles the response to the DeleteByScope request. The method always @@ -701,7 +717,9 @@ func (client ManagementLocksClient) GetAtResourceGroupLevelPreparer(resourceGrou // GetAtResourceGroupLevelSender sends the GetAtResourceGroupLevel request. The method will close the // http.Response Body if it receives an error. func (client ManagementLocksClient) GetAtResourceGroupLevelSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetAtResourceGroupLevelResponder handles the response to the GetAtResourceGroupLevel request. The method always @@ -780,7 +798,9 @@ func (client ManagementLocksClient) GetAtResourceLevelPreparer(resourceGroupName // GetAtResourceLevelSender sends the GetAtResourceLevel request. The method will close the // http.Response Body if it receives an error. func (client ManagementLocksClient) GetAtResourceLevelSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetAtResourceLevelResponder handles the response to the GetAtResourceLevel request. The method always @@ -844,7 +864,9 @@ func (client ManagementLocksClient) GetAtSubscriptionLevelPreparer(lockName stri // GetAtSubscriptionLevelSender sends the GetAtSubscriptionLevel request. The method will close the // http.Response Body if it receives an error. func (client ManagementLocksClient) GetAtSubscriptionLevelSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetAtSubscriptionLevelResponder handles the response to the GetAtSubscriptionLevel request. The method always @@ -908,7 +930,9 @@ func (client ManagementLocksClient) GetByScopePreparer(scope string, lockName st // GetByScopeSender sends the GetByScope request. The method will close the // http.Response Body if it receives an error. func (client ManagementLocksClient) GetByScopeSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetByScopeResponder handles the response to the GetByScope request. The method always @@ -984,7 +1008,9 @@ func (client ManagementLocksClient) ListAtResourceGroupLevelPreparer(resourceGro // ListAtResourceGroupLevelSender sends the ListAtResourceGroupLevel request. The method will close the // http.Response Body if it receives an error. func (client ManagementLocksClient) ListAtResourceGroupLevelSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAtResourceGroupLevelResponder handles the response to the ListAtResourceGroupLevel request. The method always @@ -1135,7 +1161,9 @@ func (client ManagementLocksClient) ListAtResourceLevelPreparer(resourceGroupNam // ListAtResourceLevelSender sends the ListAtResourceLevel request. The method will close the // http.Response Body if it receives an error. func (client ManagementLocksClient) ListAtResourceLevelSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAtResourceLevelResponder handles the response to the ListAtResourceLevel request. The method always @@ -1270,7 +1298,9 @@ func (client ManagementLocksClient) ListAtSubscriptionLevelPreparer(filter strin // ListAtSubscriptionLevelSender sends the ListAtSubscriptionLevel request. The method will close the // http.Response Body if it receives an error. func (client ManagementLocksClient) ListAtSubscriptionLevelSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAtSubscriptionLevelResponder handles the response to the ListAtSubscriptionLevel request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/locks/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/locks/version.go index 52819ed906c5..7341b8e160f6 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/locks/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/locks/version.go @@ -19,10 +19,10 @@ package locks // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-locks/2016-09-01" + return "Azure-SDK-For-Go/v11.1.1-beta arm-locks/2016-09-01" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/deploymentoperations.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/deploymentoperations.go index 116c8b728e06..eaa3a35899b5 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/deploymentoperations.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/deploymentoperations.go @@ -102,7 +102,9 @@ func (client DeploymentOperationsClient) GetPreparer(resourceGroupName string, d // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client DeploymentOperationsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -183,7 +185,9 @@ func (client DeploymentOperationsClient) ListPreparer(resourceGroupName string, // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client DeploymentOperationsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/deployments.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/deployments.go index 9941f6096115..3c8b69a2c6ba 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/deployments.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/deployments.go @@ -103,7 +103,9 @@ func (client DeploymentsClient) CancelPreparer(resourceGroupName string, deploym // CancelSender sends the Cancel request. The method will close the // http.Response Body if it receives an error. func (client DeploymentsClient) CancelSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CancelResponder handles the response to the Cancel request. The method always @@ -180,7 +182,9 @@ func (client DeploymentsClient) CheckExistencePreparer(resourceGroupName string, // CheckExistenceSender sends the CheckExistence request. The method will close the // http.Response Body if it receives an error. func (client DeploymentsClient) CheckExistenceSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CheckExistenceResponder handles the response to the CheckExistence request. The method always @@ -287,6 +291,7 @@ func (client DeploymentsClient) CreateOrUpdatePreparer(resourceGroupName string, func (client DeploymentsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -390,6 +395,7 @@ func (client DeploymentsClient) DeletePreparer(resourceGroupName string, deploym func (client DeploymentsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -467,7 +473,9 @@ func (client DeploymentsClient) ExportTemplatePreparer(resourceGroupName string, // ExportTemplateSender sends the ExportTemplate request. The method will close the // http.Response Body if it receives an error. func (client DeploymentsClient) ExportTemplateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ExportTemplateResponder handles the response to the ExportTemplate request. The method always @@ -545,7 +553,9 @@ func (client DeploymentsClient) GetPreparer(resourceGroupName string, deployment // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client DeploymentsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -625,7 +635,9 @@ func (client DeploymentsClient) ListByResourceGroupPreparer(resourceGroupName st // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client DeploymentsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -782,7 +794,9 @@ func (client DeploymentsClient) ValidatePreparer(resourceGroupName string, deplo // ValidateSender sends the Validate request. The method will close the // http.Response Body if it receives an error. func (client DeploymentsClient) ValidateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ValidateResponder handles the response to the Validate request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/group.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/group.go index 2eac7ac35478..129f7d64f642 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/group.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/group.go @@ -102,7 +102,9 @@ func (client GroupClient) CheckExistencePreparer(resourceGroupName string, resou // CheckExistenceSender sends the CheckExistence request. The method will close the // http.Response Body if it receives an error. func (client GroupClient) CheckExistenceSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CheckExistenceResponder handles the response to the CheckExistence request. The method always @@ -165,7 +167,9 @@ func (client GroupClient) CheckExistenceByIDPreparer(resourceID string) (*http.R // CheckExistenceByIDSender sends the CheckExistenceByID request. The method will close the // http.Response Body if it receives an error. func (client GroupClient) CheckExistenceByIDSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // CheckExistenceByIDResponder handles the response to the CheckExistenceByID request. The method always @@ -267,6 +271,7 @@ func (client GroupClient) CreateOrUpdatePreparer(resourceGroupName string, resou func (client GroupClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -360,6 +365,7 @@ func (client GroupClient) CreateOrUpdateByIDPreparer(resourceID string, paramete func (client GroupClient) CreateOrUpdateByIDSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -457,6 +463,7 @@ func (client GroupClient) DeletePreparer(resourceGroupName string, resourceProvi func (client GroupClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -536,6 +543,7 @@ func (client GroupClient) DeleteByIDPreparer(resourceID string, cancel <-chan st func (client GroupClient) DeleteByIDSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -613,7 +621,9 @@ func (client GroupClient) GetPreparer(resourceGroupName string, resourceProvider // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client GroupClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -677,7 +687,9 @@ func (client GroupClient) GetByIDPreparer(resourceID string) (*http.Request, err // GetByIDSender sends the GetByID request. The method will close the // http.Response Body if it receives an error. func (client GroupClient) GetByIDSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetByIDResponder handles the response to the GetByID request. The method always @@ -750,7 +762,9 @@ func (client GroupClient) ListPreparer(filter string, expand string, top *int32) // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client GroupClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -902,7 +916,9 @@ func (client GroupClient) ListByResourceGroupPreparer(resourceGroupName string, // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client GroupClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -1068,6 +1084,7 @@ func (client GroupClient) MoveResourcesPreparer(sourceResourceGroupName string, func (client GroupClient) MoveResourcesSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1165,6 +1182,7 @@ func (client GroupClient) ValidateMoveResourcesPreparer(sourceResourceGroupName func (client GroupClient) ValidateMoveResourcesSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/groups.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/groups.go index 3eae2eab75c2..49a98e738d97 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/groups.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/groups.go @@ -95,7 +95,9 @@ func (client GroupsClient) CheckExistencePreparer(resourceGroupName string) (*ht // CheckExistenceSender sends the CheckExistence request. The method will close the // http.Response Body if it receives an error. func (client GroupsClient) CheckExistenceSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CheckExistenceResponder handles the response to the CheckExistence request. The method always @@ -171,7 +173,9 @@ func (client GroupsClient) CreateOrUpdatePreparer(resourceGroupName string, para // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client GroupsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -264,6 +268,7 @@ func (client GroupsClient) DeletePreparer(resourceGroupName string, cancel <-cha func (client GroupsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -338,7 +343,9 @@ func (client GroupsClient) ExportTemplatePreparer(resourceGroupName string, para // ExportTemplateSender sends the ExportTemplate request. The method will close the // http.Response Body if it receives an error. func (client GroupsClient) ExportTemplateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ExportTemplateResponder handles the response to the ExportTemplate request. The method always @@ -410,7 +417,9 @@ func (client GroupsClient) GetPreparer(resourceGroupName string) (*http.Request, // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client GroupsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -480,7 +489,9 @@ func (client GroupsClient) ListPreparer(filter string, top *int32) (*http.Reques // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client GroupsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -625,7 +636,9 @@ func (client GroupsClient) UpdatePreparer(resourceGroupName string, parameters G // UpdateSender sends the Update request. The method will close the // http.Response Body if it receives an error. func (client GroupsClient) UpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateResponder handles the response to the Update request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/providers.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/providers.go index 173b4626b247..746aa9da2ed2 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/providers.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/providers.go @@ -90,7 +90,9 @@ func (client ProvidersClient) GetPreparer(resourceProviderNamespace string, expa // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ProvidersClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -161,7 +163,9 @@ func (client ProvidersClient) ListPreparer(top *int32, expand string) (*http.Req // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ProvidersClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -294,7 +298,9 @@ func (client ProvidersClient) RegisterPreparer(resourceProviderNamespace string) // RegisterSender sends the Register request. The method will close the // http.Response Body if it receives an error. func (client ProvidersClient) RegisterSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RegisterResponder handles the response to the Register request. The method always @@ -358,7 +364,9 @@ func (client ProvidersClient) UnregisterPreparer(resourceProviderNamespace strin // UnregisterSender sends the Unregister request. The method will close the // http.Response Body if it receives an error. func (client ProvidersClient) UnregisterSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UnregisterResponder handles the response to the Unregister request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/tags.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/tags.go index a90b390affae..5c44391dd2a3 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/tags.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/tags.go @@ -87,7 +87,9 @@ func (client TagsClient) CreateOrUpdatePreparer(tagName string) (*http.Request, // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client TagsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -152,7 +154,9 @@ func (client TagsClient) CreateOrUpdateValuePreparer(tagName string, tagValue st // CreateOrUpdateValueSender sends the CreateOrUpdateValue request. The method will close the // http.Response Body if it receives an error. func (client TagsClient) CreateOrUpdateValueSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateValueResponder handles the response to the CreateOrUpdateValue request. The method always @@ -216,7 +220,9 @@ func (client TagsClient) DeletePreparer(tagName string) (*http.Request, error) { // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client TagsClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -280,7 +286,9 @@ func (client TagsClient) DeleteValuePreparer(tagName string, tagValue string) (* // DeleteValueSender sends the DeleteValue request. The method will close the // http.Response Body if it receives an error. func (client TagsClient) DeleteValueSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteValueResponder handles the response to the DeleteValue request. The method always @@ -340,7 +348,9 @@ func (client TagsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client TagsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/version.go index f1ff686a7f4b..2cd9235281be 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/resources/version.go @@ -19,10 +19,10 @@ package resources // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-resources/2017-05-10" + return "Azure-SDK-For-Go/v11.1.1-beta arm-resources/2017-05-10" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/subscriptions/group.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/subscriptions/group.go index 77000f7ee260..7bc8e7c6969b 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/subscriptions/group.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/subscriptions/group.go @@ -87,7 +87,9 @@ func (client GroupClient) GetPreparer(subscriptionID string) (*http.Request, err // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client GroupClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -144,7 +146,9 @@ func (client GroupClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client GroupClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -277,7 +281,9 @@ func (client GroupClient) ListLocationsPreparer(subscriptionID string) (*http.Re // ListLocationsSender sends the ListLocations request. The method will close the // http.Response Body if it receives an error. func (client GroupClient) ListLocationsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListLocationsResponder handles the response to the ListLocations request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/subscriptions/tenants.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/subscriptions/tenants.go index 2cd34657eef1..78b92110dac5 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/subscriptions/tenants.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/subscriptions/tenants.go @@ -81,7 +81,9 @@ func (client TenantsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client TenantsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/subscriptions/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/subscriptions/version.go index 4413c7b90d80..e2fcaf5c4d3b 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/subscriptions/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/resources/subscriptions/version.go @@ -19,10 +19,10 @@ package subscriptions // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-subscriptions/2016-06-01" + return "Azure-SDK-For-Go/v11.1.1-beta arm-subscriptions/2016-06-01" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/scheduler/jobcollections.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/scheduler/jobcollections.go index 47acfe0505b9..cb9bdbb09efe 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/scheduler/jobcollections.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/scheduler/jobcollections.go @@ -90,7 +90,9 @@ func (client JobCollectionsClient) CreateOrUpdatePreparer(resourceGroupName stri // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client JobCollectionsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -171,6 +173,7 @@ func (client JobCollectionsClient) DeletePreparer(resourceGroupName string, jobC func (client JobCollectionsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -252,6 +255,7 @@ func (client JobCollectionsClient) DisablePreparer(resourceGroupName string, job func (client JobCollectionsClient) DisableSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -333,6 +337,7 @@ func (client JobCollectionsClient) EnablePreparer(resourceGroupName string, jobC func (client JobCollectionsClient) EnableSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -397,7 +402,9 @@ func (client JobCollectionsClient) GetPreparer(resourceGroupName string, jobColl // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client JobCollectionsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -461,7 +468,9 @@ func (client JobCollectionsClient) ListByResourceGroupPreparer(resourceGroupName // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client JobCollectionsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -591,7 +600,9 @@ func (client JobCollectionsClient) ListBySubscriptionPreparer() (*http.Request, // ListBySubscriptionSender sends the ListBySubscription request. The method will close the // http.Response Body if it receives an error. func (client JobCollectionsClient) ListBySubscriptionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListBySubscriptionResponder handles the response to the ListBySubscription request. The method always @@ -728,7 +739,9 @@ func (client JobCollectionsClient) PatchPreparer(resourceGroupName string, jobCo // PatchSender sends the Patch request. The method will close the // http.Response Body if it receives an error. func (client JobCollectionsClient) PatchSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // PatchResponder handles the response to the Patch request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/scheduler/jobs.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/scheduler/jobs.go index 86300a7ac427..b56ea162be95 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/scheduler/jobs.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/scheduler/jobs.go @@ -92,7 +92,9 @@ func (client JobsClient) CreateOrUpdatePreparer(resourceGroupName string, jobCol // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client JobsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -158,7 +160,9 @@ func (client JobsClient) DeletePreparer(resourceGroupName string, jobCollectionN // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client JobsClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -223,7 +227,9 @@ func (client JobsClient) GetPreparer(resourceGroupName string, jobCollectionName // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client JobsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -308,7 +314,9 @@ func (client JobsClient) ListPreparer(resourceGroupName string, jobCollectionNam // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client JobsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -463,7 +471,9 @@ func (client JobsClient) ListJobHistoryPreparer(resourceGroupName string, jobCol // ListJobHistorySender sends the ListJobHistory request. The method will close the // http.Response Body if it receives an error. func (client JobsClient) ListJobHistorySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListJobHistoryResponder handles the response to the ListJobHistory request. The method always @@ -601,7 +611,9 @@ func (client JobsClient) PatchPreparer(resourceGroupName string, jobCollectionNa // PatchSender sends the Patch request. The method will close the // http.Response Body if it receives an error. func (client JobsClient) PatchSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // PatchResponder handles the response to the Patch request. The method always @@ -667,7 +679,9 @@ func (client JobsClient) RunPreparer(resourceGroupName string, jobCollectionName // RunSender sends the Run request. The method will close the // http.Response Body if it receives an error. func (client JobsClient) RunSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RunResponder handles the response to the Run request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/scheduler/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/scheduler/version.go index 211ca2e0052d..468e2c34df29 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/scheduler/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/scheduler/version.go @@ -19,10 +19,10 @@ package scheduler // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-scheduler/2016-03-01" + return "Azure-SDK-For-Go/v11.1.1-beta arm-scheduler/2016-03-01" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/search/adminkeys.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/search/adminkeys.go index 5cfa9c79a1c6..543715e96500 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/search/adminkeys.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/search/adminkeys.go @@ -95,7 +95,9 @@ func (client AdminKeysClient) GetPreparer(resourceGroupName string, searchServic // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client AdminKeysClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -169,7 +171,9 @@ func (client AdminKeysClient) RegeneratePreparer(resourceGroupName string, searc // RegenerateSender sends the Regenerate request. The method will close the // http.Response Body if it receives an error. func (client AdminKeysClient) RegenerateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RegenerateResponder handles the response to the Regenerate request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/search/querykeys.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/search/querykeys.go index b96f9fbca3cb..0ce14144cd24 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/search/querykeys.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/search/querykeys.go @@ -97,7 +97,9 @@ func (client QueryKeysClient) CreatePreparer(resourceGroupName string, searchSer // CreateSender sends the Create request. The method will close the // http.Response Body if it receives an error. func (client QueryKeysClient) CreateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateResponder handles the response to the Create request. The method always @@ -172,7 +174,9 @@ func (client QueryKeysClient) DeletePreparer(resourceGroupName string, searchSer // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client QueryKeysClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -243,7 +247,9 @@ func (client QueryKeysClient) ListBySearchServicePreparer(resourceGroupName stri // ListBySearchServiceSender sends the ListBySearchService request. The method will close the // http.Response Body if it receives an error. func (client QueryKeysClient) ListBySearchServiceSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListBySearchServiceResponder handles the response to the ListBySearchService request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/search/services.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/search/services.go index bdcb5e0702c4..d5abc2ccc254 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/search/services.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/search/services.go @@ -103,7 +103,9 @@ func (client ServicesClient) CheckNameAvailabilityPreparer(checkNameAvailability // CheckNameAvailabilitySender sends the CheckNameAvailability request. The method will close the // http.Response Body if it receives an error. func (client ServicesClient) CheckNameAvailabilitySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CheckNameAvailabilityResponder handles the response to the CheckNameAvailability request. The method always @@ -218,6 +220,7 @@ func (client ServicesClient) CreateOrUpdatePreparer(resourceGroupName string, se func (client ServicesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -290,7 +293,9 @@ func (client ServicesClient) DeletePreparer(resourceGroupName string, searchServ // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client ServicesClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -361,7 +366,9 @@ func (client ServicesClient) GetPreparer(resourceGroupName string, searchService // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ServicesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -431,7 +438,9 @@ func (client ServicesClient) ListByResourceGroupPreparer(resourceGroupName strin // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client ServicesClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/search/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/search/version.go index 69a89c40390c..4356a640ab5d 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/search/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/search/version.go @@ -19,10 +19,10 @@ package search // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-search/2015-08-19" + return "Azure-SDK-For-Go/v11.1.1-beta arm-search/2015-08-19" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/eventhubs.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/eventhubs.go index 23b6487b0018..d5c9f6c5127c 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/eventhubs.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/eventhubs.go @@ -98,7 +98,9 @@ func (client EventHubsClient) ListByNamespacePreparer(resourceGroupName string, // ListByNamespaceSender sends the ListByNamespace request. The method will close the // http.Response Body if it receives an error. func (client EventHubsClient) ListByNamespaceSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByNamespaceResponder handles the response to the ListByNamespace request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/models.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/models.go index a2a7db653efc..844e7d46a808 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/models.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/models.go @@ -220,17 +220,6 @@ type Eventhub struct { *EventhubProperties `json:"properties,omitempty"` } -// EventhubProperties is properties supplied to the Create Or Update Event Hub operation. -type EventhubProperties struct { - PartitionIds *[]string `json:"partitionIds,omitempty"` - CreatedAt *date.Time `json:"createdAt,omitempty"` - UpdatedAt *date.Time `json:"updatedAt,omitempty"` - MessageRetentionInDays *int64 `json:"messageRetentionInDays,omitempty"` - PartitionCount *int64 `json:"partitionCount,omitempty"` - Status EntityStatus `json:"status,omitempty"` - CaptureDescription *CaptureDescription `json:"captureDescription,omitempty"` -} - // EventHubListResult is the result of the List EventHubs operation. type EventHubListResult struct { autorest.Response `json:"-"` @@ -250,6 +239,17 @@ func (client EventHubListResult) EventHubListResultPreparer() (*http.Request, er autorest.WithBaseURL(to.String(client.NextLink))) } +// EventhubProperties is properties supplied to the Create Or Update Event Hub operation. +type EventhubProperties struct { + PartitionIds *[]string `json:"partitionIds,omitempty"` + CreatedAt *date.Time `json:"createdAt,omitempty"` + UpdatedAt *date.Time `json:"updatedAt,omitempty"` + MessageRetentionInDays *int64 `json:"messageRetentionInDays,omitempty"` + PartitionCount *int64 `json:"partitionCount,omitempty"` + Status EntityStatus `json:"status,omitempty"` + CaptureDescription *CaptureDescription `json:"captureDescription,omitempty"` +} + // MessageCountDetails is message Count Details. type MessageCountDetails struct { ActiveMessageCount *int64 `json:"activeMessageCount,omitempty"` @@ -302,12 +302,6 @@ type PremiumMessagingRegions struct { Properties *PremiumMessagingRegionsProperties `json:"properties,omitempty"` } -// PremiumMessagingRegionsProperties is -type PremiumMessagingRegionsProperties struct { - Code *string `json:"code,omitempty"` - FullName *string `json:"fullName,omitempty"` -} - // PremiumMessagingRegionsListResult is the response of the List PremiumMessagingRegions operation. type PremiumMessagingRegionsListResult struct { autorest.Response `json:"-"` @@ -327,6 +321,12 @@ func (client PremiumMessagingRegionsListResult) PremiumMessagingRegionsListResul autorest.WithBaseURL(to.String(client.NextLink))) } +// PremiumMessagingRegionsProperties is +type PremiumMessagingRegionsProperties struct { + Code *string `json:"code,omitempty"` + FullName *string `json:"fullName,omitempty"` +} + // RegenerateAccessKeyParameters is parameters supplied to the Regenerate Authorization Rule operation, specifies which // key neeeds to be reset. type RegenerateAccessKeyParameters struct { @@ -395,11 +395,6 @@ type SBAuthorizationRule struct { *SBAuthorizationRuleProperties `json:"properties,omitempty"` } -// SBAuthorizationRuleProperties is authorizationRule properties. -type SBAuthorizationRuleProperties struct { - Rights *[]AccessRights `json:"rights,omitempty"` -} - // SBAuthorizationRuleListResult is the response to the List Namespace operation. type SBAuthorizationRuleListResult struct { autorest.Response `json:"-"` @@ -419,6 +414,11 @@ func (client SBAuthorizationRuleListResult) SBAuthorizationRuleListResultPrepare autorest.WithBaseURL(to.String(client.NextLink))) } +// SBAuthorizationRuleProperties is authorizationRule properties. +type SBAuthorizationRuleProperties struct { + Rights *[]AccessRights `json:"rights,omitempty"` +} + // SBNamespace is description of a namespace resource. type SBNamespace struct { autorest.Response `json:"-"` diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/namespaces.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/namespaces.go index 932fd0b017d4..051f38850a06 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/namespaces.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/namespaces.go @@ -94,7 +94,9 @@ func (client NamespacesClient) CheckNameAvailabilityMethodPreparer(parameters Ch // CheckNameAvailabilityMethodSender sends the CheckNameAvailabilityMethod request. The method will close the // http.Response Body if it receives an error. func (client NamespacesClient) CheckNameAvailabilityMethodSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CheckNameAvailabilityMethodResponder handles the response to the CheckNameAvailabilityMethod request. The method always @@ -189,6 +191,7 @@ func (client NamespacesClient) CreateOrUpdatePreparer(resourceGroupName string, func (client NamespacesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -270,7 +273,9 @@ func (client NamespacesClient) CreateOrUpdateAuthorizationRulePreparer(resourceG // CreateOrUpdateAuthorizationRuleSender sends the CreateOrUpdateAuthorizationRule request. The method will close the // http.Response Body if it receives an error. func (client NamespacesClient) CreateOrUpdateAuthorizationRuleSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateAuthorizationRuleResponder handles the response to the CreateOrUpdateAuthorizationRule request. The method always @@ -365,6 +370,7 @@ func (client NamespacesClient) DeletePreparer(resourceGroupName string, namespac func (client NamespacesClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -443,7 +449,9 @@ func (client NamespacesClient) DeleteAuthorizationRulePreparer(resourceGroupName // DeleteAuthorizationRuleSender sends the DeleteAuthorizationRule request. The method will close the // http.Response Body if it receives an error. func (client NamespacesClient) DeleteAuthorizationRuleSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteAuthorizationRuleResponder handles the response to the DeleteAuthorizationRule request. The method always @@ -517,7 +525,9 @@ func (client NamespacesClient) GetPreparer(resourceGroupName string, namespaceNa // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client NamespacesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -596,7 +606,9 @@ func (client NamespacesClient) GetAuthorizationRulePreparer(resourceGroupName st // GetAuthorizationRuleSender sends the GetAuthorizationRule request. The method will close the // http.Response Body if it receives an error. func (client NamespacesClient) GetAuthorizationRuleSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetAuthorizationRuleResponder handles the response to the GetAuthorizationRule request. The method always @@ -657,7 +669,9 @@ func (client NamespacesClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client NamespacesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -801,7 +815,9 @@ func (client NamespacesClient) ListAuthorizationRulesPreparer(resourceGroupName // ListAuthorizationRulesSender sends the ListAuthorizationRules request. The method will close the // http.Response Body if it receives an error. func (client NamespacesClient) ListAuthorizationRulesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAuthorizationRulesResponder handles the response to the ListAuthorizationRules request. The method always @@ -941,7 +957,9 @@ func (client NamespacesClient) ListByResourceGroupPreparer(resourceGroupName str // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client NamespacesClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -1089,7 +1107,9 @@ func (client NamespacesClient) ListKeysPreparer(resourceGroupName string, namesp // ListKeysSender sends the ListKeys request. The method will close the // http.Response Body if it receives an error. func (client NamespacesClient) ListKeysSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListKeysResponder handles the response to the ListKeys request. The method always @@ -1171,7 +1191,9 @@ func (client NamespacesClient) RegenerateKeysPreparer(resourceGroupName string, // RegenerateKeysSender sends the RegenerateKeys request. The method will close the // http.Response Body if it receives an error. func (client NamespacesClient) RegenerateKeysSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RegenerateKeysResponder handles the response to the RegenerateKeys request. The method always @@ -1250,7 +1272,9 @@ func (client NamespacesClient) UpdatePreparer(resourceGroupName string, namespac // UpdateSender sends the Update request. The method will close the // http.Response Body if it receives an error. func (client NamespacesClient) UpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateResponder handles the response to the Update request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/operations.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/operations.go index 415089e5324a..967c8d324334 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/operations.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/operations.go @@ -79,7 +79,9 @@ func (client OperationsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client OperationsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/premiummessagingregions.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/premiummessagingregions.go index 94c4296ee85d..2221d402de14 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/premiummessagingregions.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/premiummessagingregions.go @@ -83,7 +83,9 @@ func (client PremiumMessagingRegionsClient) ListPreparer() (*http.Request, error // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client PremiumMessagingRegionsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/queues.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/queues.go index 9c62f023fd98..66476c365faa 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/queues.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/queues.go @@ -104,7 +104,9 @@ func (client QueuesClient) CreateOrUpdatePreparer(resourceGroupName string, name // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client QueuesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -189,7 +191,9 @@ func (client QueuesClient) CreateOrUpdateAuthorizationRulePreparer(resourceGroup // CreateOrUpdateAuthorizationRuleSender sends the CreateOrUpdateAuthorizationRule request. The method will close the // http.Response Body if it receives an error. func (client QueuesClient) CreateOrUpdateAuthorizationRuleSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateAuthorizationRuleResponder handles the response to the CreateOrUpdateAuthorizationRule request. The method always @@ -268,7 +272,9 @@ func (client QueuesClient) DeletePreparer(resourceGroupName string, namespaceNam // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client QueuesClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -349,7 +355,9 @@ func (client QueuesClient) DeleteAuthorizationRulePreparer(resourceGroupName str // DeleteAuthorizationRuleSender sends the DeleteAuthorizationRule request. The method will close the // http.Response Body if it receives an error. func (client QueuesClient) DeleteAuthorizationRuleSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteAuthorizationRuleResponder handles the response to the DeleteAuthorizationRule request. The method always @@ -427,7 +435,9 @@ func (client QueuesClient) GetPreparer(resourceGroupName string, namespaceName s // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client QueuesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -509,7 +519,9 @@ func (client QueuesClient) GetAuthorizationRulePreparer(resourceGroupName string // GetAuthorizationRuleSender sends the GetAuthorizationRule request. The method will close the // http.Response Body if it receives an error. func (client QueuesClient) GetAuthorizationRuleSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetAuthorizationRuleResponder handles the response to the GetAuthorizationRule request. The method always @@ -588,7 +600,9 @@ func (client QueuesClient) ListAuthorizationRulesPreparer(resourceGroupName stri // ListAuthorizationRulesSender sends the ListAuthorizationRules request. The method will close the // http.Response Body if it receives an error. func (client QueuesClient) ListAuthorizationRulesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAuthorizationRulesResponder handles the response to the ListAuthorizationRules request. The method always @@ -732,7 +746,9 @@ func (client QueuesClient) ListByNamespacePreparer(resourceGroupName string, nam // ListByNamespaceSender sends the ListByNamespace request. The method will close the // http.Response Body if it receives an error. func (client QueuesClient) ListByNamespaceSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByNamespaceResponder handles the response to the ListByNamespace request. The method always @@ -883,7 +899,9 @@ func (client QueuesClient) ListKeysPreparer(resourceGroupName string, namespaceN // ListKeysSender sends the ListKeys request. The method will close the // http.Response Body if it receives an error. func (client QueuesClient) ListKeysSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListKeysResponder handles the response to the ListKeys request. The method always @@ -968,7 +986,9 @@ func (client QueuesClient) RegenerateKeysPreparer(resourceGroupName string, name // RegenerateKeysSender sends the RegenerateKeys request. The method will close the // http.Response Body if it receives an error. func (client QueuesClient) RegenerateKeysSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RegenerateKeysResponder handles the response to the RegenerateKeys request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/regions.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/regions.go index a3ee88bebddf..b4a4dac0b4ce 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/regions.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/regions.go @@ -93,7 +93,9 @@ func (client RegionsClient) ListBySkuPreparer(sku string) (*http.Request, error) // ListBySkuSender sends the ListBySku request. The method will close the // http.Response Body if it receives an error. func (client RegionsClient) ListBySkuSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListBySkuResponder handles the response to the ListBySku request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/rules.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/rules.go index b00e8e3f9e2a..9c4ca7673e9a 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/rules.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/rules.go @@ -111,7 +111,9 @@ func (client RulesClient) CreateOrUpdatePreparer(resourceGroupName string, names // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client RulesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -196,7 +198,9 @@ func (client RulesClient) DeletePreparer(resourceGroupName string, namespaceName // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client RulesClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -280,7 +284,9 @@ func (client RulesClient) GetPreparer(resourceGroupName string, namespaceName st // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client RulesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -362,7 +368,9 @@ func (client RulesClient) ListBySubscriptionsPreparer(resourceGroupName string, // ListBySubscriptionsSender sends the ListBySubscriptions request. The method will close the // http.Response Body if it receives an error. func (client RulesClient) ListBySubscriptionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListBySubscriptionsResponder handles the response to the ListBySubscriptions request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/subscriptions.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/subscriptions.go index 4ec7658e493f..0bb495fe2edf 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/subscriptions.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/subscriptions.go @@ -108,7 +108,9 @@ func (client SubscriptionsClient) CreateOrUpdatePreparer(resourceGroupName strin // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client SubscriptionsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -190,7 +192,9 @@ func (client SubscriptionsClient) DeletePreparer(resourceGroupName string, names // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client SubscriptionsClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -271,7 +275,9 @@ func (client SubscriptionsClient) GetPreparer(resourceGroupName string, namespac // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client SubscriptionsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -350,7 +356,9 @@ func (client SubscriptionsClient) ListByTopicPreparer(resourceGroupName string, // ListByTopicSender sends the ListByTopic request. The method will close the // http.Response Body if it receives an error. func (client SubscriptionsClient) ListByTopicSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByTopicResponder handles the response to the ListByTopic request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/topics.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/topics.go index 5fb582f66d64..930b2998a018 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/topics.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/topics.go @@ -104,7 +104,9 @@ func (client TopicsClient) CreateOrUpdatePreparer(resourceGroupName string, name // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client TopicsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -189,7 +191,9 @@ func (client TopicsClient) CreateOrUpdateAuthorizationRulePreparer(resourceGroup // CreateOrUpdateAuthorizationRuleSender sends the CreateOrUpdateAuthorizationRule request. The method will close the // http.Response Body if it receives an error. func (client TopicsClient) CreateOrUpdateAuthorizationRuleSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateAuthorizationRuleResponder handles the response to the CreateOrUpdateAuthorizationRule request. The method always @@ -268,7 +272,9 @@ func (client TopicsClient) DeletePreparer(resourceGroupName string, namespaceNam // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client TopicsClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -349,7 +355,9 @@ func (client TopicsClient) DeleteAuthorizationRulePreparer(resourceGroupName str // DeleteAuthorizationRuleSender sends the DeleteAuthorizationRule request. The method will close the // http.Response Body if it receives an error. func (client TopicsClient) DeleteAuthorizationRuleSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteAuthorizationRuleResponder handles the response to the DeleteAuthorizationRule request. The method always @@ -427,7 +435,9 @@ func (client TopicsClient) GetPreparer(resourceGroupName string, namespaceName s // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client TopicsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -509,7 +519,9 @@ func (client TopicsClient) GetAuthorizationRulePreparer(resourceGroupName string // GetAuthorizationRuleSender sends the GetAuthorizationRule request. The method will close the // http.Response Body if it receives an error. func (client TopicsClient) GetAuthorizationRuleSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetAuthorizationRuleResponder handles the response to the GetAuthorizationRule request. The method always @@ -588,7 +600,9 @@ func (client TopicsClient) ListAuthorizationRulesPreparer(resourceGroupName stri // ListAuthorizationRulesSender sends the ListAuthorizationRules request. The method will close the // http.Response Body if it receives an error. func (client TopicsClient) ListAuthorizationRulesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAuthorizationRulesResponder handles the response to the ListAuthorizationRules request. The method always @@ -732,7 +746,9 @@ func (client TopicsClient) ListByNamespacePreparer(resourceGroupName string, nam // ListByNamespaceSender sends the ListByNamespace request. The method will close the // http.Response Body if it receives an error. func (client TopicsClient) ListByNamespaceSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByNamespaceResponder handles the response to the ListByNamespace request. The method always @@ -883,7 +899,9 @@ func (client TopicsClient) ListKeysPreparer(resourceGroupName string, namespaceN // ListKeysSender sends the ListKeys request. The method will close the // http.Response Body if it receives an error. func (client TopicsClient) ListKeysSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListKeysResponder handles the response to the ListKeys request. The method always @@ -968,7 +986,9 @@ func (client TopicsClient) RegenerateKeysPreparer(resourceGroupName string, name // RegenerateKeysSender sends the RegenerateKeys request. The method will close the // http.Response Body if it receives an error. func (client TopicsClient) RegenerateKeysSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RegenerateKeysResponder handles the response to the RegenerateKeys request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/version.go index 1d881d2758a4..281a3aa4eb55 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/servicebus/version.go @@ -19,10 +19,10 @@ package servicebus // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-servicebus/2017-04-01" + return "Azure-SDK-For-Go/v11.1.1-beta arm-servicebus/2017-04-01" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/backuplongtermretentionpolicies.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/backuplongtermretentionpolicies.go index cd301e146af1..e76ac866bb02 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/backuplongtermretentionpolicies.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/backuplongtermretentionpolicies.go @@ -125,6 +125,7 @@ func (client BackupLongTermRetentionPoliciesClient) CreateOrUpdatePreparer(resou func (client BackupLongTermRetentionPoliciesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -194,7 +195,9 @@ func (client BackupLongTermRetentionPoliciesClient) GetPreparer(resourceGroupNam // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client BackupLongTermRetentionPoliciesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/backuplongtermretentionvaults.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/backuplongtermretentionvaults.go index 400b0b3ca283..b77b0202662a 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/backuplongtermretentionvaults.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/backuplongtermretentionvaults.go @@ -124,6 +124,7 @@ func (client BackupLongTermRetentionVaultsClient) CreateOrUpdatePreparer(resourc func (client BackupLongTermRetentionVaultsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -192,7 +193,9 @@ func (client BackupLongTermRetentionVaultsClient) GetPreparer(resourceGroupName // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client BackupLongTermRetentionVaultsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/capabilities.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/capabilities.go index d52f57b6c7af..34580d75889a 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/capabilities.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/capabilities.go @@ -88,7 +88,9 @@ func (client CapabilitiesClient) ListByLocationPreparer(locationID string) (*htt // ListByLocationSender sends the ListByLocation request. The method will close the // http.Response Body if it receives an error. func (client CapabilitiesClient) ListByLocationSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByLocationResponder handles the response to the ListByLocation request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/databaseblobauditingpolicies.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/databaseblobauditingpolicies.go index 8f9274f57b2e..675ea0f6695b 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/databaseblobauditingpolicies.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/databaseblobauditingpolicies.go @@ -97,7 +97,9 @@ func (client DatabaseBlobAuditingPoliciesClient) CreateOrUpdatePreparer(resource // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client DatabaseBlobAuditingPoliciesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -166,7 +168,9 @@ func (client DatabaseBlobAuditingPoliciesClient) GetPreparer(resourceGroupName s // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client DatabaseBlobAuditingPoliciesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/databaseoperations.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/databaseoperations.go index d0cfc625df35..62ec4e652556 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/databaseoperations.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/databaseoperations.go @@ -94,7 +94,9 @@ func (client DatabaseOperationsClient) CancelPreparer(resourceGroupName string, // CancelSender sends the Cancel request. The method will close the // http.Response Body if it receives an error. func (client DatabaseOperationsClient) CancelSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CancelResponder handles the response to the Cancel request. The method always @@ -161,7 +163,9 @@ func (client DatabaseOperationsClient) ListByDatabasePreparer(resourceGroupName // ListByDatabaseSender sends the ListByDatabase request. The method will close the // http.Response Body if it receives an error. func (client DatabaseOperationsClient) ListByDatabaseSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByDatabaseResponder handles the response to the ListByDatabase request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/databases.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/databases.go index 39a186f6fd01..dbaaef7b11c7 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/databases.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/databases.go @@ -124,6 +124,7 @@ func (client DatabasesClient) CreateImportOperationPreparer(resourceGroupName st func (client DatabasesClient) CreateImportOperationSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -212,6 +213,7 @@ func (client DatabasesClient) CreateOrUpdatePreparer(resourceGroupName string, s func (client DatabasesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -280,7 +282,9 @@ func (client DatabasesClient) DeletePreparer(resourceGroupName string, serverNam // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client DatabasesClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -377,6 +381,7 @@ func (client DatabasesClient) ExportPreparer(resourceGroupName string, serverNam func (client DatabasesClient) ExportSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -449,7 +454,9 @@ func (client DatabasesClient) GetPreparer(resourceGroupName string, serverName s // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client DatabasesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -518,7 +525,9 @@ func (client DatabasesClient) GetByElasticPoolPreparer(resourceGroupName string, // GetByElasticPoolSender sends the GetByElasticPool request. The method will close the // http.Response Body if it receives an error. func (client DatabasesClient) GetByElasticPoolSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetByElasticPoolResponder handles the response to the GetByElasticPool request. The method always @@ -587,7 +596,9 @@ func (client DatabasesClient) GetByRecommendedElasticPoolPreparer(resourceGroupN // GetByRecommendedElasticPoolSender sends the GetByRecommendedElasticPool request. The method will close the // http.Response Body if it receives an error. func (client DatabasesClient) GetByRecommendedElasticPoolSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetByRecommendedElasticPoolResponder handles the response to the GetByRecommendedElasticPool request. The method always @@ -682,6 +693,7 @@ func (client DatabasesClient) ImportPreparer(resourceGroupName string, serverNam func (client DatabasesClient) ImportSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -750,7 +762,9 @@ func (client DatabasesClient) ListByElasticPoolPreparer(resourceGroupName string // ListByElasticPoolSender sends the ListByElasticPool request. The method will close the // http.Response Body if it receives an error. func (client DatabasesClient) ListByElasticPoolSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByElasticPoolResponder handles the response to the ListByElasticPool request. The method always @@ -818,7 +832,9 @@ func (client DatabasesClient) ListByRecommendedElasticPoolPreparer(resourceGroup // ListByRecommendedElasticPoolSender sends the ListByRecommendedElasticPool request. The method will close the // http.Response Body if it receives an error. func (client DatabasesClient) ListByRecommendedElasticPoolSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByRecommendedElasticPoolResponder handles the response to the ListByRecommendedElasticPool request. The method always @@ -892,7 +908,9 @@ func (client DatabasesClient) ListByServerPreparer(resourceGroupName string, ser // ListByServerSender sends the ListByServer request. The method will close the // http.Response Body if it receives an error. func (client DatabasesClient) ListByServerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByServerResponder handles the response to the ListByServer request. The method always @@ -960,7 +978,9 @@ func (client DatabasesClient) ListMetricDefinitionsPreparer(resourceGroupName st // ListMetricDefinitionsSender sends the ListMetricDefinitions request. The method will close the // http.Response Body if it receives an error. func (client DatabasesClient) ListMetricDefinitionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListMetricDefinitionsResponder handles the response to the ListMetricDefinitions request. The method always @@ -1029,7 +1049,9 @@ func (client DatabasesClient) ListMetricsPreparer(resourceGroupName string, serv // ListMetricsSender sends the ListMetrics request. The method will close the // http.Response Body if it receives an error. func (client DatabasesClient) ListMetricsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListMetricsResponder handles the response to the ListMetrics request. The method always @@ -1113,6 +1135,7 @@ func (client DatabasesClient) PausePreparer(resourceGroupName string, serverName func (client DatabasesClient) PauseSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1196,6 +1219,7 @@ func (client DatabasesClient) ResumePreparer(resourceGroupName string, serverNam func (client DatabasesClient) ResumeSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1281,6 +1305,7 @@ func (client DatabasesClient) UpdatePreparer(resourceGroupName string, serverNam func (client DatabasesClient) UpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/databasethreatdetectionpolicies.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/databasethreatdetectionpolicies.go index 7404964494d0..3b24bfd96def 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/databasethreatdetectionpolicies.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/databasethreatdetectionpolicies.go @@ -97,7 +97,9 @@ func (client DatabaseThreatDetectionPoliciesClient) CreateOrUpdatePreparer(resou // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client DatabaseThreatDetectionPoliciesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -167,7 +169,9 @@ func (client DatabaseThreatDetectionPoliciesClient) GetPreparer(resourceGroupNam // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client DatabaseThreatDetectionPoliciesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/databaseusages.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/databaseusages.go index 291743404537..ca5b95e1c778 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/databaseusages.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/databaseusages.go @@ -92,7 +92,9 @@ func (client DatabaseUsagesClient) ListByDatabasePreparer(resourceGroupName stri // ListByDatabaseSender sends the ListByDatabase request. The method will close the // http.Response Body if it receives an error. func (client DatabaseUsagesClient) ListByDatabaseSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByDatabaseResponder handles the response to the ListByDatabase request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/datamaskingpolicies.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/datamaskingpolicies.go index bbc49c66a34c..ae4619b27f13 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/datamaskingpolicies.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/datamaskingpolicies.go @@ -96,7 +96,9 @@ func (client DataMaskingPoliciesClient) CreateOrUpdatePreparer(resourceGroupName // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client DataMaskingPoliciesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -165,7 +167,9 @@ func (client DataMaskingPoliciesClient) GetPreparer(resourceGroupName string, se // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client DataMaskingPoliciesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/datamaskingrules.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/datamaskingrules.go index c04dff8de31a..29d428fdca46 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/datamaskingrules.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/datamaskingrules.go @@ -109,7 +109,9 @@ func (client DataMaskingRulesClient) CreateOrUpdatePreparer(resourceGroupName st // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client DataMaskingRulesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -178,7 +180,9 @@ func (client DataMaskingRulesClient) ListByDatabasePreparer(resourceGroupName st // ListByDatabaseSender sends the ListByDatabase request. The method will close the // http.Response Body if it receives an error. func (client DataMaskingRulesClient) ListByDatabaseSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByDatabaseResponder handles the response to the ListByDatabase request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/elasticpoolactivities.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/elasticpoolactivities.go index ef21f85fc597..d4ead261d432 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/elasticpoolactivities.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/elasticpoolactivities.go @@ -92,7 +92,9 @@ func (client ElasticPoolActivitiesClient) ListByElasticPoolPreparer(resourceGrou // ListByElasticPoolSender sends the ListByElasticPool request. The method will close the // http.Response Body if it receives an error. func (client ElasticPoolActivitiesClient) ListByElasticPoolSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByElasticPoolResponder handles the response to the ListByElasticPool request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/elasticpooldatabaseactivities.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/elasticpooldatabaseactivities.go index 534a3b8d5b50..5179beca9460 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/elasticpooldatabaseactivities.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/elasticpooldatabaseactivities.go @@ -93,7 +93,9 @@ func (client ElasticPoolDatabaseActivitiesClient) ListByElasticPoolPreparer(reso // ListByElasticPoolSender sends the ListByElasticPool request. The method will close the // http.Response Body if it receives an error. func (client ElasticPoolDatabaseActivitiesClient) ListByElasticPoolSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByElasticPoolResponder handles the response to the ListByElasticPool request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/elasticpools.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/elasticpools.go index f000afdf3341..c713052082c7 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/elasticpools.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/elasticpools.go @@ -112,6 +112,7 @@ func (client ElasticPoolsClient) CreateOrUpdatePreparer(resourceGroupName string func (client ElasticPoolsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -180,7 +181,9 @@ func (client ElasticPoolsClient) DeletePreparer(resourceGroupName string, server // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client ElasticPoolsClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -247,7 +250,9 @@ func (client ElasticPoolsClient) GetPreparer(resourceGroupName string, serverNam // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ElasticPoolsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -313,7 +318,9 @@ func (client ElasticPoolsClient) ListByServerPreparer(resourceGroupName string, // ListByServerSender sends the ListByServer request. The method will close the // http.Response Body if it receives an error. func (client ElasticPoolsClient) ListByServerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByServerResponder handles the response to the ListByServer request. The method always @@ -381,7 +388,9 @@ func (client ElasticPoolsClient) ListMetricDefinitionsPreparer(resourceGroupName // ListMetricDefinitionsSender sends the ListMetricDefinitions request. The method will close the // http.Response Body if it receives an error. func (client ElasticPoolsClient) ListMetricDefinitionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListMetricDefinitionsResponder handles the response to the ListMetricDefinitions request. The method always @@ -450,7 +459,9 @@ func (client ElasticPoolsClient) ListMetricsPreparer(resourceGroupName string, s // ListMetricsSender sends the ListMetrics request. The method will close the // http.Response Body if it receives an error. func (client ElasticPoolsClient) ListMetricsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListMetricsResponder handles the response to the ListMetrics request. The method always @@ -536,6 +547,7 @@ func (client ElasticPoolsClient) UpdatePreparer(resourceGroupName string, server func (client ElasticPoolsClient) UpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/encryptionprotectors.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/encryptionprotectors.go index dc3a0686c941..efa2d3b03f46 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/encryptionprotectors.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/encryptionprotectors.go @@ -111,6 +111,7 @@ func (client EncryptionProtectorsClient) CreateOrUpdatePreparer(resourceGroupNam func (client EncryptionProtectorsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -179,7 +180,9 @@ func (client EncryptionProtectorsClient) GetPreparer(resourceGroupName string, s // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client EncryptionProtectorsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -245,7 +248,9 @@ func (client EncryptionProtectorsClient) ListByServerPreparer(resourceGroupName // ListByServerSender sends the ListByServer request. The method will close the // http.Response Body if it receives an error. func (client EncryptionProtectorsClient) ListByServerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByServerResponder handles the response to the ListByServer request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/failovergroups.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/failovergroups.go index 13c28fd8f417..ffc6bf2f2368 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/failovergroups.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/failovergroups.go @@ -123,6 +123,7 @@ func (client FailoverGroupsClient) CreateOrUpdatePreparer(resourceGroupName stri func (client FailoverGroupsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -207,6 +208,7 @@ func (client FailoverGroupsClient) DeletePreparer(resourceGroupName string, serv func (client FailoverGroupsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -291,6 +293,7 @@ func (client FailoverGroupsClient) FailoverPreparer(resourceGroupName string, se func (client FailoverGroupsClient) FailoverSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -376,6 +379,7 @@ func (client FailoverGroupsClient) ForceFailoverAllowDataLossPreparer(resourceGr func (client FailoverGroupsClient) ForceFailoverAllowDataLossSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -444,7 +448,9 @@ func (client FailoverGroupsClient) GetPreparer(resourceGroupName string, serverN // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client FailoverGroupsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -510,7 +516,9 @@ func (client FailoverGroupsClient) ListByServerPreparer(resourceGroupName string // ListByServerSender sends the ListByServer request. The method will close the // http.Response Body if it receives an error. func (client FailoverGroupsClient) ListByServerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByServerResponder handles the response to the ListByServer request. The method always @@ -665,6 +673,7 @@ func (client FailoverGroupsClient) UpdatePreparer(resourceGroupName string, serv func (client FailoverGroupsClient) UpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/firewallrules.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/firewallrules.go index e59dd25519ee..74b5c3692dce 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/firewallrules.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/firewallrules.go @@ -104,7 +104,9 @@ func (client FirewallRulesClient) CreateOrUpdatePreparer(resourceGroupName strin // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client FirewallRulesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -172,7 +174,9 @@ func (client FirewallRulesClient) DeletePreparer(resourceGroupName string, serve // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client FirewallRulesClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -239,7 +243,9 @@ func (client FirewallRulesClient) GetPreparer(resourceGroupName string, serverNa // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client FirewallRulesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -305,7 +311,9 @@ func (client FirewallRulesClient) ListByServerPreparer(resourceGroupName string, // ListByServerSender sends the ListByServer request. The method will close the // http.Response Body if it receives an error. func (client FirewallRulesClient) ListByServerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByServerResponder handles the response to the ListByServer request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/geobackuppolicies.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/geobackuppolicies.go index b841e2d73fc4..114533894a50 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/geobackuppolicies.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/geobackuppolicies.go @@ -103,7 +103,9 @@ func (client GeoBackupPoliciesClient) CreateOrUpdatePreparer(resourceGroupName s // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client GeoBackupPoliciesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -172,7 +174,9 @@ func (client GeoBackupPoliciesClient) GetPreparer(resourceGroupName string, serv // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client GeoBackupPoliciesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -240,7 +244,9 @@ func (client GeoBackupPoliciesClient) ListByDatabasePreparer(resourceGroupName s // ListByDatabaseSender sends the ListByDatabase request. The method will close the // http.Response Body if it receives an error. func (client GeoBackupPoliciesClient) ListByDatabaseSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByDatabaseResponder handles the response to the ListByDatabase request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/operations.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/operations.go index f1ec16293ad9..1b6bc59f8d32 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/operations.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/operations.go @@ -81,7 +81,9 @@ func (client OperationsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client OperationsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/recommendedelasticpools.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/recommendedelasticpools.go index 99f39eb88f6c..95691ddfedb0 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/recommendedelasticpools.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/recommendedelasticpools.go @@ -92,7 +92,9 @@ func (client RecommendedElasticPoolsClient) GetPreparer(resourceGroupName string // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client RecommendedElasticPoolsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -158,7 +160,9 @@ func (client RecommendedElasticPoolsClient) ListByServerPreparer(resourceGroupNa // ListByServerSender sends the ListByServer request. The method will close the // http.Response Body if it receives an error. func (client RecommendedElasticPoolsClient) ListByServerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByServerResponder handles the response to the ListByServer request. The method always @@ -226,7 +230,9 @@ func (client RecommendedElasticPoolsClient) ListMetricsPreparer(resourceGroupNam // ListMetricsSender sends the ListMetrics request. The method will close the // http.Response Body if it receives an error. func (client RecommendedElasticPoolsClient) ListMetricsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListMetricsResponder handles the response to the ListMetrics request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/recoverabledatabases.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/recoverabledatabases.go index ffc44c53b2c4..f53ccf65914d 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/recoverabledatabases.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/recoverabledatabases.go @@ -92,7 +92,9 @@ func (client RecoverableDatabasesClient) GetPreparer(resourceGroupName string, s // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client RecoverableDatabasesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -158,7 +160,9 @@ func (client RecoverableDatabasesClient) ListByServerPreparer(resourceGroupName // ListByServerSender sends the ListByServer request. The method will close the // http.Response Body if it receives an error. func (client RecoverableDatabasesClient) ListByServerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByServerResponder handles the response to the ListByServer request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/replicationlinks.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/replicationlinks.go index 62127b8a251d..258392d8cfe0 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/replicationlinks.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/replicationlinks.go @@ -93,7 +93,9 @@ func (client ReplicationLinksClient) DeletePreparer(resourceGroupName string, se // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client ReplicationLinksClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -179,6 +181,7 @@ func (client ReplicationLinksClient) FailoverPreparer(resourceGroupName string, func (client ReplicationLinksClient) FailoverSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -265,6 +268,7 @@ func (client ReplicationLinksClient) FailoverAllowDataLossPreparer(resourceGroup func (client ReplicationLinksClient) FailoverAllowDataLossSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -333,7 +337,9 @@ func (client ReplicationLinksClient) GetPreparer(resourceGroupName string, serve // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ReplicationLinksClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -401,7 +407,9 @@ func (client ReplicationLinksClient) ListByDatabasePreparer(resourceGroupName st // ListByDatabaseSender sends the ListByDatabase request. The method will close the // http.Response Body if it receives an error. func (client ReplicationLinksClient) ListByDatabaseSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByDatabaseResponder handles the response to the ListByDatabase request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/restorabledroppeddatabases.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/restorabledroppeddatabases.go index cf49b0a48ebc..7655160901c1 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/restorabledroppeddatabases.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/restorabledroppeddatabases.go @@ -92,7 +92,9 @@ func (client RestorableDroppedDatabasesClient) GetPreparer(resourceGroupName str // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client RestorableDroppedDatabasesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -158,7 +160,9 @@ func (client RestorableDroppedDatabasesClient) ListByServerPreparer(resourceGrou // ListByServerSender sends the ListByServer request. The method will close the // http.Response Body if it receives an error. func (client RestorableDroppedDatabasesClient) ListByServerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByServerResponder handles the response to the ListByServer request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/restorepoints.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/restorepoints.go index 6f3db13d9357..f0f3ac25c445 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/restorepoints.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/restorepoints.go @@ -92,7 +92,9 @@ func (client RestorePointsClient) ListByDatabasePreparer(resourceGroupName strin // ListByDatabaseSender sends the ListByDatabase request. The method will close the // http.Response Body if it receives an error. func (client RestorePointsClient) ListByDatabaseSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByDatabaseResponder handles the response to the ListByDatabase request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/serverazureadadministrators.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/serverazureadadministrators.go index 5371fa6537c2..d95d07a97e6d 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/serverazureadadministrators.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/serverazureadadministrators.go @@ -127,6 +127,7 @@ func (client ServerAzureADAdministratorsClient) CreateOrUpdatePreparer(resourceG func (client ServerAzureADAdministratorsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -212,6 +213,7 @@ func (client ServerAzureADAdministratorsClient) DeletePreparer(resourceGroupName func (client ServerAzureADAdministratorsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -280,7 +282,9 @@ func (client ServerAzureADAdministratorsClient) GetPreparer(resourceGroupName st // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ServerAzureADAdministratorsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -346,7 +350,9 @@ func (client ServerAzureADAdministratorsClient) ListByServerPreparer(resourceGro // ListByServerSender sends the ListByServer request. The method will close the // http.Response Body if it receives an error. func (client ServerAzureADAdministratorsClient) ListByServerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByServerResponder handles the response to the ListByServer request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/servercommunicationlinks.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/servercommunicationlinks.go index a74de33d1943..3c5f6274ae9a 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/servercommunicationlinks.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/servercommunicationlinks.go @@ -121,6 +121,7 @@ func (client ServerCommunicationLinksClient) CreateOrUpdatePreparer(resourceGrou func (client ServerCommunicationLinksClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -189,7 +190,9 @@ func (client ServerCommunicationLinksClient) DeletePreparer(resourceGroupName st // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client ServerCommunicationLinksClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -256,7 +259,9 @@ func (client ServerCommunicationLinksClient) GetPreparer(resourceGroupName strin // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ServerCommunicationLinksClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -322,7 +327,9 @@ func (client ServerCommunicationLinksClient) ListByServerPreparer(resourceGroupN // ListByServerSender sends the ListByServer request. The method will close the // http.Response Body if it receives an error. func (client ServerCommunicationLinksClient) ListByServerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByServerResponder handles the response to the ListByServer request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/serverconnectionpolicies.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/serverconnectionpolicies.go index 70493592ff5c..d1547af0bc20 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/serverconnectionpolicies.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/serverconnectionpolicies.go @@ -94,7 +94,9 @@ func (client ServerConnectionPoliciesClient) CreateOrUpdatePreparer(resourceGrou // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client ServerConnectionPoliciesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -162,7 +164,9 @@ func (client ServerConnectionPoliciesClient) GetPreparer(resourceGroupName strin // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ServerConnectionPoliciesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/serverkeys.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/serverkeys.go index 953427188630..79cb80bb462c 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/serverkeys.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/serverkeys.go @@ -113,6 +113,7 @@ func (client ServerKeysClient) CreateOrUpdatePreparer(resourceGroupName string, func (client ServerKeysClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -197,6 +198,7 @@ func (client ServerKeysClient) DeletePreparer(resourceGroupName string, serverNa func (client ServerKeysClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -264,7 +266,9 @@ func (client ServerKeysClient) GetPreparer(resourceGroupName string, serverName // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ServerKeysClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -330,7 +334,9 @@ func (client ServerKeysClient) ListByServerPreparer(resourceGroupName string, se // ListByServerSender sends the ListByServer request. The method will close the // http.Response Body if it receives an error. func (client ServerKeysClient) ListByServerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByServerResponder handles the response to the ListByServer request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/servers.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/servers.go index 98205b7a3d8b..5be091572aad 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/servers.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/servers.go @@ -97,7 +97,9 @@ func (client ServersClient) CheckNameAvailabilityPreparer(parameters CheckNameAv // CheckNameAvailabilitySender sends the CheckNameAvailability request. The method will close the // http.Response Body if it receives an error. func (client ServersClient) CheckNameAvailabilitySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CheckNameAvailabilityResponder handles the response to the CheckNameAvailability request. The method always @@ -182,6 +184,7 @@ func (client ServersClient) CreateOrUpdatePreparer(resourceGroupName string, ser func (client ServersClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -264,6 +267,7 @@ func (client ServersClient) DeletePreparer(resourceGroupName string, serverName func (client ServersClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -329,7 +333,9 @@ func (client ServersClient) GetPreparer(resourceGroupName string, serverName str // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ServersClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -390,7 +396,9 @@ func (client ServersClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client ServersClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -524,7 +532,9 @@ func (client ServersClient) ListByResourceGroupPreparer(resourceGroupName string // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client ServersClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -678,6 +688,7 @@ func (client ServersClient) UpdatePreparer(resourceGroupName string, serverName func (client ServersClient) UpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/serverusages.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/serverusages.go index 5c9cb9162e21..fc4bf0d3e455 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/serverusages.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/serverusages.go @@ -90,7 +90,9 @@ func (client ServerUsagesClient) ListByServerPreparer(resourceGroupName string, // ListByServerSender sends the ListByServer request. The method will close the // http.Response Body if it receives an error. func (client ServerUsagesClient) ListByServerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByServerResponder handles the response to the ListByServer request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/serviceobjectives.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/serviceobjectives.go index 5fc89b0df541..316609510799 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/serviceobjectives.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/serviceobjectives.go @@ -92,7 +92,9 @@ func (client ServiceObjectivesClient) GetPreparer(resourceGroupName string, serv // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ServiceObjectivesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -158,7 +160,9 @@ func (client ServiceObjectivesClient) ListByServerPreparer(resourceGroupName str // ListByServerSender sends the ListByServer request. The method will close the // http.Response Body if it receives an error. func (client ServiceObjectivesClient) ListByServerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByServerResponder handles the response to the ListByServer request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/servicetieradvisors.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/servicetieradvisors.go index 26ffa1467e21..b3848f2e1747 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/servicetieradvisors.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/servicetieradvisors.go @@ -93,7 +93,9 @@ func (client ServiceTierAdvisorsClient) GetPreparer(resourceGroupName string, se // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ServiceTierAdvisorsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -161,7 +163,9 @@ func (client ServiceTierAdvisorsClient) ListByDatabasePreparer(resourceGroupName // ListByDatabaseSender sends the ListByDatabase request. The method will close the // http.Response Body if it receives an error. func (client ServiceTierAdvisorsClient) ListByDatabaseSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByDatabaseResponder handles the response to the ListByDatabase request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/syncagents.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/syncagents.go index c3aae13ee3df..9c8ab2cb715b 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/syncagents.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/syncagents.go @@ -110,6 +110,7 @@ func (client SyncAgentsClient) CreateOrUpdatePreparer(resourceGroupName string, func (client SyncAgentsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -194,6 +195,7 @@ func (client SyncAgentsClient) DeletePreparer(resourceGroupName string, serverNa func (client SyncAgentsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -261,7 +263,9 @@ func (client SyncAgentsClient) GenerateKeyPreparer(resourceGroupName string, ser // GenerateKeySender sends the GenerateKey request. The method will close the // http.Response Body if it receives an error. func (client SyncAgentsClient) GenerateKeySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GenerateKeyResponder handles the response to the GenerateKey request. The method always @@ -329,7 +333,9 @@ func (client SyncAgentsClient) GetPreparer(resourceGroupName string, serverName // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client SyncAgentsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -395,7 +401,9 @@ func (client SyncAgentsClient) ListByServerPreparer(resourceGroupName string, se // ListByServerSender sends the ListByServer request. The method will close the // http.Response Body if it receives an error. func (client SyncAgentsClient) ListByServerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByServerResponder handles the response to the ListByServer request. The method always @@ -532,7 +540,9 @@ func (client SyncAgentsClient) ListLinkedDatabasesPreparer(resourceGroupName str // ListLinkedDatabasesSender sends the ListLinkedDatabases request. The method will close the // http.Response Body if it receives an error. func (client SyncAgentsClient) ListLinkedDatabasesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListLinkedDatabasesResponder handles the response to the ListLinkedDatabases request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/syncgroups.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/syncgroups.go index 9cc7af60ef0a..a6d0bb1cee5f 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/syncgroups.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/syncgroups.go @@ -93,7 +93,9 @@ func (client SyncGroupsClient) CancelSyncPreparer(resourceGroupName string, serv // CancelSyncSender sends the CancelSync request. The method will close the // http.Response Body if it receives an error. func (client SyncGroupsClient) CancelSyncSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CancelSyncResponder handles the response to the CancelSync request. The method always @@ -180,6 +182,7 @@ func (client SyncGroupsClient) CreateOrUpdatePreparer(resourceGroupName string, func (client SyncGroupsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -265,6 +268,7 @@ func (client SyncGroupsClient) DeletePreparer(resourceGroupName string, serverNa func (client SyncGroupsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -333,7 +337,9 @@ func (client SyncGroupsClient) GetPreparer(resourceGroupName string, serverName // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client SyncGroupsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -401,7 +407,9 @@ func (client SyncGroupsClient) ListByDatabasePreparer(resourceGroupName string, // ListByDatabaseSender sends the ListByDatabase request. The method will close the // http.Response Body if it receives an error. func (client SyncGroupsClient) ListByDatabaseSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByDatabaseResponder handles the response to the ListByDatabase request. The method always @@ -539,7 +547,9 @@ func (client SyncGroupsClient) ListHubSchemasPreparer(resourceGroupName string, // ListHubSchemasSender sends the ListHubSchemas request. The method will close the // http.Response Body if it receives an error. func (client SyncGroupsClient) ListHubSchemasSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListHubSchemasResponder handles the response to the ListHubSchemas request. The method always @@ -685,7 +695,9 @@ func (client SyncGroupsClient) ListLogsPreparer(resourceGroupName string, server // ListLogsSender sends the ListLogs request. The method will close the // http.Response Body if it receives an error. func (client SyncGroupsClient) ListLogsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListLogsResponder handles the response to the ListLogs request. The method always @@ -818,7 +830,9 @@ func (client SyncGroupsClient) ListSyncDatabaseIdsPreparer(locationName string) // ListSyncDatabaseIdsSender sends the ListSyncDatabaseIds request. The method will close the // http.Response Body if it receives an error. func (client SyncGroupsClient) ListSyncDatabaseIdsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListSyncDatabaseIdsResponder handles the response to the ListSyncDatabaseIds request. The method always @@ -972,6 +986,7 @@ func (client SyncGroupsClient) RefreshHubSchemaPreparer(resourceGroupName string func (client SyncGroupsClient) RefreshHubSchemaSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1040,7 +1055,9 @@ func (client SyncGroupsClient) TriggerSyncPreparer(resourceGroupName string, ser // TriggerSyncSender sends the TriggerSync request. The method will close the // http.Response Body if it receives an error. func (client SyncGroupsClient) TriggerSyncSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // TriggerSyncResponder handles the response to the TriggerSync request. The method always @@ -1127,6 +1144,7 @@ func (client SyncGroupsClient) UpdatePreparer(resourceGroupName string, serverNa func (client SyncGroupsClient) UpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/syncmembers.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/syncmembers.go index fe9c9cb1e8ad..eee8e2a1db32 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/syncmembers.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/syncmembers.go @@ -113,6 +113,7 @@ func (client SyncMembersClient) CreateOrUpdatePreparer(resourceGroupName string, func (client SyncMembersClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -200,6 +201,7 @@ func (client SyncMembersClient) DeletePreparer(resourceGroupName string, serverN func (client SyncMembersClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -270,7 +272,9 @@ func (client SyncMembersClient) GetPreparer(resourceGroupName string, serverName // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client SyncMembersClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -339,7 +343,9 @@ func (client SyncMembersClient) ListBySyncGroupPreparer(resourceGroupName string // ListBySyncGroupSender sends the ListBySyncGroup request. The method will close the // http.Response Body if it receives an error. func (client SyncMembersClient) ListBySyncGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListBySyncGroupResponder handles the response to the ListBySyncGroup request. The method always @@ -479,7 +485,9 @@ func (client SyncMembersClient) ListMemberSchemasPreparer(resourceGroupName stri // ListMemberSchemasSender sends the ListMemberSchemas request. The method will close the // http.Response Body if it receives an error. func (client SyncMembersClient) ListMemberSchemasSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListMemberSchemasResponder handles the response to the ListMemberSchemas request. The method always @@ -636,6 +644,7 @@ func (client SyncMembersClient) RefreshMemberSchemaPreparer(resourceGroupName st func (client SyncMembersClient) RefreshMemberSchemaSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -724,6 +733,7 @@ func (client SyncMembersClient) UpdatePreparer(resourceGroupName string, serverN func (client SyncMembersClient) UpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/transparentdataencryptionactivities.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/transparentdataencryptionactivities.go index 3f78c22551d5..a782ecb31a39 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/transparentdataencryptionactivities.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/transparentdataencryptionactivities.go @@ -96,7 +96,9 @@ func (client TransparentDataEncryptionActivitiesClient) ListByConfigurationPrepa // ListByConfigurationSender sends the ListByConfiguration request. The method will close the // http.Response Body if it receives an error. func (client TransparentDataEncryptionActivitiesClient) ListByConfigurationSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByConfigurationResponder handles the response to the ListByConfiguration request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/transparentdataencryptions.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/transparentdataencryptions.go index 4f603942baa4..abb34d867bb8 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/transparentdataencryptions.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/transparentdataencryptions.go @@ -97,7 +97,9 @@ func (client TransparentDataEncryptionsClient) CreateOrUpdatePreparer(resourceGr // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client TransparentDataEncryptionsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -167,7 +169,9 @@ func (client TransparentDataEncryptionsClient) GetPreparer(resourceGroupName str // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client TransparentDataEncryptionsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/version.go index cd5df84b1a58..891e71ac4a76 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/version.go @@ -19,10 +19,10 @@ package sql // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-sql/" + return "Azure-SDK-For-Go/v11.1.1-beta arm-sql/" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/virtualnetworkrules.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/virtualnetworkrules.go index 12c001600d3d..8a4e37f5e236 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/virtualnetworkrules.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/sql/virtualnetworkrules.go @@ -122,6 +122,7 @@ func (client VirtualNetworkRulesClient) CreateOrUpdatePreparer(resourceGroupName func (client VirtualNetworkRulesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -207,6 +208,7 @@ func (client VirtualNetworkRulesClient) DeletePreparer(resourceGroupName string, func (client VirtualNetworkRulesClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -274,7 +276,9 @@ func (client VirtualNetworkRulesClient) GetPreparer(resourceGroupName string, se // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client VirtualNetworkRulesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -340,7 +344,9 @@ func (client VirtualNetworkRulesClient) ListByServerPreparer(resourceGroupName s // ListByServerSender sends the ListByServer request. The method will close the // http.Response Body if it receives an error. func (client VirtualNetworkRulesClient) ListByServerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByServerResponder handles the response to the ListByServer request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/storage/accounts.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/storage/accounts.go index 0870a03ded6e..dfa59f957837 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/storage/accounts.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/storage/accounts.go @@ -96,7 +96,9 @@ func (client AccountsClient) CheckNameAvailabilityPreparer(accountName AccountCh // CheckNameAvailabilitySender sends the CheckNameAvailability request. The method will close the // http.Response Body if it receives an error. func (client AccountsClient) CheckNameAvailabilitySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CheckNameAvailabilityResponder handles the response to the CheckNameAvailability request. The method always @@ -208,6 +210,7 @@ func (client AccountsClient) CreatePreparer(resourceGroupName string, accountNam func (client AccountsClient) CreateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -286,7 +289,9 @@ func (client AccountsClient) DeletePreparer(resourceGroupName string, accountNam // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client AccountsClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -364,7 +369,9 @@ func (client AccountsClient) GetPropertiesPreparer(resourceGroupName string, acc // GetPropertiesSender sends the GetProperties request. The method will close the // http.Response Body if it receives an error. func (client AccountsClient) GetPropertiesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetPropertiesResponder handles the response to the GetProperties request. The method always @@ -426,7 +433,9 @@ func (client AccountsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client AccountsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -509,7 +518,9 @@ func (client AccountsClient) ListAccountSASPreparer(resourceGroupName string, ac // ListAccountSASSender sends the ListAccountSAS request. The method will close the // http.Response Body if it receives an error. func (client AccountsClient) ListAccountSASSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAccountSASResponder handles the response to the ListAccountSAS request. The method always @@ -582,7 +593,9 @@ func (client AccountsClient) ListByResourceGroupPreparer(resourceGroupName strin // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client AccountsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -660,7 +673,9 @@ func (client AccountsClient) ListKeysPreparer(resourceGroupName string, accountN // ListKeysSender sends the ListKeys request. The method will close the // http.Response Body if it receives an error. func (client AccountsClient) ListKeysSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListKeysResponder handles the response to the ListKeys request. The method always @@ -745,7 +760,9 @@ func (client AccountsClient) ListServiceSASPreparer(resourceGroupName string, ac // ListServiceSASSender sends the ListServiceSAS request. The method will close the // http.Response Body if it receives an error. func (client AccountsClient) ListServiceSASSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListServiceSASResponder handles the response to the ListServiceSAS request. The method always @@ -828,7 +845,9 @@ func (client AccountsClient) RegenerateKeyPreparer(resourceGroupName string, acc // RegenerateKeySender sends the RegenerateKey request. The method will close the // http.Response Body if it receives an error. func (client AccountsClient) RegenerateKeySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RegenerateKeyResponder handles the response to the RegenerateKey request. The method always @@ -914,7 +933,9 @@ func (client AccountsClient) UpdatePreparer(resourceGroupName string, accountNam // UpdateSender sends the Update request. The method will close the // http.Response Body if it receives an error. func (client AccountsClient) UpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateResponder handles the response to the Update request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/storage/operations.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/storage/operations.go index cc46c6997920..ca46f8e13601 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/storage/operations.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/storage/operations.go @@ -79,7 +79,9 @@ func (client OperationsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client OperationsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/storage/skus.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/storage/skus.go index 94d4d6f83ec5..cfad757fb223 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/storage/skus.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/storage/skus.go @@ -83,7 +83,9 @@ func (client SkusClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client SkusClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/storage/usage.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/storage/usage.go index 682e5c16c362..933c5d9617e8 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/storage/usage.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/storage/usage.go @@ -83,7 +83,9 @@ func (client UsageClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client UsageClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/storage/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/storage/version.go index 467102d59734..5d5ab667115f 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/storage/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/storage/version.go @@ -19,10 +19,10 @@ package storage // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-storage/2017-06-01" + return "Azure-SDK-For-Go/v11.1.1-beta arm-storage/2017-06-01" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/trafficmanager/endpoints.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/trafficmanager/endpoints.go index 935c3f68d695..6883c1ecb6fb 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/trafficmanager/endpoints.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/trafficmanager/endpoints.go @@ -94,7 +94,9 @@ func (client EndpointsClient) CreateOrUpdatePreparer(resourceGroupName string, p // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client EndpointsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -163,7 +165,9 @@ func (client EndpointsClient) DeletePreparer(resourceGroupName string, profileNa // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client EndpointsClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -232,7 +236,9 @@ func (client EndpointsClient) GetPreparer(resourceGroupName string, profileName // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client EndpointsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -304,7 +310,9 @@ func (client EndpointsClient) UpdatePreparer(resourceGroupName string, profileNa // UpdateSender sends the Update request. The method will close the // http.Response Body if it receives an error. func (client EndpointsClient) UpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateResponder handles the response to the Update request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/trafficmanager/geographichierarchies.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/trafficmanager/geographichierarchies.go index ba6e6c8165e2..963fa895d0fb 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/trafficmanager/geographichierarchies.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/trafficmanager/geographichierarchies.go @@ -79,7 +79,9 @@ func (client GeographicHierarchiesClient) GetDefaultPreparer() (*http.Request, e // GetDefaultSender sends the GetDefault request. The method will close the // http.Response Body if it receives an error. func (client GeographicHierarchiesClient) GetDefaultSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetDefaultResponder handles the response to the GetDefault request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/trafficmanager/heatmap.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/trafficmanager/heatmap.go index 81c9ca5e2209..4c6dae1e8cf0 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/trafficmanager/heatmap.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/trafficmanager/heatmap.go @@ -112,7 +112,9 @@ func (client HeatMapClient) GetPreparer(resourceGroupName string, profileName st // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client HeatMapClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/trafficmanager/profiles.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/trafficmanager/profiles.go index 81f12321a57f..cbabcc60a427 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/trafficmanager/profiles.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/trafficmanager/profiles.go @@ -83,7 +83,9 @@ func (client ProfilesClient) CheckTrafficManagerRelativeDNSNameAvailabilityPrepa // CheckTrafficManagerRelativeDNSNameAvailabilitySender sends the CheckTrafficManagerRelativeDNSNameAvailability request. The method will close the // http.Response Body if it receives an error. func (client ProfilesClient) CheckTrafficManagerRelativeDNSNameAvailabilitySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // CheckTrafficManagerRelativeDNSNameAvailabilityResponder handles the response to the CheckTrafficManagerRelativeDNSNameAvailability request. The method always @@ -152,7 +154,9 @@ func (client ProfilesClient) CreateOrUpdatePreparer(resourceGroupName string, pr // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client ProfilesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -218,7 +222,9 @@ func (client ProfilesClient) DeletePreparer(resourceGroupName string, profileNam // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client ProfilesClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -284,7 +290,9 @@ func (client ProfilesClient) GetPreparer(resourceGroupName string, profileName s // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client ProfilesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -348,7 +356,9 @@ func (client ProfilesClient) ListByResourceGroupPreparer(resourceGroupName strin // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client ProfilesClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -409,7 +419,9 @@ func (client ProfilesClient) ListBySubscriptionPreparer() (*http.Request, error) // ListBySubscriptionSender sends the ListBySubscription request. The method will close the // http.Response Body if it receives an error. func (client ProfilesClient) ListBySubscriptionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListBySubscriptionResponder handles the response to the ListBySubscription request. The method always @@ -478,7 +490,9 @@ func (client ProfilesClient) UpdatePreparer(resourceGroupName string, profileNam // UpdateSender sends the Update request. The method will close the // http.Response Body if it receives an error. func (client ProfilesClient) UpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateResponder handles the response to the Update request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/trafficmanager/usermetricskeys.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/trafficmanager/usermetricskeys.go index e77ca981bb9e..d3cd4f6073bb 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/trafficmanager/usermetricskeys.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/trafficmanager/usermetricskeys.go @@ -83,7 +83,9 @@ func (client UserMetricsKeysClient) CreateOrUpdatePreparer() (*http.Request, err // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client UserMetricsKeysClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -144,7 +146,9 @@ func (client UserMetricsKeysClient) DeletePreparer() (*http.Request, error) { // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client UserMetricsKeysClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -205,7 +209,9 @@ func (client UserMetricsKeysClient) GetDefaultPreparer() (*http.Request, error) // GetDefaultSender sends the GetDefault request. The method will close the // http.Response Body if it receives an error. func (client UserMetricsKeysClient) GetDefaultSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetDefaultResponder handles the response to the GetDefault request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/trafficmanager/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/trafficmanager/version.go index f27c187190f0..6490949a511e 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/trafficmanager/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/trafficmanager/version.go @@ -19,10 +19,10 @@ package trafficmanager // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.1.0-beta arm-trafficmanager/" + return "Azure-SDK-For-Go/v11.1.1-beta arm-trafficmanager/" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.1.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/apps.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/apps.go index 37d1f6ef822a..629e58fa7377 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/apps.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/apps.go @@ -100,7 +100,9 @@ func (client AppsClient) AddPremierAddOnPreparer(resourceGroupName string, name // AddPremierAddOnSender sends the AddPremierAddOn request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) AddPremierAddOnSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // AddPremierAddOnResponder handles the response to the AddPremierAddOn request. The method always @@ -179,7 +181,9 @@ func (client AppsClient) AddPremierAddOnSlotPreparer(resourceGroupName string, n // AddPremierAddOnSlotSender sends the AddPremierAddOnSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) AddPremierAddOnSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // AddPremierAddOnSlotResponder handles the response to the AddPremierAddOnSlot request. The method always @@ -256,7 +260,9 @@ func (client AppsClient) AnalyzeCustomHostnamePreparer(resourceGroupName string, // AnalyzeCustomHostnameSender sends the AnalyzeCustomHostname request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) AnalyzeCustomHostnameSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // AnalyzeCustomHostnameResponder handles the response to the AnalyzeCustomHostname request. The method always @@ -334,7 +340,9 @@ func (client AppsClient) AnalyzeCustomHostnameSlotPreparer(resourceGroupName str // AnalyzeCustomHostnameSlotSender sends the AnalyzeCustomHostnameSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) AnalyzeCustomHostnameSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // AnalyzeCustomHostnameSlotResponder handles the response to the AnalyzeCustomHostnameSlot request. The method always @@ -413,7 +421,9 @@ func (client AppsClient) ApplySlotConfigToProductionPreparer(resourceGroupName s // ApplySlotConfigToProductionSender sends the ApplySlotConfigToProduction request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ApplySlotConfigToProductionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ApplySlotConfigToProductionResponder handles the response to the ApplySlotConfigToProduction request. The method always @@ -493,7 +503,9 @@ func (client AppsClient) ApplySlotConfigurationSlotPreparer(resourceGroupName st // ApplySlotConfigurationSlotSender sends the ApplySlotConfigurationSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ApplySlotConfigurationSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ApplySlotConfigurationSlotResponder handles the response to the ApplySlotConfigurationSlot request. The method always @@ -576,7 +588,9 @@ func (client AppsClient) BackupPreparer(resourceGroupName string, name string, r // BackupSender sends the Backup request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) BackupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // BackupResponder handles the response to the Backup request. The method always @@ -662,7 +676,9 @@ func (client AppsClient) BackupSlotPreparer(resourceGroupName string, name strin // BackupSlotSender sends the BackupSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) BackupSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // BackupSlotResponder handles the response to the BackupSlot request. The method always @@ -739,7 +755,9 @@ func (client AppsClient) CreateDeploymentPreparer(resourceGroupName string, name // CreateDeploymentSender sends the CreateDeployment request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) CreateDeploymentSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateDeploymentResponder handles the response to the CreateDeployment request. The method always @@ -818,7 +836,9 @@ func (client AppsClient) CreateDeploymentSlotPreparer(resourceGroupName string, // CreateDeploymentSlotSender sends the CreateDeploymentSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) CreateDeploymentSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateDeploymentSlotResponder handles the response to the CreateDeploymentSlot request. The method always @@ -915,6 +935,7 @@ func (client AppsClient) CreateFunctionPreparer(resourceGroupName string, name s func (client AppsClient) CreateFunctionSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1014,6 +1035,7 @@ func (client AppsClient) CreateInstanceFunctionSlotPreparer(resourceGroupName st func (client AppsClient) CreateInstanceFunctionSlotSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1111,6 +1133,7 @@ func (client AppsClient) CreateInstanceMSDeployOperationPreparer(resourceGroupNa func (client AppsClient) CreateInstanceMSDeployOperationSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1210,6 +1233,7 @@ func (client AppsClient) CreateInstanceMSDeployOperationSlotPreparer(resourceGro func (client AppsClient) CreateInstanceMSDeployOperationSlotSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1306,6 +1330,7 @@ func (client AppsClient) CreateMSDeployOperationPreparer(resourceGroupName strin func (client AppsClient) CreateMSDeployOperationSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1403,6 +1428,7 @@ func (client AppsClient) CreateMSDeployOperationSlotPreparer(resourceGroupName s func (client AppsClient) CreateMSDeployOperationSlotSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1521,6 +1547,7 @@ func (client AppsClient) CreateOrUpdatePreparer(resourceGroupName string, name s func (client AppsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -1597,7 +1624,9 @@ func (client AppsClient) CreateOrUpdateConfigurationPreparer(resourceGroupName s // CreateOrUpdateConfigurationSender sends the CreateOrUpdateConfiguration request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) CreateOrUpdateConfigurationSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateConfigurationResponder handles the response to the CreateOrUpdateConfiguration request. The method always @@ -1675,7 +1704,9 @@ func (client AppsClient) CreateOrUpdateConfigurationSlotPreparer(resourceGroupNa // CreateOrUpdateConfigurationSlotSender sends the CreateOrUpdateConfigurationSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) CreateOrUpdateConfigurationSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateConfigurationSlotResponder handles the response to the CreateOrUpdateConfigurationSlot request. The method always @@ -1754,7 +1785,9 @@ func (client AppsClient) CreateOrUpdateDomainOwnershipIdentifierPreparer(resourc // CreateOrUpdateDomainOwnershipIdentifierSender sends the CreateOrUpdateDomainOwnershipIdentifier request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) CreateOrUpdateDomainOwnershipIdentifierSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateDomainOwnershipIdentifierResponder handles the response to the CreateOrUpdateDomainOwnershipIdentifier request. The method always @@ -1835,7 +1868,9 @@ func (client AppsClient) CreateOrUpdateDomainOwnershipIdentifierSlotPreparer(res // CreateOrUpdateDomainOwnershipIdentifierSlotSender sends the CreateOrUpdateDomainOwnershipIdentifierSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) CreateOrUpdateDomainOwnershipIdentifierSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateDomainOwnershipIdentifierSlotResponder handles the response to the CreateOrUpdateDomainOwnershipIdentifierSlot request. The method always @@ -1913,7 +1948,9 @@ func (client AppsClient) CreateOrUpdateHostNameBindingPreparer(resourceGroupName // CreateOrUpdateHostNameBindingSender sends the CreateOrUpdateHostNameBinding request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) CreateOrUpdateHostNameBindingSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateHostNameBindingResponder handles the response to the CreateOrUpdateHostNameBinding request. The method always @@ -1993,7 +2030,9 @@ func (client AppsClient) CreateOrUpdateHostNameBindingSlotPreparer(resourceGroup // CreateOrUpdateHostNameBindingSlotSender sends the CreateOrUpdateHostNameBindingSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) CreateOrUpdateHostNameBindingSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateHostNameBindingSlotResponder handles the response to the CreateOrUpdateHostNameBindingSlot request. The method always @@ -2072,7 +2111,9 @@ func (client AppsClient) CreateOrUpdateHybridConnectionPreparer(resourceGroupNam // CreateOrUpdateHybridConnectionSender sends the CreateOrUpdateHybridConnection request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) CreateOrUpdateHybridConnectionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateHybridConnectionResponder handles the response to the CreateOrUpdateHybridConnection request. The method always @@ -2152,7 +2193,9 @@ func (client AppsClient) CreateOrUpdateHybridConnectionSlotPreparer(resourceGrou // CreateOrUpdateHybridConnectionSlotSender sends the CreateOrUpdateHybridConnectionSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) CreateOrUpdateHybridConnectionSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateHybridConnectionSlotResponder handles the response to the CreateOrUpdateHybridConnectionSlot request. The method always @@ -2230,7 +2273,9 @@ func (client AppsClient) CreateOrUpdatePublicCertificatePreparer(resourceGroupNa // CreateOrUpdatePublicCertificateSender sends the CreateOrUpdatePublicCertificate request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) CreateOrUpdatePublicCertificateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdatePublicCertificateResponder handles the response to the CreateOrUpdatePublicCertificate request. The method always @@ -2310,7 +2355,9 @@ func (client AppsClient) CreateOrUpdatePublicCertificateSlotPreparer(resourceGro // CreateOrUpdatePublicCertificateSlotSender sends the CreateOrUpdatePublicCertificateSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) CreateOrUpdatePublicCertificateSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdatePublicCertificateSlotResponder handles the response to the CreateOrUpdatePublicCertificateSlot request. The method always @@ -2389,7 +2436,9 @@ func (client AppsClient) CreateOrUpdateRelayServiceConnectionPreparer(resourceGr // CreateOrUpdateRelayServiceConnectionSender sends the CreateOrUpdateRelayServiceConnection request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) CreateOrUpdateRelayServiceConnectionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateRelayServiceConnectionResponder handles the response to the CreateOrUpdateRelayServiceConnection request. The method always @@ -2470,7 +2519,9 @@ func (client AppsClient) CreateOrUpdateRelayServiceConnectionSlotPreparer(resour // CreateOrUpdateRelayServiceConnectionSlotSender sends the CreateOrUpdateRelayServiceConnectionSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) CreateOrUpdateRelayServiceConnectionSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateRelayServiceConnectionSlotResponder handles the response to the CreateOrUpdateRelayServiceConnectionSlot request. The method always @@ -2590,6 +2641,7 @@ func (client AppsClient) CreateOrUpdateSlotPreparer(resourceGroupName string, na func (client AppsClient) CreateOrUpdateSlotSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -2686,6 +2738,7 @@ func (client AppsClient) CreateOrUpdateSourceControlPreparer(resourceGroupName s func (client AppsClient) CreateOrUpdateSourceControlSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -2784,6 +2837,7 @@ func (client AppsClient) CreateOrUpdateSourceControlSlotPreparer(resourceGroupNa func (client AppsClient) CreateOrUpdateSourceControlSlotSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -2863,7 +2917,9 @@ func (client AppsClient) CreateOrUpdateVnetConnectionPreparer(resourceGroupName // CreateOrUpdateVnetConnectionSender sends the CreateOrUpdateVnetConnection request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) CreateOrUpdateVnetConnectionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateVnetConnectionResponder handles the response to the CreateOrUpdateVnetConnection request. The method always @@ -2942,7 +2998,9 @@ func (client AppsClient) CreateOrUpdateVnetConnectionGatewayPreparer(resourceGro // CreateOrUpdateVnetConnectionGatewaySender sends the CreateOrUpdateVnetConnectionGateway request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) CreateOrUpdateVnetConnectionGatewaySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateVnetConnectionGatewayResponder handles the response to the CreateOrUpdateVnetConnectionGateway request. The method always @@ -3023,7 +3081,9 @@ func (client AppsClient) CreateOrUpdateVnetConnectionGatewaySlotPreparer(resourc // CreateOrUpdateVnetConnectionGatewaySlotSender sends the CreateOrUpdateVnetConnectionGatewaySlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) CreateOrUpdateVnetConnectionGatewaySlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateVnetConnectionGatewaySlotResponder handles the response to the CreateOrUpdateVnetConnectionGatewaySlot request. The method always @@ -3104,7 +3164,9 @@ func (client AppsClient) CreateOrUpdateVnetConnectionSlotPreparer(resourceGroupN // CreateOrUpdateVnetConnectionSlotSender sends the CreateOrUpdateVnetConnectionSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) CreateOrUpdateVnetConnectionSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateVnetConnectionSlotResponder handles the response to the CreateOrUpdateVnetConnectionSlot request. The method always @@ -3189,7 +3251,9 @@ func (client AppsClient) DeletePreparer(resourceGroupName string, name string, d // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -3263,7 +3327,9 @@ func (client AppsClient) DeleteBackupPreparer(resourceGroupName string, name str // DeleteBackupSender sends the DeleteBackup request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteBackupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteBackupResponder handles the response to the DeleteBackup request. The method always @@ -3335,7 +3401,9 @@ func (client AppsClient) DeleteBackupConfigurationPreparer(resourceGroupName str // DeleteBackupConfigurationSender sends the DeleteBackupConfiguration request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteBackupConfigurationSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteBackupConfigurationResponder handles the response to the DeleteBackupConfiguration request. The method always @@ -3410,7 +3478,9 @@ func (client AppsClient) DeleteBackupConfigurationSlotPreparer(resourceGroupName // DeleteBackupConfigurationSlotSender sends the DeleteBackupConfigurationSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteBackupConfigurationSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteBackupConfigurationSlotResponder handles the response to the DeleteBackupConfigurationSlot request. The method always @@ -3486,7 +3556,9 @@ func (client AppsClient) DeleteBackupSlotPreparer(resourceGroupName string, name // DeleteBackupSlotSender sends the DeleteBackupSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteBackupSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteBackupSlotResponder handles the response to the DeleteBackupSlot request. The method always @@ -3561,7 +3633,9 @@ func (client AppsClient) DeleteContinuousWebJobPreparer(resourceGroupName string // DeleteContinuousWebJobSender sends the DeleteContinuousWebJob request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteContinuousWebJobSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteContinuousWebJobResponder handles the response to the DeleteContinuousWebJob request. The method always @@ -3638,7 +3712,9 @@ func (client AppsClient) DeleteContinuousWebJobSlotPreparer(resourceGroupName st // DeleteContinuousWebJobSlotSender sends the DeleteContinuousWebJobSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteContinuousWebJobSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteContinuousWebJobSlotResponder handles the response to the DeleteContinuousWebJobSlot request. The method always @@ -3712,7 +3788,9 @@ func (client AppsClient) DeleteDeploymentPreparer(resourceGroupName string, name // DeleteDeploymentSender sends the DeleteDeployment request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteDeploymentSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteDeploymentResponder handles the response to the DeleteDeployment request. The method always @@ -3788,7 +3866,9 @@ func (client AppsClient) DeleteDeploymentSlotPreparer(resourceGroupName string, // DeleteDeploymentSlotSender sends the DeleteDeploymentSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteDeploymentSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteDeploymentSlotResponder handles the response to the DeleteDeploymentSlot request. The method always @@ -3862,7 +3942,9 @@ func (client AppsClient) DeleteDomainOwnershipIdentifierPreparer(resourceGroupNa // DeleteDomainOwnershipIdentifierSender sends the DeleteDomainOwnershipIdentifier request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteDomainOwnershipIdentifierSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteDomainOwnershipIdentifierResponder handles the response to the DeleteDomainOwnershipIdentifier request. The method always @@ -3938,7 +4020,9 @@ func (client AppsClient) DeleteDomainOwnershipIdentifierSlotPreparer(resourceGro // DeleteDomainOwnershipIdentifierSlotSender sends the DeleteDomainOwnershipIdentifierSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteDomainOwnershipIdentifierSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteDomainOwnershipIdentifierSlotResponder handles the response to the DeleteDomainOwnershipIdentifierSlot request. The method always @@ -4012,7 +4096,9 @@ func (client AppsClient) DeleteFunctionPreparer(resourceGroupName string, name s // DeleteFunctionSender sends the DeleteFunction request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteFunctionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteFunctionResponder handles the response to the DeleteFunction request. The method always @@ -4086,7 +4172,9 @@ func (client AppsClient) DeleteHostNameBindingPreparer(resourceGroupName string, // DeleteHostNameBindingSender sends the DeleteHostNameBinding request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteHostNameBindingSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteHostNameBindingResponder handles the response to the DeleteHostNameBinding request. The method always @@ -4162,7 +4250,9 @@ func (client AppsClient) DeleteHostNameBindingSlotPreparer(resourceGroupName str // DeleteHostNameBindingSlotSender sends the DeleteHostNameBindingSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteHostNameBindingSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteHostNameBindingSlotResponder handles the response to the DeleteHostNameBindingSlot request. The method always @@ -4237,7 +4327,9 @@ func (client AppsClient) DeleteHybridConnectionPreparer(resourceGroupName string // DeleteHybridConnectionSender sends the DeleteHybridConnection request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteHybridConnectionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteHybridConnectionResponder handles the response to the DeleteHybridConnection request. The method always @@ -4314,7 +4406,9 @@ func (client AppsClient) DeleteHybridConnectionSlotPreparer(resourceGroupName st // DeleteHybridConnectionSlotSender sends the DeleteHybridConnectionSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteHybridConnectionSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteHybridConnectionSlotResponder handles the response to the DeleteHybridConnectionSlot request. The method always @@ -4390,7 +4484,9 @@ func (client AppsClient) DeleteInstanceFunctionSlotPreparer(resourceGroupName st // DeleteInstanceFunctionSlotSender sends the DeleteInstanceFunctionSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteInstanceFunctionSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteInstanceFunctionSlotResponder handles the response to the DeleteInstanceFunctionSlot request. The method always @@ -4467,7 +4563,9 @@ func (client AppsClient) DeleteInstanceProcessPreparer(resourceGroupName string, // DeleteInstanceProcessSender sends the DeleteInstanceProcess request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteInstanceProcessSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteInstanceProcessResponder handles the response to the DeleteInstanceProcess request. The method always @@ -4546,7 +4644,9 @@ func (client AppsClient) DeleteInstanceProcessSlotPreparer(resourceGroupName str // DeleteInstanceProcessSlotSender sends the DeleteInstanceProcessSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteInstanceProcessSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteInstanceProcessSlotResponder handles the response to the DeleteInstanceProcessSlot request. The method always @@ -4620,7 +4720,9 @@ func (client AppsClient) DeletePremierAddOnPreparer(resourceGroupName string, na // DeletePremierAddOnSender sends the DeletePremierAddOn request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeletePremierAddOnSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeletePremierAddOnResponder handles the response to the DeletePremierAddOn request. The method always @@ -4696,7 +4798,9 @@ func (client AppsClient) DeletePremierAddOnSlotPreparer(resourceGroupName string // DeletePremierAddOnSlotSender sends the DeletePremierAddOnSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeletePremierAddOnSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeletePremierAddOnSlotResponder handles the response to the DeletePremierAddOnSlot request. The method always @@ -4770,7 +4874,9 @@ func (client AppsClient) DeleteProcessPreparer(resourceGroupName string, name st // DeleteProcessSender sends the DeleteProcess request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteProcessSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteProcessResponder handles the response to the DeleteProcess request. The method always @@ -4847,7 +4953,9 @@ func (client AppsClient) DeleteProcessSlotPreparer(resourceGroupName string, nam // DeleteProcessSlotSender sends the DeleteProcessSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteProcessSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteProcessSlotResponder handles the response to the DeleteProcessSlot request. The method always @@ -4921,7 +5029,9 @@ func (client AppsClient) DeletePublicCertificatePreparer(resourceGroupName strin // DeletePublicCertificateSender sends the DeletePublicCertificate request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeletePublicCertificateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeletePublicCertificateResponder handles the response to the DeletePublicCertificate request. The method always @@ -4997,7 +5107,9 @@ func (client AppsClient) DeletePublicCertificateSlotPreparer(resourceGroupName s // DeletePublicCertificateSlotSender sends the DeletePublicCertificateSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeletePublicCertificateSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeletePublicCertificateSlotResponder handles the response to the DeletePublicCertificateSlot request. The method always @@ -5071,7 +5183,9 @@ func (client AppsClient) DeleteRelayServiceConnectionPreparer(resourceGroupName // DeleteRelayServiceConnectionSender sends the DeleteRelayServiceConnection request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteRelayServiceConnectionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteRelayServiceConnectionResponder handles the response to the DeleteRelayServiceConnection request. The method always @@ -5147,7 +5261,9 @@ func (client AppsClient) DeleteRelayServiceConnectionSlotPreparer(resourceGroupN // DeleteRelayServiceConnectionSlotSender sends the DeleteRelayServiceConnectionSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteRelayServiceConnectionSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteRelayServiceConnectionSlotResponder handles the response to the DeleteRelayServiceConnectionSlot request. The method always @@ -5222,7 +5338,9 @@ func (client AppsClient) DeleteSiteExtensionPreparer(resourceGroupName string, n // DeleteSiteExtensionSender sends the DeleteSiteExtension request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteSiteExtensionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteSiteExtensionResponder handles the response to the DeleteSiteExtension request. The method always @@ -5299,7 +5417,9 @@ func (client AppsClient) DeleteSiteExtensionSlotPreparer(resourceGroupName strin // DeleteSiteExtensionSlotSender sends the DeleteSiteExtensionSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteSiteExtensionSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteSiteExtensionSlotResponder handles the response to the DeleteSiteExtensionSlot request. The method always @@ -5385,7 +5505,9 @@ func (client AppsClient) DeleteSlotPreparer(resourceGroupName string, name strin // DeleteSlotSender sends the DeleteSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteSlotResponder handles the response to the DeleteSlot request. The method always @@ -5457,7 +5579,9 @@ func (client AppsClient) DeleteSourceControlPreparer(resourceGroupName string, n // DeleteSourceControlSender sends the DeleteSourceControl request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteSourceControlSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteSourceControlResponder handles the response to the DeleteSourceControl request. The method always @@ -5532,7 +5656,9 @@ func (client AppsClient) DeleteSourceControlSlotPreparer(resourceGroupName strin // DeleteSourceControlSlotSender sends the DeleteSourceControlSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteSourceControlSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteSourceControlSlotResponder handles the response to the DeleteSourceControlSlot request. The method always @@ -5607,7 +5733,9 @@ func (client AppsClient) DeleteTriggeredWebJobPreparer(resourceGroupName string, // DeleteTriggeredWebJobSender sends the DeleteTriggeredWebJob request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteTriggeredWebJobSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteTriggeredWebJobResponder handles the response to the DeleteTriggeredWebJob request. The method always @@ -5684,7 +5812,9 @@ func (client AppsClient) DeleteTriggeredWebJobSlotPreparer(resourceGroupName str // DeleteTriggeredWebJobSlotSender sends the DeleteTriggeredWebJobSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteTriggeredWebJobSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteTriggeredWebJobSlotResponder handles the response to the DeleteTriggeredWebJobSlot request. The method always @@ -5758,7 +5888,9 @@ func (client AppsClient) DeleteVnetConnectionPreparer(resourceGroupName string, // DeleteVnetConnectionSender sends the DeleteVnetConnection request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteVnetConnectionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteVnetConnectionResponder handles the response to the DeleteVnetConnection request. The method always @@ -5834,7 +5966,9 @@ func (client AppsClient) DeleteVnetConnectionSlotPreparer(resourceGroupName stri // DeleteVnetConnectionSlotSender sends the DeleteVnetConnectionSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DeleteVnetConnectionSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteVnetConnectionSlotResponder handles the response to the DeleteVnetConnectionSlot request. The method always @@ -5909,7 +6043,9 @@ func (client AppsClient) DiscoverRestorePreparer(resourceGroupName string, name // DiscoverRestoreSender sends the DiscoverRestore request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DiscoverRestoreSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DiscoverRestoreResponder handles the response to the DiscoverRestore request. The method always @@ -5987,7 +6123,9 @@ func (client AppsClient) DiscoverRestoreSlotPreparer(resourceGroupName string, n // DiscoverRestoreSlotSender sends the DiscoverRestoreSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) DiscoverRestoreSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DiscoverRestoreSlotResponder handles the response to the DiscoverRestoreSlot request. The method always @@ -6060,7 +6198,9 @@ func (client AppsClient) GenerateNewSitePublishingPasswordPreparer(resourceGroup // GenerateNewSitePublishingPasswordSender sends the GenerateNewSitePublishingPassword request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GenerateNewSitePublishingPasswordSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GenerateNewSitePublishingPasswordResponder handles the response to the GenerateNewSitePublishingPassword request. The method always @@ -6136,7 +6276,9 @@ func (client AppsClient) GenerateNewSitePublishingPasswordSlotPreparer(resourceG // GenerateNewSitePublishingPasswordSlotSender sends the GenerateNewSitePublishingPasswordSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GenerateNewSitePublishingPasswordSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GenerateNewSitePublishingPasswordSlotResponder handles the response to the GenerateNewSitePublishingPasswordSlot request. The method always @@ -6208,7 +6350,9 @@ func (client AppsClient) GetPreparer(resourceGroupName string, name string) (*ht // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -6281,7 +6425,9 @@ func (client AppsClient) GetAuthSettingsPreparer(resourceGroupName string, name // GetAuthSettingsSender sends the GetAuthSettings request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetAuthSettingsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetAuthSettingsResponder handles the response to the GetAuthSettings request. The method always @@ -6356,7 +6502,9 @@ func (client AppsClient) GetAuthSettingsSlotPreparer(resourceGroupName string, n // GetAuthSettingsSlotSender sends the GetAuthSettingsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetAuthSettingsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetAuthSettingsSlotResponder handles the response to the GetAuthSettingsSlot request. The method always @@ -6429,7 +6577,9 @@ func (client AppsClient) GetBackupConfigurationPreparer(resourceGroupName string // GetBackupConfigurationSender sends the GetBackupConfiguration request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetBackupConfigurationSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetBackupConfigurationResponder handles the response to the GetBackupConfiguration request. The method always @@ -6505,7 +6655,9 @@ func (client AppsClient) GetBackupConfigurationSlotPreparer(resourceGroupName st // GetBackupConfigurationSlotSender sends the GetBackupConfigurationSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetBackupConfigurationSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetBackupConfigurationSlotResponder handles the response to the GetBackupConfigurationSlot request. The method always @@ -6580,7 +6732,9 @@ func (client AppsClient) GetBackupStatusPreparer(resourceGroupName string, name // GetBackupStatusSender sends the GetBackupStatus request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetBackupStatusSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetBackupStatusResponder handles the response to the GetBackupStatus request. The method always @@ -6657,7 +6811,9 @@ func (client AppsClient) GetBackupStatusSlotPreparer(resourceGroupName string, n // GetBackupStatusSlotSender sends the GetBackupStatusSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetBackupStatusSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetBackupStatusSlotResponder handles the response to the GetBackupStatusSlot request. The method always @@ -6731,7 +6887,9 @@ func (client AppsClient) GetConfigurationPreparer(resourceGroupName string, name // GetConfigurationSender sends the GetConfiguration request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetConfigurationSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetConfigurationResponder handles the response to the GetConfiguration request. The method always @@ -6807,7 +6965,9 @@ func (client AppsClient) GetConfigurationSlotPreparer(resourceGroupName string, // GetConfigurationSlotSender sends the GetConfigurationSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetConfigurationSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetConfigurationSlotResponder handles the response to the GetConfigurationSlot request. The method always @@ -6882,7 +7042,9 @@ func (client AppsClient) GetConfigurationSnapshotPreparer(resourceGroupName stri // GetConfigurationSnapshotSender sends the GetConfigurationSnapshot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetConfigurationSnapshotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetConfigurationSnapshotResponder handles the response to the GetConfigurationSnapshot request. The method always @@ -6959,7 +7121,9 @@ func (client AppsClient) GetConfigurationSnapshotSlotPreparer(resourceGroupName // GetConfigurationSnapshotSlotSender sends the GetConfigurationSnapshotSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetConfigurationSnapshotSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetConfigurationSnapshotSlotResponder handles the response to the GetConfigurationSnapshotSlot request. The method always @@ -7035,7 +7199,9 @@ func (client AppsClient) GetContinuousWebJobPreparer(resourceGroupName string, n // GetContinuousWebJobSender sends the GetContinuousWebJob request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetContinuousWebJobSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetContinuousWebJobResponder handles the response to the GetContinuousWebJob request. The method always @@ -7113,7 +7279,9 @@ func (client AppsClient) GetContinuousWebJobSlotPreparer(resourceGroupName strin // GetContinuousWebJobSlotSender sends the GetContinuousWebJobSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetContinuousWebJobSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetContinuousWebJobSlotResponder handles the response to the GetContinuousWebJobSlot request. The method always @@ -7188,7 +7356,9 @@ func (client AppsClient) GetDeploymentPreparer(resourceGroupName string, name st // GetDeploymentSender sends the GetDeployment request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetDeploymentSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetDeploymentResponder handles the response to the GetDeployment request. The method always @@ -7265,7 +7435,9 @@ func (client AppsClient) GetDeploymentSlotPreparer(resourceGroupName string, nam // GetDeploymentSlotSender sends the GetDeploymentSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetDeploymentSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetDeploymentSlotResponder handles the response to the GetDeploymentSlot request. The method always @@ -7338,7 +7510,9 @@ func (client AppsClient) GetDiagnosticLogsConfigurationPreparer(resourceGroupNam // GetDiagnosticLogsConfigurationSender sends the GetDiagnosticLogsConfiguration request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetDiagnosticLogsConfigurationSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetDiagnosticLogsConfigurationResponder handles the response to the GetDiagnosticLogsConfiguration request. The method always @@ -7414,7 +7588,9 @@ func (client AppsClient) GetDiagnosticLogsConfigurationSlotPreparer(resourceGrou // GetDiagnosticLogsConfigurationSlotSender sends the GetDiagnosticLogsConfigurationSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetDiagnosticLogsConfigurationSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetDiagnosticLogsConfigurationSlotResponder handles the response to the GetDiagnosticLogsConfigurationSlot request. The method always @@ -7489,7 +7665,9 @@ func (client AppsClient) GetDomainOwnershipIdentifierPreparer(resourceGroupName // GetDomainOwnershipIdentifierSender sends the GetDomainOwnershipIdentifier request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetDomainOwnershipIdentifierSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetDomainOwnershipIdentifierResponder handles the response to the GetDomainOwnershipIdentifier request. The method always @@ -7566,7 +7744,9 @@ func (client AppsClient) GetDomainOwnershipIdentifierSlotPreparer(resourceGroupN // GetDomainOwnershipIdentifierSlotSender sends the GetDomainOwnershipIdentifierSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetDomainOwnershipIdentifierSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetDomainOwnershipIdentifierSlotResponder handles the response to the GetDomainOwnershipIdentifierSlot request. The method always @@ -7641,7 +7821,9 @@ func (client AppsClient) GetFunctionPreparer(resourceGroupName string, name stri // GetFunctionSender sends the GetFunction request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetFunctionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetFunctionResponder handles the response to the GetFunction request. The method always @@ -7714,7 +7896,9 @@ func (client AppsClient) GetFunctionsAdminTokenPreparer(resourceGroupName string // GetFunctionsAdminTokenSender sends the GetFunctionsAdminToken request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetFunctionsAdminTokenSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetFunctionsAdminTokenResponder handles the response to the GetFunctionsAdminToken request. The method always @@ -7789,7 +7973,9 @@ func (client AppsClient) GetFunctionsAdminTokenSlotPreparer(resourceGroupName st // GetFunctionsAdminTokenSlotSender sends the GetFunctionsAdminTokenSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetFunctionsAdminTokenSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetFunctionsAdminTokenSlotResponder handles the response to the GetFunctionsAdminTokenSlot request. The method always @@ -7864,7 +8050,9 @@ func (client AppsClient) GetHostNameBindingPreparer(resourceGroupName string, na // GetHostNameBindingSender sends the GetHostNameBinding request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetHostNameBindingSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetHostNameBindingResponder handles the response to the GetHostNameBinding request. The method always @@ -7941,7 +8129,9 @@ func (client AppsClient) GetHostNameBindingSlotPreparer(resourceGroupName string // GetHostNameBindingSlotSender sends the GetHostNameBindingSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetHostNameBindingSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetHostNameBindingSlotResponder handles the response to the GetHostNameBindingSlot request. The method always @@ -8017,7 +8207,9 @@ func (client AppsClient) GetHybridConnectionPreparer(resourceGroupName string, n // GetHybridConnectionSender sends the GetHybridConnection request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetHybridConnectionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetHybridConnectionResponder handles the response to the GetHybridConnection request. The method always @@ -8095,7 +8287,9 @@ func (client AppsClient) GetHybridConnectionSlotPreparer(resourceGroupName strin // GetHybridConnectionSlotSender sends the GetHybridConnectionSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetHybridConnectionSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetHybridConnectionSlotResponder handles the response to the GetHybridConnectionSlot request. The method always @@ -8172,7 +8366,9 @@ func (client AppsClient) GetInstanceFunctionSlotPreparer(resourceGroupName strin // GetInstanceFunctionSlotSender sends the GetInstanceFunctionSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetInstanceFunctionSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetInstanceFunctionSlotResponder handles the response to the GetInstanceFunctionSlot request. The method always @@ -8247,7 +8443,9 @@ func (client AppsClient) GetInstanceMSDeployLogPreparer(resourceGroupName string // GetInstanceMSDeployLogSender sends the GetInstanceMSDeployLog request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetInstanceMSDeployLogSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetInstanceMSDeployLogResponder handles the response to the GetInstanceMSDeployLog request. The method always @@ -8323,7 +8521,9 @@ func (client AppsClient) GetInstanceMSDeployLogSlotPreparer(resourceGroupName st // GetInstanceMSDeployLogSlotSender sends the GetInstanceMSDeployLogSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetInstanceMSDeployLogSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetInstanceMSDeployLogSlotResponder handles the response to the GetInstanceMSDeployLogSlot request. The method always @@ -8398,7 +8598,9 @@ func (client AppsClient) GetInstanceMsDeployStatusPreparer(resourceGroupName str // GetInstanceMsDeployStatusSender sends the GetInstanceMsDeployStatus request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetInstanceMsDeployStatusSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetInstanceMsDeployStatusResponder handles the response to the GetInstanceMsDeployStatus request. The method always @@ -8474,7 +8676,9 @@ func (client AppsClient) GetInstanceMsDeployStatusSlotPreparer(resourceGroupName // GetInstanceMsDeployStatusSlotSender sends the GetInstanceMsDeployStatusSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetInstanceMsDeployStatusSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetInstanceMsDeployStatusSlotResponder handles the response to the GetInstanceMsDeployStatusSlot request. The method always @@ -8551,7 +8755,9 @@ func (client AppsClient) GetInstanceProcessPreparer(resourceGroupName string, na // GetInstanceProcessSender sends the GetInstanceProcess request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetInstanceProcessSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetInstanceProcessResponder handles the response to the GetInstanceProcess request. The method always @@ -8628,7 +8834,9 @@ func (client AppsClient) GetInstanceProcessDumpPreparer(resourceGroupName string // GetInstanceProcessDumpSender sends the GetInstanceProcessDump request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetInstanceProcessDumpSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetInstanceProcessDumpResponder handles the response to the GetInstanceProcessDump request. The method always @@ -8708,7 +8916,9 @@ func (client AppsClient) GetInstanceProcessDumpSlotPreparer(resourceGroupName st // GetInstanceProcessDumpSlotSender sends the GetInstanceProcessDumpSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetInstanceProcessDumpSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetInstanceProcessDumpSlotResponder handles the response to the GetInstanceProcessDumpSlot request. The method always @@ -8787,7 +8997,9 @@ func (client AppsClient) GetInstanceProcessModulePreparer(resourceGroupName stri // GetInstanceProcessModuleSender sends the GetInstanceProcessModule request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetInstanceProcessModuleSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetInstanceProcessModuleResponder handles the response to the GetInstanceProcessModule request. The method always @@ -8868,7 +9080,9 @@ func (client AppsClient) GetInstanceProcessModuleSlotPreparer(resourceGroupName // GetInstanceProcessModuleSlotSender sends the GetInstanceProcessModuleSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetInstanceProcessModuleSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetInstanceProcessModuleSlotResponder handles the response to the GetInstanceProcessModuleSlot request. The method always @@ -8947,7 +9161,9 @@ func (client AppsClient) GetInstanceProcessSlotPreparer(resourceGroupName string // GetInstanceProcessSlotSender sends the GetInstanceProcessSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetInstanceProcessSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetInstanceProcessSlotResponder handles the response to the GetInstanceProcessSlot request. The method always @@ -9026,7 +9242,9 @@ func (client AppsClient) GetInstanceProcessThreadPreparer(resourceGroupName stri // GetInstanceProcessThreadSender sends the GetInstanceProcessThread request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetInstanceProcessThreadSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetInstanceProcessThreadResponder handles the response to the GetInstanceProcessThread request. The method always @@ -9107,7 +9325,9 @@ func (client AppsClient) GetInstanceProcessThreadSlotPreparer(resourceGroupName // GetInstanceProcessThreadSlotSender sends the GetInstanceProcessThreadSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetInstanceProcessThreadSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetInstanceProcessThreadSlotResponder handles the response to the GetInstanceProcessThreadSlot request. The method always @@ -9181,7 +9401,9 @@ func (client AppsClient) GetMigrateMySQLStatusPreparer(resourceGroupName string, // GetMigrateMySQLStatusSender sends the GetMigrateMySQLStatus request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetMigrateMySQLStatusSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetMigrateMySQLStatusResponder handles the response to the GetMigrateMySQLStatus request. The method always @@ -9257,7 +9479,9 @@ func (client AppsClient) GetMigrateMySQLStatusSlotPreparer(resourceGroupName str // GetMigrateMySQLStatusSlotSender sends the GetMigrateMySQLStatusSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetMigrateMySQLStatusSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetMigrateMySQLStatusSlotResponder handles the response to the GetMigrateMySQLStatusSlot request. The method always @@ -9330,7 +9554,9 @@ func (client AppsClient) GetMSDeployLogPreparer(resourceGroupName string, name s // GetMSDeployLogSender sends the GetMSDeployLog request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetMSDeployLogSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetMSDeployLogResponder handles the response to the GetMSDeployLog request. The method always @@ -9405,7 +9631,9 @@ func (client AppsClient) GetMSDeployLogSlotPreparer(resourceGroupName string, na // GetMSDeployLogSlotSender sends the GetMSDeployLogSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetMSDeployLogSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetMSDeployLogSlotResponder handles the response to the GetMSDeployLogSlot request. The method always @@ -9478,7 +9706,9 @@ func (client AppsClient) GetMSDeployStatusPreparer(resourceGroupName string, nam // GetMSDeployStatusSender sends the GetMSDeployStatus request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetMSDeployStatusSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetMSDeployStatusResponder handles the response to the GetMSDeployStatus request. The method always @@ -9553,7 +9783,9 @@ func (client AppsClient) GetMSDeployStatusSlotPreparer(resourceGroupName string, // GetMSDeployStatusSlotSender sends the GetMSDeployStatusSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetMSDeployStatusSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetMSDeployStatusSlotResponder handles the response to the GetMSDeployStatusSlot request. The method always @@ -9628,7 +9860,9 @@ func (client AppsClient) GetPremierAddOnPreparer(resourceGroupName string, name // GetPremierAddOnSender sends the GetPremierAddOn request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetPremierAddOnSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetPremierAddOnResponder handles the response to the GetPremierAddOn request. The method always @@ -9705,7 +9939,9 @@ func (client AppsClient) GetPremierAddOnSlotPreparer(resourceGroupName string, n // GetPremierAddOnSlotSender sends the GetPremierAddOnSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetPremierAddOnSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetPremierAddOnSlotResponder handles the response to the GetPremierAddOnSlot request. The method always @@ -9779,7 +10015,9 @@ func (client AppsClient) GetProcessPreparer(resourceGroupName string, name strin // GetProcessSender sends the GetProcess request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetProcessSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetProcessResponder handles the response to the GetProcess request. The method always @@ -9853,7 +10091,9 @@ func (client AppsClient) GetProcessDumpPreparer(resourceGroupName string, name s // GetProcessDumpSender sends the GetProcessDump request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetProcessDumpSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetProcessDumpResponder handles the response to the GetProcessDump request. The method always @@ -9930,7 +10170,9 @@ func (client AppsClient) GetProcessDumpSlotPreparer(resourceGroupName string, na // GetProcessDumpSlotSender sends the GetProcessDumpSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetProcessDumpSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetProcessDumpSlotResponder handles the response to the GetProcessDumpSlot request. The method always @@ -10007,7 +10249,9 @@ func (client AppsClient) GetProcessModulePreparer(resourceGroupName string, name // GetProcessModuleSender sends the GetProcessModule request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetProcessModuleSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetProcessModuleResponder handles the response to the GetProcessModule request. The method always @@ -10086,7 +10330,9 @@ func (client AppsClient) GetProcessModuleSlotPreparer(resourceGroupName string, // GetProcessModuleSlotSender sends the GetProcessModuleSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetProcessModuleSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetProcessModuleSlotResponder handles the response to the GetProcessModuleSlot request. The method always @@ -10163,7 +10409,9 @@ func (client AppsClient) GetProcessSlotPreparer(resourceGroupName string, name s // GetProcessSlotSender sends the GetProcessSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetProcessSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetProcessSlotResponder handles the response to the GetProcessSlot request. The method always @@ -10240,7 +10488,9 @@ func (client AppsClient) GetProcessThreadPreparer(resourceGroupName string, name // GetProcessThreadSender sends the GetProcessThread request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetProcessThreadSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetProcessThreadResponder handles the response to the GetProcessThread request. The method always @@ -10319,7 +10569,9 @@ func (client AppsClient) GetProcessThreadSlotPreparer(resourceGroupName string, // GetProcessThreadSlotSender sends the GetProcessThreadSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetProcessThreadSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetProcessThreadSlotResponder handles the response to the GetProcessThreadSlot request. The method always @@ -10394,7 +10646,9 @@ func (client AppsClient) GetPublicCertificatePreparer(resourceGroupName string, // GetPublicCertificateSender sends the GetPublicCertificate request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetPublicCertificateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetPublicCertificateResponder handles the response to the GetPublicCertificate request. The method always @@ -10471,7 +10725,9 @@ func (client AppsClient) GetPublicCertificateSlotPreparer(resourceGroupName stri // GetPublicCertificateSlotSender sends the GetPublicCertificateSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetPublicCertificateSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetPublicCertificateSlotResponder handles the response to the GetPublicCertificateSlot request. The method always @@ -10546,7 +10802,9 @@ func (client AppsClient) GetRelayServiceConnectionPreparer(resourceGroupName str // GetRelayServiceConnectionSender sends the GetRelayServiceConnection request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetRelayServiceConnectionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetRelayServiceConnectionResponder handles the response to the GetRelayServiceConnection request. The method always @@ -10623,7 +10881,9 @@ func (client AppsClient) GetRelayServiceConnectionSlotPreparer(resourceGroupName // GetRelayServiceConnectionSlotSender sends the GetRelayServiceConnectionSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetRelayServiceConnectionSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetRelayServiceConnectionSlotResponder handles the response to the GetRelayServiceConnectionSlot request. The method always @@ -10699,7 +10959,9 @@ func (client AppsClient) GetSiteExtensionPreparer(resourceGroupName string, name // GetSiteExtensionSender sends the GetSiteExtension request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetSiteExtensionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetSiteExtensionResponder handles the response to the GetSiteExtension request. The method always @@ -10777,7 +11039,9 @@ func (client AppsClient) GetSiteExtensionSlotPreparer(resourceGroupName string, // GetSiteExtensionSlotSender sends the GetSiteExtensionSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetSiteExtensionSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetSiteExtensionSlotResponder handles the response to the GetSiteExtensionSlot request. The method always @@ -10850,7 +11114,9 @@ func (client AppsClient) GetSitePhpErrorLogFlagPreparer(resourceGroupName string // GetSitePhpErrorLogFlagSender sends the GetSitePhpErrorLogFlag request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetSitePhpErrorLogFlagSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetSitePhpErrorLogFlagResponder handles the response to the GetSitePhpErrorLogFlag request. The method always @@ -10925,7 +11191,9 @@ func (client AppsClient) GetSitePhpErrorLogFlagSlotPreparer(resourceGroupName st // GetSitePhpErrorLogFlagSlotSender sends the GetSitePhpErrorLogFlagSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetSitePhpErrorLogFlagSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetSitePhpErrorLogFlagSlotResponder handles the response to the GetSitePhpErrorLogFlagSlot request. The method always @@ -11000,7 +11268,9 @@ func (client AppsClient) GetSlotPreparer(resourceGroupName string, name string, // GetSlotSender sends the GetSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetSlotResponder handles the response to the GetSlot request. The method always @@ -11073,7 +11343,9 @@ func (client AppsClient) GetSourceControlPreparer(resourceGroupName string, name // GetSourceControlSender sends the GetSourceControl request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetSourceControlSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetSourceControlResponder handles the response to the GetSourceControl request. The method always @@ -11149,7 +11421,9 @@ func (client AppsClient) GetSourceControlSlotPreparer(resourceGroupName string, // GetSourceControlSlotSender sends the GetSourceControlSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetSourceControlSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetSourceControlSlotResponder handles the response to the GetSourceControlSlot request. The method always @@ -11225,7 +11499,9 @@ func (client AppsClient) GetTriggeredWebJobPreparer(resourceGroupName string, na // GetTriggeredWebJobSender sends the GetTriggeredWebJob request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetTriggeredWebJobSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetTriggeredWebJobResponder handles the response to the GetTriggeredWebJob request. The method always @@ -11302,7 +11578,9 @@ func (client AppsClient) GetTriggeredWebJobHistoryPreparer(resourceGroupName str // GetTriggeredWebJobHistorySender sends the GetTriggeredWebJobHistory request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetTriggeredWebJobHistorySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetTriggeredWebJobHistoryResponder handles the response to the GetTriggeredWebJobHistory request. The method always @@ -11381,7 +11659,9 @@ func (client AppsClient) GetTriggeredWebJobHistorySlotPreparer(resourceGroupName // GetTriggeredWebJobHistorySlotSender sends the GetTriggeredWebJobHistorySlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetTriggeredWebJobHistorySlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetTriggeredWebJobHistorySlotResponder handles the response to the GetTriggeredWebJobHistorySlot request. The method always @@ -11459,7 +11739,9 @@ func (client AppsClient) GetTriggeredWebJobSlotPreparer(resourceGroupName string // GetTriggeredWebJobSlotSender sends the GetTriggeredWebJobSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetTriggeredWebJobSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetTriggeredWebJobSlotResponder handles the response to the GetTriggeredWebJobSlot request. The method always @@ -11534,7 +11816,9 @@ func (client AppsClient) GetVnetConnectionPreparer(resourceGroupName string, nam // GetVnetConnectionSender sends the GetVnetConnection request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetVnetConnectionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetVnetConnectionResponder handles the response to the GetVnetConnection request. The method always @@ -11610,7 +11894,9 @@ func (client AppsClient) GetVnetConnectionGatewayPreparer(resourceGroupName stri // GetVnetConnectionGatewaySender sends the GetVnetConnectionGateway request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetVnetConnectionGatewaySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetVnetConnectionGatewayResponder handles the response to the GetVnetConnectionGateway request. The method always @@ -11689,7 +11975,9 @@ func (client AppsClient) GetVnetConnectionGatewaySlotPreparer(resourceGroupName // GetVnetConnectionGatewaySlotSender sends the GetVnetConnectionGatewaySlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetVnetConnectionGatewaySlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetVnetConnectionGatewaySlotResponder handles the response to the GetVnetConnectionGatewaySlot request. The method always @@ -11766,7 +12054,9 @@ func (client AppsClient) GetVnetConnectionSlotPreparer(resourceGroupName string, // GetVnetConnectionSlotSender sends the GetVnetConnectionSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetVnetConnectionSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetVnetConnectionSlotResponder handles the response to the GetVnetConnectionSlot request. The method always @@ -11841,7 +12131,9 @@ func (client AppsClient) GetWebJobPreparer(resourceGroupName string, name string // GetWebJobSender sends the GetWebJob request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetWebJobSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetWebJobResponder handles the response to the GetWebJob request. The method always @@ -11918,7 +12210,9 @@ func (client AppsClient) GetWebJobSlotPreparer(resourceGroupName string, name st // GetWebJobSlotSender sends the GetWebJobSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) GetWebJobSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetWebJobSlotResponder handles the response to the GetWebJobSlot request. The method always @@ -12014,6 +12308,7 @@ func (client AppsClient) InstallSiteExtensionPreparer(resourceGroupName string, func (client AppsClient) InstallSiteExtensionSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -12112,6 +12407,7 @@ func (client AppsClient) InstallSiteExtensionSlotPreparer(resourceGroupName stri func (client AppsClient) InstallSiteExtensionSlotSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -12185,7 +12481,9 @@ func (client AppsClient) IsCloneablePreparer(resourceGroupName string, name stri // IsCloneableSender sends the IsCloneable request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) IsCloneableSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // IsCloneableResponder handles the response to the IsCloneable request. The method always @@ -12260,7 +12558,9 @@ func (client AppsClient) IsCloneableSlotPreparer(resourceGroupName string, name // IsCloneableSlotSender sends the IsCloneableSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) IsCloneableSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // IsCloneableSlotResponder handles the response to the IsCloneableSlot request. The method always @@ -12321,7 +12621,9 @@ func (client AppsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -12463,7 +12765,9 @@ func (client AppsClient) ListApplicationSettingsPreparer(resourceGroupName strin // ListApplicationSettingsSender sends the ListApplicationSettings request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListApplicationSettingsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListApplicationSettingsResponder handles the response to the ListApplicationSettings request. The method always @@ -12539,7 +12843,9 @@ func (client AppsClient) ListApplicationSettingsSlotPreparer(resourceGroupName s // ListApplicationSettingsSlotSender sends the ListApplicationSettingsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListApplicationSettingsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListApplicationSettingsSlotResponder handles the response to the ListApplicationSettingsSlot request. The method always @@ -12612,7 +12918,9 @@ func (client AppsClient) ListBackupsPreparer(resourceGroupName string, name stri // ListBackupsSender sends the ListBackups request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListBackupsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListBackupsResponder handles the response to the ListBackups request. The method always @@ -12756,7 +13064,9 @@ func (client AppsClient) ListBackupsSlotPreparer(resourceGroupName string, name // ListBackupsSlotSender sends the ListBackupsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListBackupsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListBackupsSlotResponder handles the response to the ListBackupsSlot request. The method always @@ -12912,7 +13222,9 @@ func (client AppsClient) ListBackupStatusSecretsPreparer(resourceGroupName strin // ListBackupStatusSecretsSender sends the ListBackupStatusSecrets request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListBackupStatusSecretsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListBackupStatusSecretsResponder handles the response to the ListBackupStatusSecrets request. The method always @@ -13001,7 +13313,9 @@ func (client AppsClient) ListBackupStatusSecretsSlotPreparer(resourceGroupName s // ListBackupStatusSecretsSlotSender sends the ListBackupStatusSecretsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListBackupStatusSecretsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListBackupStatusSecretsSlotResponder handles the response to the ListBackupStatusSecretsSlot request. The method always @@ -13078,7 +13392,9 @@ func (client AppsClient) ListByResourceGroupPreparer(resourceGroupName string, i // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -13220,7 +13536,9 @@ func (client AppsClient) ListConfigurationsPreparer(resourceGroupName string, na // ListConfigurationsSender sends the ListConfigurations request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListConfigurationsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListConfigurationsResponder handles the response to the ListConfigurations request. The method always @@ -13363,7 +13681,9 @@ func (client AppsClient) ListConfigurationSnapshotInfoPreparer(resourceGroupName // ListConfigurationSnapshotInfoSender sends the ListConfigurationSnapshotInfo request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListConfigurationSnapshotInfoSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListConfigurationSnapshotInfoResponder handles the response to the ListConfigurationSnapshotInfo request. The method always @@ -13439,7 +13759,9 @@ func (client AppsClient) ListConfigurationSnapshotInfoSlotPreparer(resourceGroup // ListConfigurationSnapshotInfoSlotSender sends the ListConfigurationSnapshotInfoSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListConfigurationSnapshotInfoSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListConfigurationSnapshotInfoSlotResponder handles the response to the ListConfigurationSnapshotInfoSlot request. The method always @@ -13514,7 +13836,9 @@ func (client AppsClient) ListConfigurationsSlotPreparer(resourceGroupName string // ListConfigurationsSlotSender sends the ListConfigurationsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListConfigurationsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListConfigurationsSlotResponder handles the response to the ListConfigurationsSlot request. The method always @@ -13656,7 +13980,9 @@ func (client AppsClient) ListConnectionStringsPreparer(resourceGroupName string, // ListConnectionStringsSender sends the ListConnectionStrings request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListConnectionStringsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListConnectionStringsResponder handles the response to the ListConnectionStrings request. The method always @@ -13732,7 +14058,9 @@ func (client AppsClient) ListConnectionStringsSlotPreparer(resourceGroupName str // ListConnectionStringsSlotSender sends the ListConnectionStringsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListConnectionStringsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListConnectionStringsSlotResponder handles the response to the ListConnectionStringsSlot request. The method always @@ -13805,7 +14133,9 @@ func (client AppsClient) ListContinuousWebJobsPreparer(resourceGroupName string, // ListContinuousWebJobsSender sends the ListContinuousWebJobs request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListContinuousWebJobsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListContinuousWebJobsResponder handles the response to the ListContinuousWebJobs request. The method always @@ -13949,7 +14279,9 @@ func (client AppsClient) ListContinuousWebJobsSlotPreparer(resourceGroupName str // ListContinuousWebJobsSlotSender sends the ListContinuousWebJobsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListContinuousWebJobsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListContinuousWebJobsSlotResponder handles the response to the ListContinuousWebJobsSlot request. The method always @@ -14094,7 +14426,9 @@ func (client AppsClient) ListDeploymentLogPreparer(resourceGroupName string, nam // ListDeploymentLogSender sends the ListDeploymentLog request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListDeploymentLogSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListDeploymentLogResponder handles the response to the ListDeploymentLog request. The method always @@ -14172,7 +14506,9 @@ func (client AppsClient) ListDeploymentLogSlotPreparer(resourceGroupName string, // ListDeploymentLogSlotSender sends the ListDeploymentLogSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListDeploymentLogSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListDeploymentLogSlotResponder handles the response to the ListDeploymentLogSlot request. The method always @@ -14245,7 +14581,9 @@ func (client AppsClient) ListDeploymentsPreparer(resourceGroupName string, name // ListDeploymentsSender sends the ListDeployments request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListDeploymentsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListDeploymentsResponder handles the response to the ListDeployments request. The method always @@ -14389,7 +14727,9 @@ func (client AppsClient) ListDeploymentsSlotPreparer(resourceGroupName string, n // ListDeploymentsSlotSender sends the ListDeploymentsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListDeploymentsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListDeploymentsSlotResponder handles the response to the ListDeploymentsSlot request. The method always @@ -14531,7 +14871,9 @@ func (client AppsClient) ListDomainOwnershipIdentifiersPreparer(resourceGroupNam // ListDomainOwnershipIdentifiersSender sends the ListDomainOwnershipIdentifiers request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListDomainOwnershipIdentifiersSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListDomainOwnershipIdentifiersResponder handles the response to the ListDomainOwnershipIdentifiers request. The method always @@ -14675,7 +15017,9 @@ func (client AppsClient) ListDomainOwnershipIdentifiersSlotPreparer(resourceGrou // ListDomainOwnershipIdentifiersSlotSender sends the ListDomainOwnershipIdentifiersSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListDomainOwnershipIdentifiersSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListDomainOwnershipIdentifiersSlotResponder handles the response to the ListDomainOwnershipIdentifiersSlot request. The method always @@ -14817,7 +15161,9 @@ func (client AppsClient) ListFunctionsPreparer(resourceGroupName string, name st // ListFunctionsSender sends the ListFunctions request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListFunctionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListFunctionsResponder handles the response to the ListFunctions request. The method always @@ -14961,7 +15307,9 @@ func (client AppsClient) ListFunctionSecretsPreparer(resourceGroupName string, n // ListFunctionSecretsSender sends the ListFunctionSecrets request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListFunctionSecretsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListFunctionSecretsResponder handles the response to the ListFunctionSecrets request. The method always @@ -15038,7 +15386,9 @@ func (client AppsClient) ListFunctionSecretsSlotPreparer(resourceGroupName strin // ListFunctionSecretsSlotSender sends the ListFunctionSecretsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListFunctionSecretsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListFunctionSecretsSlotResponder handles the response to the ListFunctionSecretsSlot request. The method always @@ -15111,7 +15461,9 @@ func (client AppsClient) ListHostNameBindingsPreparer(resourceGroupName string, // ListHostNameBindingsSender sends the ListHostNameBindings request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListHostNameBindingsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListHostNameBindingsResponder handles the response to the ListHostNameBindings request. The method always @@ -15255,7 +15607,9 @@ func (client AppsClient) ListHostNameBindingsSlotPreparer(resourceGroupName stri // ListHostNameBindingsSlotSender sends the ListHostNameBindingsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListHostNameBindingsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListHostNameBindingsSlotResponder handles the response to the ListHostNameBindingsSlot request. The method always @@ -15400,7 +15754,9 @@ func (client AppsClient) ListHybridConnectionKeysPreparer(resourceGroupName stri // ListHybridConnectionKeysSender sends the ListHybridConnectionKeys request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListHybridConnectionKeysSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListHybridConnectionKeysResponder handles the response to the ListHybridConnectionKeys request. The method always @@ -15478,7 +15834,9 @@ func (client AppsClient) ListHybridConnectionKeysSlotPreparer(resourceGroupName // ListHybridConnectionKeysSlotSender sends the ListHybridConnectionKeysSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListHybridConnectionKeysSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListHybridConnectionKeysSlotResponder handles the response to the ListHybridConnectionKeysSlot request. The method always @@ -15551,7 +15909,9 @@ func (client AppsClient) ListHybridConnectionsPreparer(resourceGroupName string, // ListHybridConnectionsSender sends the ListHybridConnections request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListHybridConnectionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListHybridConnectionsResponder handles the response to the ListHybridConnections request. The method always @@ -15626,7 +15986,9 @@ func (client AppsClient) ListHybridConnectionsSlotPreparer(resourceGroupName str // ListHybridConnectionsSlotSender sends the ListHybridConnectionsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListHybridConnectionsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListHybridConnectionsSlotResponder handles the response to the ListHybridConnectionsSlot request. The method always @@ -15701,7 +16063,9 @@ func (client AppsClient) ListInstanceFunctionsSlotPreparer(resourceGroupName str // ListInstanceFunctionsSlotSender sends the ListInstanceFunctionsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListInstanceFunctionsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListInstanceFunctionsSlotResponder handles the response to the ListInstanceFunctionsSlot request. The method always @@ -15843,7 +16207,9 @@ func (client AppsClient) ListInstanceIdentifiersPreparer(resourceGroupName strin // ListInstanceIdentifiersSender sends the ListInstanceIdentifiers request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListInstanceIdentifiersSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListInstanceIdentifiersResponder handles the response to the ListInstanceIdentifiers request. The method always @@ -15987,7 +16353,9 @@ func (client AppsClient) ListInstanceIdentifiersSlotPreparer(resourceGroupName s // ListInstanceIdentifiersSlotSender sends the ListInstanceIdentifiersSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListInstanceIdentifiersSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListInstanceIdentifiersSlotResponder handles the response to the ListInstanceIdentifiersSlot request. The method always @@ -16133,7 +16501,9 @@ func (client AppsClient) ListInstanceProcessesPreparer(resourceGroupName string, // ListInstanceProcessesSender sends the ListInstanceProcesses request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListInstanceProcessesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListInstanceProcessesResponder handles the response to the ListInstanceProcesses request. The method always @@ -16281,7 +16651,9 @@ func (client AppsClient) ListInstanceProcessesSlotPreparer(resourceGroupName str // ListInstanceProcessesSlotSender sends the ListInstanceProcessesSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListInstanceProcessesSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListInstanceProcessesSlotResponder handles the response to the ListInstanceProcessesSlot request. The method always @@ -16428,7 +16800,9 @@ func (client AppsClient) ListInstanceProcessModulesPreparer(resourceGroupName st // ListInstanceProcessModulesSender sends the ListInstanceProcessModules request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListInstanceProcessModulesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListInstanceProcessModulesResponder handles the response to the ListInstanceProcessModules request. The method always @@ -16577,7 +16951,9 @@ func (client AppsClient) ListInstanceProcessModulesSlotPreparer(resourceGroupNam // ListInstanceProcessModulesSlotSender sends the ListInstanceProcessModulesSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListInstanceProcessModulesSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListInstanceProcessModulesSlotResponder handles the response to the ListInstanceProcessModulesSlot request. The method always @@ -16723,7 +17099,9 @@ func (client AppsClient) ListInstanceProcessThreadsPreparer(resourceGroupName st // ListInstanceProcessThreadsSender sends the ListInstanceProcessThreads request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListInstanceProcessThreadsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListInstanceProcessThreadsResponder handles the response to the ListInstanceProcessThreads request. The method always @@ -16872,7 +17250,9 @@ func (client AppsClient) ListInstanceProcessThreadsSlotPreparer(resourceGroupNam // ListInstanceProcessThreadsSlotSender sends the ListInstanceProcessThreadsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListInstanceProcessThreadsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListInstanceProcessThreadsSlotResponder handles the response to the ListInstanceProcessThreadsSlot request. The method always @@ -17014,7 +17394,9 @@ func (client AppsClient) ListMetadataPreparer(resourceGroupName string, name str // ListMetadataSender sends the ListMetadata request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListMetadataSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListMetadataResponder handles the response to the ListMetadata request. The method always @@ -17089,7 +17471,9 @@ func (client AppsClient) ListMetadataSlotPreparer(resourceGroupName string, name // ListMetadataSlotSender sends the ListMetadataSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListMetadataSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListMetadataSlotResponder handles the response to the ListMetadataSlot request. The method always @@ -17162,7 +17546,9 @@ func (client AppsClient) ListMetricDefinitionsPreparer(resourceGroupName string, // ListMetricDefinitionsSender sends the ListMetricDefinitions request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListMetricDefinitionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListMetricDefinitionsResponder handles the response to the ListMetricDefinitions request. The method always @@ -17306,7 +17692,9 @@ func (client AppsClient) ListMetricDefinitionsSlotPreparer(resourceGroupName str // ListMetricDefinitionsSlotSender sends the ListMetricDefinitionsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListMetricDefinitionsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListMetricDefinitionsSlotResponder handles the response to the ListMetricDefinitionsSlot request. The method always @@ -17458,7 +17846,9 @@ func (client AppsClient) ListMetricsPreparer(resourceGroupName string, name stri // ListMetricsSender sends the ListMetrics request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListMetricsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListMetricsResponder handles the response to the ListMetrics request. The method always @@ -17612,7 +18002,9 @@ func (client AppsClient) ListMetricsSlotPreparer(resourceGroupName string, name // ListMetricsSlotSender sends the ListMetricsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListMetricsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListMetricsSlotResponder handles the response to the ListMetricsSlot request. The method always @@ -17756,7 +18148,9 @@ func (client AppsClient) ListNetworkFeaturesPreparer(resourceGroupName string, n // ListNetworkFeaturesSender sends the ListNetworkFeatures request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListNetworkFeaturesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListNetworkFeaturesResponder handles the response to the ListNetworkFeatures request. The method always @@ -17833,7 +18227,9 @@ func (client AppsClient) ListNetworkFeaturesSlotPreparer(resourceGroupName strin // ListNetworkFeaturesSlotSender sends the ListNetworkFeaturesSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListNetworkFeaturesSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListNetworkFeaturesSlotResponder handles the response to the ListNetworkFeaturesSlot request. The method always @@ -17911,7 +18307,9 @@ func (client AppsClient) ListPerfMonCountersPreparer(resourceGroupName string, n // ListPerfMonCountersSender sends the ListPerfMonCounters request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListPerfMonCountersSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListPerfMonCountersResponder handles the response to the ListPerfMonCounters request. The method always @@ -18060,7 +18458,9 @@ func (client AppsClient) ListPerfMonCountersSlotPreparer(resourceGroupName strin // ListPerfMonCountersSlotSender sends the ListPerfMonCountersSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListPerfMonCountersSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListPerfMonCountersSlotResponder handles the response to the ListPerfMonCountersSlot request. The method always @@ -18202,7 +18602,9 @@ func (client AppsClient) ListPremierAddOnsPreparer(resourceGroupName string, nam // ListPremierAddOnsSender sends the ListPremierAddOns request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListPremierAddOnsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListPremierAddOnsResponder handles the response to the ListPremierAddOns request. The method always @@ -18277,7 +18679,9 @@ func (client AppsClient) ListPremierAddOnsSlotPreparer(resourceGroupName string, // ListPremierAddOnsSlotSender sends the ListPremierAddOnsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListPremierAddOnsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListPremierAddOnsSlotResponder handles the response to the ListPremierAddOnsSlot request. The method always @@ -18351,7 +18755,9 @@ func (client AppsClient) ListProcessesPreparer(resourceGroupName string, name st // ListProcessesSender sends the ListProcesses request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListProcessesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListProcessesResponder handles the response to the ListProcesses request. The method always @@ -18496,7 +18902,9 @@ func (client AppsClient) ListProcessesSlotPreparer(resourceGroupName string, nam // ListProcessesSlotSender sends the ListProcessesSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListProcessesSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListProcessesSlotResponder handles the response to the ListProcessesSlot request. The method always @@ -18639,7 +19047,9 @@ func (client AppsClient) ListProcessModulesPreparer(resourceGroupName string, na // ListProcessModulesSender sends the ListProcessModules request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListProcessModulesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListProcessModulesResponder handles the response to the ListProcessModules request. The method always @@ -18786,7 +19196,9 @@ func (client AppsClient) ListProcessModulesSlotPreparer(resourceGroupName string // ListProcessModulesSlotSender sends the ListProcessModulesSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListProcessModulesSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListProcessModulesSlotResponder handles the response to the ListProcessModulesSlot request. The method always @@ -18929,7 +19341,9 @@ func (client AppsClient) ListProcessThreadsPreparer(resourceGroupName string, na // ListProcessThreadsSender sends the ListProcessThreads request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListProcessThreadsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListProcessThreadsResponder handles the response to the ListProcessThreads request. The method always @@ -19075,7 +19489,9 @@ func (client AppsClient) ListProcessThreadsSlotPreparer(resourceGroupName string // ListProcessThreadsSlotSender sends the ListProcessThreadsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListProcessThreadsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListProcessThreadsSlotResponder handles the response to the ListProcessThreadsSlot request. The method always @@ -19217,7 +19633,9 @@ func (client AppsClient) ListPublicCertificatesPreparer(resourceGroupName string // ListPublicCertificatesSender sends the ListPublicCertificates request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListPublicCertificatesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListPublicCertificatesResponder handles the response to the ListPublicCertificates request. The method always @@ -19361,7 +19779,9 @@ func (client AppsClient) ListPublicCertificatesSlotPreparer(resourceGroupName st // ListPublicCertificatesSlotSender sends the ListPublicCertificatesSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListPublicCertificatesSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListPublicCertificatesSlotResponder handles the response to the ListPublicCertificatesSlot request. The method always @@ -19523,6 +19943,7 @@ func (client AppsClient) ListPublishingCredentialsPreparer(resourceGroupName str func (client AppsClient) ListPublishingCredentialsSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -19619,6 +20040,7 @@ func (client AppsClient) ListPublishingCredentialsSlotPreparer(resourceGroupName func (client AppsClient) ListPublishingCredentialsSlotSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -19696,7 +20118,9 @@ func (client AppsClient) ListPublishingProfileXMLWithSecretsPreparer(resourceGro // ListPublishingProfileXMLWithSecretsSender sends the ListPublishingProfileXMLWithSecrets request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListPublishingProfileXMLWithSecretsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListPublishingProfileXMLWithSecretsResponder handles the response to the ListPublishingProfileXMLWithSecrets request. The method always @@ -19774,7 +20198,9 @@ func (client AppsClient) ListPublishingProfileXMLWithSecretsSlotPreparer(resourc // ListPublishingProfileXMLWithSecretsSlotSender sends the ListPublishingProfileXMLWithSecretsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListPublishingProfileXMLWithSecretsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListPublishingProfileXMLWithSecretsSlotResponder handles the response to the ListPublishingProfileXMLWithSecretsSlot request. The method always @@ -19846,7 +20272,9 @@ func (client AppsClient) ListRelayServiceConnectionsPreparer(resourceGroupName s // ListRelayServiceConnectionsSender sends the ListRelayServiceConnections request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListRelayServiceConnectionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListRelayServiceConnectionsResponder handles the response to the ListRelayServiceConnections request. The method always @@ -19921,7 +20349,9 @@ func (client AppsClient) ListRelayServiceConnectionsSlotPreparer(resourceGroupNa // ListRelayServiceConnectionsSlotSender sends the ListRelayServiceConnectionsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListRelayServiceConnectionsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListRelayServiceConnectionsSlotResponder handles the response to the ListRelayServiceConnectionsSlot request. The method always @@ -19994,7 +20424,9 @@ func (client AppsClient) ListSiteExtensionsPreparer(resourceGroupName string, na // ListSiteExtensionsSender sends the ListSiteExtensions request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListSiteExtensionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListSiteExtensionsResponder handles the response to the ListSiteExtensions request. The method always @@ -20138,7 +20570,9 @@ func (client AppsClient) ListSiteExtensionsSlotPreparer(resourceGroupName string // ListSiteExtensionsSlotSender sends the ListSiteExtensionsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListSiteExtensionsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListSiteExtensionsSlotResponder handles the response to the ListSiteExtensionsSlot request. The method always @@ -20280,7 +20714,9 @@ func (client AppsClient) ListSitePushSettingsPreparer(resourceGroupName string, // ListSitePushSettingsSender sends the ListSitePushSettings request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListSitePushSettingsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListSitePushSettingsResponder handles the response to the ListSitePushSettings request. The method always @@ -20355,7 +20791,9 @@ func (client AppsClient) ListSitePushSettingsSlotPreparer(resourceGroupName stri // ListSitePushSettingsSlotSender sends the ListSitePushSettingsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListSitePushSettingsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListSitePushSettingsSlotResponder handles the response to the ListSitePushSettingsSlot request. The method always @@ -20429,7 +20867,9 @@ func (client AppsClient) ListSlotConfigurationNamesPreparer(resourceGroupName st // ListSlotConfigurationNamesSender sends the ListSlotConfigurationNames request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListSlotConfigurationNamesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListSlotConfigurationNamesResponder handles the response to the ListSlotConfigurationNames request. The method always @@ -20508,7 +20948,9 @@ func (client AppsClient) ListSlotDifferencesFromProductionPreparer(resourceGroup // ListSlotDifferencesFromProductionSender sends the ListSlotDifferencesFromProduction request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListSlotDifferencesFromProductionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListSlotDifferencesFromProductionResponder handles the response to the ListSlotDifferencesFromProduction request. The method always @@ -20658,7 +21100,9 @@ func (client AppsClient) ListSlotDifferencesSlotPreparer(resourceGroupName strin // ListSlotDifferencesSlotSender sends the ListSlotDifferencesSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListSlotDifferencesSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListSlotDifferencesSlotResponder handles the response to the ListSlotDifferencesSlot request. The method always @@ -20800,7 +21244,9 @@ func (client AppsClient) ListSlotsPreparer(resourceGroupName string, name string // ListSlotsSender sends the ListSlots request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListSlotsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListSlotsResponder handles the response to the ListSlots request. The method always @@ -20942,7 +21388,9 @@ func (client AppsClient) ListSnapshotsPreparer(resourceGroupName string, name st // ListSnapshotsSender sends the ListSnapshots request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListSnapshotsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListSnapshotsResponder handles the response to the ListSnapshots request. The method always @@ -21086,7 +21534,9 @@ func (client AppsClient) ListSnapshotsSlotPreparer(resourceGroupName string, nam // ListSnapshotsSlotSender sends the ListSnapshotsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListSnapshotsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListSnapshotsSlotResponder handles the response to the ListSnapshotsSlot request. The method always @@ -21228,7 +21678,9 @@ func (client AppsClient) ListSyncFunctionTriggersPreparer(resourceGroupName stri // ListSyncFunctionTriggersSender sends the ListSyncFunctionTriggers request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListSyncFunctionTriggersSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListSyncFunctionTriggersResponder handles the response to the ListSyncFunctionTriggers request. The method always @@ -21303,7 +21755,9 @@ func (client AppsClient) ListSyncFunctionTriggersSlotPreparer(resourceGroupName // ListSyncFunctionTriggersSlotSender sends the ListSyncFunctionTriggersSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListSyncFunctionTriggersSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListSyncFunctionTriggersSlotResponder handles the response to the ListSyncFunctionTriggersSlot request. The method always @@ -21379,7 +21833,9 @@ func (client AppsClient) ListTriggeredWebJobHistoryPreparer(resourceGroupName st // ListTriggeredWebJobHistorySender sends the ListTriggeredWebJobHistory request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListTriggeredWebJobHistorySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListTriggeredWebJobHistoryResponder handles the response to the ListTriggeredWebJobHistory request. The method always @@ -21526,7 +21982,9 @@ func (client AppsClient) ListTriggeredWebJobHistorySlotPreparer(resourceGroupNam // ListTriggeredWebJobHistorySlotSender sends the ListTriggeredWebJobHistorySlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListTriggeredWebJobHistorySlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListTriggeredWebJobHistorySlotResponder handles the response to the ListTriggeredWebJobHistorySlot request. The method always @@ -21668,7 +22126,9 @@ func (client AppsClient) ListTriggeredWebJobsPreparer(resourceGroupName string, // ListTriggeredWebJobsSender sends the ListTriggeredWebJobs request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListTriggeredWebJobsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListTriggeredWebJobsResponder handles the response to the ListTriggeredWebJobs request. The method always @@ -21812,7 +22272,9 @@ func (client AppsClient) ListTriggeredWebJobsSlotPreparer(resourceGroupName stri // ListTriggeredWebJobsSlotSender sends the ListTriggeredWebJobsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListTriggeredWebJobsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListTriggeredWebJobsSlotResponder handles the response to the ListTriggeredWebJobsSlot request. The method always @@ -21960,7 +22422,9 @@ func (client AppsClient) ListUsagesPreparer(resourceGroupName string, name strin // ListUsagesSender sends the ListUsages request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListUsagesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListUsagesResponder handles the response to the ListUsages request. The method always @@ -22110,7 +22574,9 @@ func (client AppsClient) ListUsagesSlotPreparer(resourceGroupName string, name s // ListUsagesSlotSender sends the ListUsagesSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListUsagesSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListUsagesSlotResponder handles the response to the ListUsagesSlot request. The method always @@ -22252,7 +22718,9 @@ func (client AppsClient) ListVnetConnectionsPreparer(resourceGroupName string, n // ListVnetConnectionsSender sends the ListVnetConnections request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListVnetConnectionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListVnetConnectionsResponder handles the response to the ListVnetConnections request. The method always @@ -22328,7 +22796,9 @@ func (client AppsClient) ListVnetConnectionsSlotPreparer(resourceGroupName strin // ListVnetConnectionsSlotSender sends the ListVnetConnectionsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListVnetConnectionsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListVnetConnectionsSlotResponder handles the response to the ListVnetConnectionsSlot request. The method always @@ -22401,7 +22871,9 @@ func (client AppsClient) ListWebJobsPreparer(resourceGroupName string, name stri // ListWebJobsSender sends the ListWebJobs request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListWebJobsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListWebJobsResponder handles the response to the ListWebJobs request. The method always @@ -22545,7 +23017,9 @@ func (client AppsClient) ListWebJobsSlotPreparer(resourceGroupName string, name // ListWebJobsSlotSender sends the ListWebJobsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ListWebJobsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListWebJobsSlotResponder handles the response to the ListWebJobsSlot request. The method always @@ -22710,6 +23184,7 @@ func (client AppsClient) MigrateMySQLPreparer(resourceGroupName string, name str func (client AppsClient) MigrateMySQLSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -22806,6 +23281,7 @@ func (client AppsClient) MigrateStoragePreparer(subscriptionName string, resourc func (client AppsClient) MigrateStorageSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -22902,6 +23378,7 @@ func (client AppsClient) RecoverPreparer(resourceGroupName string, name string, func (client AppsClient) RecoverSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -22976,7 +23453,9 @@ func (client AppsClient) RecoverSiteConfigurationSnapshotPreparer(resourceGroupN // RecoverSiteConfigurationSnapshotSender sends the RecoverSiteConfigurationSnapshot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) RecoverSiteConfigurationSnapshotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RecoverSiteConfigurationSnapshotResponder handles the response to the RecoverSiteConfigurationSnapshot request. The method always @@ -23052,7 +23531,9 @@ func (client AppsClient) RecoverSiteConfigurationSnapshotSlotPreparer(resourceGr // RecoverSiteConfigurationSnapshotSlotSender sends the RecoverSiteConfigurationSnapshotSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) RecoverSiteConfigurationSnapshotSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RecoverSiteConfigurationSnapshotSlotResponder handles the response to the RecoverSiteConfigurationSnapshotSlot request. The method always @@ -23150,6 +23631,7 @@ func (client AppsClient) RecoverSlotPreparer(resourceGroupName string, name stri func (client AppsClient) RecoverSlotSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -23223,7 +23705,9 @@ func (client AppsClient) ResetProductionSlotConfigPreparer(resourceGroupName str // ResetProductionSlotConfigSender sends the ResetProductionSlotConfig request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ResetProductionSlotConfigSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ResetProductionSlotConfigResponder handles the response to the ResetProductionSlotConfig request. The method always @@ -23298,7 +23782,9 @@ func (client AppsClient) ResetSlotConfigurationSlotPreparer(resourceGroupName st // ResetSlotConfigurationSlotSender sends the ResetSlotConfigurationSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) ResetSlotConfigurationSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ResetSlotConfigurationSlotResponder handles the response to the ResetSlotConfigurationSlot request. The method always @@ -23379,7 +23865,9 @@ func (client AppsClient) RestartPreparer(resourceGroupName string, name string, // RestartSender sends the Restart request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) RestartSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RestartResponder handles the response to the Restart request. The method always @@ -23462,7 +23950,9 @@ func (client AppsClient) RestartSlotPreparer(resourceGroupName string, name stri // RestartSlotSender sends the RestartSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) RestartSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RestartSlotResponder handles the response to the RestartSlot request. The method always @@ -23558,6 +24048,7 @@ func (client AppsClient) RestorePreparer(resourceGroupName string, name string, func (client AppsClient) RestoreSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -23657,6 +24148,7 @@ func (client AppsClient) RestoreSlotPreparer(resourceGroupName string, name stri func (client AppsClient) RestoreSlotSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -23733,7 +24225,9 @@ func (client AppsClient) RunTriggeredWebJobPreparer(resourceGroupName string, na // RunTriggeredWebJobSender sends the RunTriggeredWebJob request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) RunTriggeredWebJobSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RunTriggeredWebJobResponder handles the response to the RunTriggeredWebJob request. The method always @@ -23810,7 +24304,9 @@ func (client AppsClient) RunTriggeredWebJobSlotPreparer(resourceGroupName string // RunTriggeredWebJobSlotSender sends the RunTriggeredWebJobSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) RunTriggeredWebJobSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RunTriggeredWebJobSlotResponder handles the response to the RunTriggeredWebJobSlot request. The method always @@ -23882,7 +24378,9 @@ func (client AppsClient) StartPreparer(resourceGroupName string, name string) (* // StartSender sends the Start request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) StartSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // StartResponder handles the response to the Start request. The method always @@ -23957,7 +24455,9 @@ func (client AppsClient) StartContinuousWebJobPreparer(resourceGroupName string, // StartContinuousWebJobSender sends the StartContinuousWebJob request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) StartContinuousWebJobSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // StartContinuousWebJobResponder handles the response to the StartContinuousWebJob request. The method always @@ -24034,7 +24534,9 @@ func (client AppsClient) StartContinuousWebJobSlotPreparer(resourceGroupName str // StartContinuousWebJobSlotSender sends the StartContinuousWebJobSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) StartContinuousWebJobSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // StartContinuousWebJobSlotResponder handles the response to the StartContinuousWebJobSlot request. The method always @@ -24108,7 +24610,9 @@ func (client AppsClient) StartSlotPreparer(resourceGroupName string, name string // StartSlotSender sends the StartSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) StartSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // StartSlotResponder handles the response to the StartSlot request. The method always @@ -24191,7 +24695,9 @@ func (client AppsClient) StartWebSiteNetworkTracePreparer(resourceGroupName stri // StartWebSiteNetworkTraceSender sends the StartWebSiteNetworkTrace request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) StartWebSiteNetworkTraceSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // StartWebSiteNetworkTraceResponder handles the response to the StartWebSiteNetworkTrace request. The method always @@ -24276,7 +24782,9 @@ func (client AppsClient) StartWebSiteNetworkTraceSlotPreparer(resourceGroupName // StartWebSiteNetworkTraceSlotSender sends the StartWebSiteNetworkTraceSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) StartWebSiteNetworkTraceSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // StartWebSiteNetworkTraceSlotResponder handles the response to the StartWebSiteNetworkTraceSlot request. The method always @@ -24349,7 +24857,9 @@ func (client AppsClient) StopPreparer(resourceGroupName string, name string) (*h // StopSender sends the Stop request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) StopSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // StopResponder handles the response to the Stop request. The method always @@ -24424,7 +24934,9 @@ func (client AppsClient) StopContinuousWebJobPreparer(resourceGroupName string, // StopContinuousWebJobSender sends the StopContinuousWebJob request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) StopContinuousWebJobSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // StopContinuousWebJobResponder handles the response to the StopContinuousWebJob request. The method always @@ -24501,7 +25013,9 @@ func (client AppsClient) StopContinuousWebJobSlotPreparer(resourceGroupName stri // StopContinuousWebJobSlotSender sends the StopContinuousWebJobSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) StopContinuousWebJobSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // StopContinuousWebJobSlotResponder handles the response to the StopContinuousWebJobSlot request. The method always @@ -24575,7 +25089,9 @@ func (client AppsClient) StopSlotPreparer(resourceGroupName string, name string, // StopSlotSender sends the StopSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) StopSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // StopSlotResponder handles the response to the StopSlot request. The method always @@ -24647,7 +25163,9 @@ func (client AppsClient) StopWebSiteNetworkTracePreparer(resourceGroupName strin // StopWebSiteNetworkTraceSender sends the StopWebSiteNetworkTrace request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) StopWebSiteNetworkTraceSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // StopWebSiteNetworkTraceResponder handles the response to the StopWebSiteNetworkTrace request. The method always @@ -24722,7 +25240,9 @@ func (client AppsClient) StopWebSiteNetworkTraceSlotPreparer(resourceGroupName s // StopWebSiteNetworkTraceSlotSender sends the StopWebSiteNetworkTraceSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) StopWebSiteNetworkTraceSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // StopWebSiteNetworkTraceSlotResponder handles the response to the StopWebSiteNetworkTraceSlot request. The method always @@ -24822,6 +25342,7 @@ func (client AppsClient) SwapSlotSlotPreparer(resourceGroupName string, name str func (client AppsClient) SwapSlotSlotSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -24920,6 +25441,7 @@ func (client AppsClient) SwapSlotWithProductionPreparer(resourceGroupName string func (client AppsClient) SwapSlotWithProductionSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -24992,7 +25514,9 @@ func (client AppsClient) SyncFunctionTriggersPreparer(resourceGroupName string, // SyncFunctionTriggersSender sends the SyncFunctionTriggers request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) SyncFunctionTriggersSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // SyncFunctionTriggersResponder handles the response to the SyncFunctionTriggers request. The method always @@ -25066,7 +25590,9 @@ func (client AppsClient) SyncFunctionTriggersSlotPreparer(resourceGroupName stri // SyncFunctionTriggersSlotSender sends the SyncFunctionTriggersSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) SyncFunctionTriggersSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // SyncFunctionTriggersSlotResponder handles the response to the SyncFunctionTriggersSlot request. The method always @@ -25138,7 +25664,9 @@ func (client AppsClient) SyncRepositoryPreparer(resourceGroupName string, name s // SyncRepositorySender sends the SyncRepository request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) SyncRepositorySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // SyncRepositoryResponder handles the response to the SyncRepository request. The method always @@ -25212,7 +25740,9 @@ func (client AppsClient) SyncRepositorySlotPreparer(resourceGroupName string, na // SyncRepositorySlotSender sends the SyncRepositorySlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) SyncRepositorySlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // SyncRepositorySlotResponder handles the response to the SyncRepositorySlot request. The method always @@ -25287,7 +25817,9 @@ func (client AppsClient) UpdateApplicationSettingsPreparer(resourceGroupName str // UpdateApplicationSettingsSender sends the UpdateApplicationSettings request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateApplicationSettingsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateApplicationSettingsResponder handles the response to the UpdateApplicationSettings request. The method always @@ -25365,7 +25897,9 @@ func (client AppsClient) UpdateApplicationSettingsSlotPreparer(resourceGroupName // UpdateApplicationSettingsSlotSender sends the UpdateApplicationSettingsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateApplicationSettingsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateApplicationSettingsSlotResponder handles the response to the UpdateApplicationSettingsSlot request. The method always @@ -25441,7 +25975,9 @@ func (client AppsClient) UpdateAuthSettingsPreparer(resourceGroupName string, na // UpdateAuthSettingsSender sends the UpdateAuthSettings request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateAuthSettingsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateAuthSettingsResponder handles the response to the UpdateAuthSettings request. The method always @@ -25519,7 +26055,9 @@ func (client AppsClient) UpdateAuthSettingsSlotPreparer(resourceGroupName string // UpdateAuthSettingsSlotSender sends the UpdateAuthSettingsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateAuthSettingsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateAuthSettingsSlotResponder handles the response to the UpdateAuthSettingsSlot request. The method always @@ -25603,7 +26141,9 @@ func (client AppsClient) UpdateBackupConfigurationPreparer(resourceGroupName str // UpdateBackupConfigurationSender sends the UpdateBackupConfiguration request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateBackupConfigurationSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateBackupConfigurationResponder handles the response to the UpdateBackupConfiguration request. The method always @@ -25689,7 +26229,9 @@ func (client AppsClient) UpdateBackupConfigurationSlotPreparer(resourceGroupName // UpdateBackupConfigurationSlotSender sends the UpdateBackupConfigurationSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateBackupConfigurationSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateBackupConfigurationSlotResponder handles the response to the UpdateBackupConfigurationSlot request. The method always @@ -25765,7 +26307,9 @@ func (client AppsClient) UpdateConfigurationPreparer(resourceGroupName string, n // UpdateConfigurationSender sends the UpdateConfiguration request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateConfigurationSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateConfigurationResponder handles the response to the UpdateConfiguration request. The method always @@ -25843,7 +26387,9 @@ func (client AppsClient) UpdateConfigurationSlotPreparer(resourceGroupName strin // UpdateConfigurationSlotSender sends the UpdateConfigurationSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateConfigurationSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateConfigurationSlotResponder handles the response to the UpdateConfigurationSlot request. The method always @@ -25919,7 +26465,9 @@ func (client AppsClient) UpdateConnectionStringsPreparer(resourceGroupName strin // UpdateConnectionStringsSender sends the UpdateConnectionStrings request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateConnectionStringsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateConnectionStringsResponder handles the response to the UpdateConnectionStrings request. The method always @@ -25997,7 +26545,9 @@ func (client AppsClient) UpdateConnectionStringsSlotPreparer(resourceGroupName s // UpdateConnectionStringsSlotSender sends the UpdateConnectionStringsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateConnectionStringsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateConnectionStringsSlotResponder handles the response to the UpdateConnectionStringsSlot request. The method always @@ -26089,7 +26639,9 @@ func (client AppsClient) UpdateDiagnosticLogsConfigPreparer(resourceGroupName st // UpdateDiagnosticLogsConfigSender sends the UpdateDiagnosticLogsConfig request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateDiagnosticLogsConfigSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateDiagnosticLogsConfigResponder handles the response to the UpdateDiagnosticLogsConfig request. The method always @@ -26183,7 +26735,9 @@ func (client AppsClient) UpdateDiagnosticLogsConfigSlotPreparer(resourceGroupNam // UpdateDiagnosticLogsConfigSlotSender sends the UpdateDiagnosticLogsConfigSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateDiagnosticLogsConfigSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateDiagnosticLogsConfigSlotResponder handles the response to the UpdateDiagnosticLogsConfigSlot request. The method always @@ -26262,7 +26816,9 @@ func (client AppsClient) UpdateDomainOwnershipIdentifierPreparer(resourceGroupNa // UpdateDomainOwnershipIdentifierSender sends the UpdateDomainOwnershipIdentifier request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateDomainOwnershipIdentifierSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateDomainOwnershipIdentifierResponder handles the response to the UpdateDomainOwnershipIdentifier request. The method always @@ -26343,7 +26899,9 @@ func (client AppsClient) UpdateDomainOwnershipIdentifierSlotPreparer(resourceGro // UpdateDomainOwnershipIdentifierSlotSender sends the UpdateDomainOwnershipIdentifierSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateDomainOwnershipIdentifierSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateDomainOwnershipIdentifierSlotResponder handles the response to the UpdateDomainOwnershipIdentifierSlot request. The method always @@ -26422,7 +26980,9 @@ func (client AppsClient) UpdateHybridConnectionPreparer(resourceGroupName string // UpdateHybridConnectionSender sends the UpdateHybridConnection request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateHybridConnectionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateHybridConnectionResponder handles the response to the UpdateHybridConnection request. The method always @@ -26502,7 +27062,9 @@ func (client AppsClient) UpdateHybridConnectionSlotPreparer(resourceGroupName st // UpdateHybridConnectionSlotSender sends the UpdateHybridConnectionSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateHybridConnectionSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateHybridConnectionSlotResponder handles the response to the UpdateHybridConnectionSlot request. The method always @@ -26578,7 +27140,9 @@ func (client AppsClient) UpdateMetadataPreparer(resourceGroupName string, name s // UpdateMetadataSender sends the UpdateMetadata request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateMetadataSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateMetadataResponder handles the response to the UpdateMetadata request. The method always @@ -26656,7 +27220,9 @@ func (client AppsClient) UpdateMetadataSlotPreparer(resourceGroupName string, na // UpdateMetadataSlotSender sends the UpdateMetadataSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateMetadataSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateMetadataSlotResponder handles the response to the UpdateMetadataSlot request. The method always @@ -26735,7 +27301,9 @@ func (client AppsClient) UpdateRelayServiceConnectionPreparer(resourceGroupName // UpdateRelayServiceConnectionSender sends the UpdateRelayServiceConnection request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateRelayServiceConnectionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateRelayServiceConnectionResponder handles the response to the UpdateRelayServiceConnection request. The method always @@ -26816,7 +27384,9 @@ func (client AppsClient) UpdateRelayServiceConnectionSlotPreparer(resourceGroupN // UpdateRelayServiceConnectionSlotSender sends the UpdateRelayServiceConnectionSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateRelayServiceConnectionSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateRelayServiceConnectionSlotResponder handles the response to the UpdateRelayServiceConnectionSlot request. The method always @@ -26892,7 +27462,9 @@ func (client AppsClient) UpdateSitePushSettingsPreparer(resourceGroupName string // UpdateSitePushSettingsSender sends the UpdateSitePushSettings request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateSitePushSettingsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateSitePushSettingsResponder handles the response to the UpdateSitePushSettings request. The method always @@ -26970,7 +27542,9 @@ func (client AppsClient) UpdateSitePushSettingsSlotPreparer(resourceGroupName st // UpdateSitePushSettingsSlotSender sends the UpdateSitePushSettingsSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateSitePushSettingsSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateSitePushSettingsSlotResponder handles the response to the UpdateSitePushSettingsSlot request. The method always @@ -27047,7 +27621,9 @@ func (client AppsClient) UpdateSlotConfigurationNamesPreparer(resourceGroupName // UpdateSlotConfigurationNamesSender sends the UpdateSlotConfigurationNames request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateSlotConfigurationNamesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateSlotConfigurationNamesResponder handles the response to the UpdateSlotConfigurationNames request. The method always @@ -27126,7 +27702,9 @@ func (client AppsClient) UpdateVnetConnectionPreparer(resourceGroupName string, // UpdateVnetConnectionSender sends the UpdateVnetConnection request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateVnetConnectionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateVnetConnectionResponder handles the response to the UpdateVnetConnection request. The method always @@ -27205,7 +27783,9 @@ func (client AppsClient) UpdateVnetConnectionGatewayPreparer(resourceGroupName s // UpdateVnetConnectionGatewaySender sends the UpdateVnetConnectionGateway request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateVnetConnectionGatewaySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateVnetConnectionGatewayResponder handles the response to the UpdateVnetConnectionGateway request. The method always @@ -27286,7 +27866,9 @@ func (client AppsClient) UpdateVnetConnectionGatewaySlotPreparer(resourceGroupNa // UpdateVnetConnectionGatewaySlotSender sends the UpdateVnetConnectionGatewaySlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateVnetConnectionGatewaySlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateVnetConnectionGatewaySlotResponder handles the response to the UpdateVnetConnectionGatewaySlot request. The method always @@ -27367,7 +27949,9 @@ func (client AppsClient) UpdateVnetConnectionSlotPreparer(resourceGroupName stri // UpdateVnetConnectionSlotSender sends the UpdateVnetConnectionSlot request. The method will close the // http.Response Body if it receives an error. func (client AppsClient) UpdateVnetConnectionSlotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateVnetConnectionSlotResponder handles the response to the UpdateVnetConnectionSlot request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/appservicecertificateorders.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/appservicecertificateorders.go index 7798b1f5a048..079a87c60fb8 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/appservicecertificateorders.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/appservicecertificateorders.go @@ -126,6 +126,7 @@ func (client AppServiceCertificateOrdersClient) CreateOrUpdatePreparer(resourceG func (client AppServiceCertificateOrdersClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -223,6 +224,7 @@ func (client AppServiceCertificateOrdersClient) CreateOrUpdateCertificatePrepare func (client AppServiceCertificateOrdersClient) CreateOrUpdateCertificateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -297,7 +299,9 @@ func (client AppServiceCertificateOrdersClient) DeletePreparer(resourceGroupName // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client AppServiceCertificateOrdersClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -371,7 +375,9 @@ func (client AppServiceCertificateOrdersClient) DeleteCertificatePreparer(resour // DeleteCertificateSender sends the DeleteCertificate request. The method will close the // http.Response Body if it receives an error. func (client AppServiceCertificateOrdersClient) DeleteCertificateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteCertificateResponder handles the response to the DeleteCertificate request. The method always @@ -444,7 +450,9 @@ func (client AppServiceCertificateOrdersClient) GetPreparer(resourceGroupName st // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client AppServiceCertificateOrdersClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -519,7 +527,9 @@ func (client AppServiceCertificateOrdersClient) GetCertificatePreparer(resourceG // GetCertificateSender sends the GetCertificate request. The method will close the // http.Response Body if it receives an error. func (client AppServiceCertificateOrdersClient) GetCertificateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetCertificateResponder handles the response to the GetCertificate request. The method always @@ -580,7 +590,9 @@ func (client AppServiceCertificateOrdersClient) ListPreparer() (*http.Request, e // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client AppServiceCertificateOrdersClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -721,7 +733,9 @@ func (client AppServiceCertificateOrdersClient) ListByResourceGroupPreparer(reso // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client AppServiceCertificateOrdersClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -864,7 +878,9 @@ func (client AppServiceCertificateOrdersClient) ListCertificatesPreparer(resourc // ListCertificatesSender sends the ListCertificates request. The method will close the // http.Response Body if it receives an error. func (client AppServiceCertificateOrdersClient) ListCertificatesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListCertificatesResponder handles the response to the ListCertificates request. The method always @@ -1009,7 +1025,9 @@ func (client AppServiceCertificateOrdersClient) ReissuePreparer(resourceGroupNam // ReissueSender sends the Reissue request. The method will close the // http.Response Body if it receives an error. func (client AppServiceCertificateOrdersClient) ReissueSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ReissueResponder handles the response to the Reissue request. The method always @@ -1084,7 +1102,9 @@ func (client AppServiceCertificateOrdersClient) RenewPreparer(resourceGroupName // RenewSender sends the Renew request. The method will close the // http.Response Body if it receives an error. func (client AppServiceCertificateOrdersClient) RenewSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RenewResponder handles the response to the Renew request. The method always @@ -1157,7 +1177,9 @@ func (client AppServiceCertificateOrdersClient) ResendEmailPreparer(resourceGrou // ResendEmailSender sends the ResendEmail request. The method will close the // http.Response Body if it receives an error. func (client AppServiceCertificateOrdersClient) ResendEmailSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ResendEmailResponder handles the response to the ResendEmail request. The method always @@ -1232,7 +1254,9 @@ func (client AppServiceCertificateOrdersClient) ResendRequestEmailsPreparer(reso // ResendRequestEmailsSender sends the ResendRequestEmails request. The method will close the // http.Response Body if it receives an error. func (client AppServiceCertificateOrdersClient) ResendRequestEmailsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ResendRequestEmailsResponder handles the response to the ResendRequestEmails request. The method always @@ -1305,7 +1329,9 @@ func (client AppServiceCertificateOrdersClient) RetrieveCertificateActionsPrepar // RetrieveCertificateActionsSender sends the RetrieveCertificateActions request. The method will close the // http.Response Body if it receives an error. func (client AppServiceCertificateOrdersClient) RetrieveCertificateActionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RetrieveCertificateActionsResponder handles the response to the RetrieveCertificateActions request. The method always @@ -1379,7 +1405,9 @@ func (client AppServiceCertificateOrdersClient) RetrieveCertificateEmailHistoryP // RetrieveCertificateEmailHistorySender sends the RetrieveCertificateEmailHistory request. The method will close the // http.Response Body if it receives an error. func (client AppServiceCertificateOrdersClient) RetrieveCertificateEmailHistorySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RetrieveCertificateEmailHistoryResponder handles the response to the RetrieveCertificateEmailHistory request. The method always @@ -1455,7 +1483,9 @@ func (client AppServiceCertificateOrdersClient) RetrieveSiteSealPreparer(resourc // RetrieveSiteSealSender sends the RetrieveSiteSeal request. The method will close the // http.Response Body if it receives an error. func (client AppServiceCertificateOrdersClient) RetrieveSiteSealSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RetrieveSiteSealResponder handles the response to the RetrieveSiteSeal request. The method always @@ -1531,7 +1561,9 @@ func (client AppServiceCertificateOrdersClient) ValidatePurchaseInformationPrepa // ValidatePurchaseInformationSender sends the ValidatePurchaseInformation request. The method will close the // http.Response Body if it receives an error. func (client AppServiceCertificateOrdersClient) ValidatePurchaseInformationSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ValidatePurchaseInformationResponder handles the response to the ValidatePurchaseInformation request. The method always @@ -1604,7 +1636,9 @@ func (client AppServiceCertificateOrdersClient) VerifyDomainOwnershipPreparer(re // VerifyDomainOwnershipSender sends the VerifyDomainOwnership request. The method will close the // http.Response Body if it receives an error. func (client AppServiceCertificateOrdersClient) VerifyDomainOwnershipSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // VerifyDomainOwnershipResponder handles the response to the VerifyDomainOwnership request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/appserviceenvironments.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/appserviceenvironments.go index a2f811338a8f..ebe475b9c59a 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/appserviceenvironments.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/appserviceenvironments.go @@ -126,6 +126,7 @@ func (client AppServiceEnvironmentsClient) CreateOrUpdatePreparer(resourceGroupN func (client AppServiceEnvironmentsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -222,6 +223,7 @@ func (client AppServiceEnvironmentsClient) CreateOrUpdateMultiRolePoolPreparer(r func (client AppServiceEnvironmentsClient) CreateOrUpdateMultiRolePoolSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -319,6 +321,7 @@ func (client AppServiceEnvironmentsClient) CreateOrUpdateWorkerPoolPreparer(reso func (client AppServiceEnvironmentsClient) CreateOrUpdateWorkerPoolSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -416,6 +419,7 @@ func (client AppServiceEnvironmentsClient) DeletePreparer(resourceGroupName stri func (client AppServiceEnvironmentsClient) DeleteSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -489,7 +493,9 @@ func (client AppServiceEnvironmentsClient) GetPreparer(resourceGroupName string, // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -564,7 +570,9 @@ func (client AppServiceEnvironmentsClient) GetDiagnosticsItemPreparer(resourceGr // GetDiagnosticsItemSender sends the GetDiagnosticsItem request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) GetDiagnosticsItemSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetDiagnosticsItemResponder handles the response to the GetDiagnosticsItem request. The method always @@ -638,7 +646,9 @@ func (client AppServiceEnvironmentsClient) GetMultiRolePoolPreparer(resourceGrou // GetMultiRolePoolSender sends the GetMultiRolePool request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) GetMultiRolePoolSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetMultiRolePoolResponder handles the response to the GetMultiRolePool request. The method always @@ -713,7 +723,9 @@ func (client AppServiceEnvironmentsClient) GetWorkerPoolPreparer(resourceGroupNa // GetWorkerPoolSender sends the GetWorkerPool request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) GetWorkerPoolSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetWorkerPoolResponder handles the response to the GetWorkerPool request. The method always @@ -774,7 +786,9 @@ func (client AppServiceEnvironmentsClient) ListPreparer() (*http.Request, error) // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -917,7 +931,9 @@ func (client AppServiceEnvironmentsClient) ListAppServicePlansPreparer(resourceG // ListAppServicePlansSender sends the ListAppServicePlans request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListAppServicePlansSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAppServicePlansResponder handles the response to the ListAppServicePlans request. The method always @@ -1058,7 +1074,9 @@ func (client AppServiceEnvironmentsClient) ListByResourceGroupPreparer(resourceG // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -1201,7 +1219,9 @@ func (client AppServiceEnvironmentsClient) ListCapacitiesPreparer(resourceGroupN // ListCapacitiesSender sends the ListCapacities request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListCapacitiesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListCapacitiesResponder handles the response to the ListCapacities request. The method always @@ -1344,7 +1364,9 @@ func (client AppServiceEnvironmentsClient) ListDiagnosticsPreparer(resourceGroup // ListDiagnosticsSender sends the ListDiagnostics request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListDiagnosticsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListDiagnosticsResponder handles the response to the ListDiagnostics request. The method always @@ -1418,7 +1440,9 @@ func (client AppServiceEnvironmentsClient) ListMetricDefinitionsPreparer(resourc // ListMetricDefinitionsSender sends the ListMetricDefinitions request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListMetricDefinitionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListMetricDefinitionsResponder handles the response to the ListMetricDefinitions request. The method always @@ -1501,7 +1525,9 @@ func (client AppServiceEnvironmentsClient) ListMetricsPreparer(resourceGroupName // ListMetricsSender sends the ListMetrics request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListMetricsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListMetricsResponder handles the response to the ListMetrics request. The method always @@ -1644,7 +1670,9 @@ func (client AppServiceEnvironmentsClient) ListMultiRoleMetricDefinitionsPrepare // ListMultiRoleMetricDefinitionsSender sends the ListMultiRoleMetricDefinitions request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListMultiRoleMetricDefinitionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListMultiRoleMetricDefinitionsResponder handles the response to the ListMultiRoleMetricDefinitions request. The method always @@ -1806,7 +1834,9 @@ func (client AppServiceEnvironmentsClient) ListMultiRoleMetricsPreparer(resource // ListMultiRoleMetricsSender sends the ListMultiRoleMetrics request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListMultiRoleMetricsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListMultiRoleMetricsResponder handles the response to the ListMultiRoleMetrics request. The method always @@ -1951,7 +1981,9 @@ func (client AppServiceEnvironmentsClient) ListMultiRolePoolInstanceMetricDefini // ListMultiRolePoolInstanceMetricDefinitionsSender sends the ListMultiRolePoolInstanceMetricDefinitions request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListMultiRolePoolInstanceMetricDefinitionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListMultiRolePoolInstanceMetricDefinitionsResponder handles the response to the ListMultiRolePoolInstanceMetricDefinitions request. The method always @@ -2100,7 +2132,9 @@ func (client AppServiceEnvironmentsClient) ListMultiRolePoolInstanceMetricsPrepa // ListMultiRolePoolInstanceMetricsSender sends the ListMultiRolePoolInstanceMetrics request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListMultiRolePoolInstanceMetricsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListMultiRolePoolInstanceMetricsResponder handles the response to the ListMultiRolePoolInstanceMetrics request. The method always @@ -2243,7 +2277,9 @@ func (client AppServiceEnvironmentsClient) ListMultiRolePoolsPreparer(resourceGr // ListMultiRolePoolsSender sends the ListMultiRolePools request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListMultiRolePoolsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListMultiRolePoolsResponder handles the response to the ListMultiRolePools request. The method always @@ -2386,7 +2422,9 @@ func (client AppServiceEnvironmentsClient) ListMultiRolePoolSkusPreparer(resourc // ListMultiRolePoolSkusSender sends the ListMultiRolePoolSkus request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListMultiRolePoolSkusSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListMultiRolePoolSkusResponder handles the response to the ListMultiRolePoolSkus request. The method always @@ -2529,7 +2567,9 @@ func (client AppServiceEnvironmentsClient) ListMultiRoleUsagesPreparer(resourceG // ListMultiRoleUsagesSender sends the ListMultiRoleUsages request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListMultiRoleUsagesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListMultiRoleUsagesResponder handles the response to the ListMultiRoleUsages request. The method always @@ -2672,7 +2712,9 @@ func (client AppServiceEnvironmentsClient) ListOperationsPreparer(resourceGroupN // ListOperationsSender sends the ListOperations request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListOperationsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListOperationsResponder handles the response to the ListOperations request. The method always @@ -2751,7 +2793,9 @@ func (client AppServiceEnvironmentsClient) ListUsagesPreparer(resourceGroupName // ListUsagesSender sends the ListUsages request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListUsagesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListUsagesResponder handles the response to the ListUsages request. The method always @@ -2894,7 +2938,9 @@ func (client AppServiceEnvironmentsClient) ListVipsPreparer(resourceGroupName st // ListVipsSender sends the ListVips request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListVipsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListVipsResponder handles the response to the ListVips request. The method always @@ -2971,7 +3017,9 @@ func (client AppServiceEnvironmentsClient) ListWebAppsPreparer(resourceGroupName // ListWebAppsSender sends the ListWebApps request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListWebAppsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListWebAppsResponder handles the response to the ListWebApps request. The method always @@ -3115,7 +3163,9 @@ func (client AppServiceEnvironmentsClient) ListWebWorkerMetricDefinitionsPrepare // ListWebWorkerMetricDefinitionsSender sends the ListWebWorkerMetricDefinitions request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListWebWorkerMetricDefinitionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListWebWorkerMetricDefinitionsResponder handles the response to the ListWebWorkerMetricDefinitions request. The method always @@ -3268,7 +3318,9 @@ func (client AppServiceEnvironmentsClient) ListWebWorkerMetricsPreparer(resource // ListWebWorkerMetricsSender sends the ListWebWorkerMetrics request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListWebWorkerMetricsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListWebWorkerMetricsResponder handles the response to the ListWebWorkerMetrics request. The method always @@ -3412,7 +3464,9 @@ func (client AppServiceEnvironmentsClient) ListWebWorkerUsagesPreparer(resourceG // ListWebWorkerUsagesSender sends the ListWebWorkerUsages request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListWebWorkerUsagesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListWebWorkerUsagesResponder handles the response to the ListWebWorkerUsages request. The method always @@ -3558,7 +3612,9 @@ func (client AppServiceEnvironmentsClient) ListWorkerPoolInstanceMetricDefinitio // ListWorkerPoolInstanceMetricDefinitionsSender sends the ListWorkerPoolInstanceMetricDefinitions request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListWorkerPoolInstanceMetricDefinitionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListWorkerPoolInstanceMetricDefinitionsResponder handles the response to the ListWorkerPoolInstanceMetricDefinitions request. The method always @@ -3713,7 +3769,9 @@ func (client AppServiceEnvironmentsClient) ListWorkerPoolInstanceMetricsPreparer // ListWorkerPoolInstanceMetricsSender sends the ListWorkerPoolInstanceMetrics request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListWorkerPoolInstanceMetricsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListWorkerPoolInstanceMetricsResponder handles the response to the ListWorkerPoolInstanceMetrics request. The method always @@ -3856,7 +3914,9 @@ func (client AppServiceEnvironmentsClient) ListWorkerPoolsPreparer(resourceGroup // ListWorkerPoolsSender sends the ListWorkerPools request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListWorkerPoolsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListWorkerPoolsResponder handles the response to the ListWorkerPools request. The method always @@ -4000,7 +4060,9 @@ func (client AppServiceEnvironmentsClient) ListWorkerPoolSkusPreparer(resourceGr // ListWorkerPoolSkusSender sends the ListWorkerPoolSkus request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) ListWorkerPoolSkusSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListWorkerPoolSkusResponder handles the response to the ListWorkerPoolSkus request. The method always @@ -4143,7 +4205,9 @@ func (client AppServiceEnvironmentsClient) RebootPreparer(resourceGroupName stri // RebootSender sends the Reboot request. The method will close the // http.Response Body if it receives an error. func (client AppServiceEnvironmentsClient) RebootSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RebootResponder handles the response to the Reboot request. The method always @@ -4219,6 +4283,7 @@ func (client AppServiceEnvironmentsClient) ResumePreparer(resourceGroupName stri func (client AppServiceEnvironmentsClient) ResumeSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -4365,6 +4430,7 @@ func (client AppServiceEnvironmentsClient) SuspendPreparer(resourceGroupName str func (client AppServiceEnvironmentsClient) SuspendSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/appserviceplans.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/appserviceplans.go index 6f0e12f9f6ce..1d8d87e73005 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/appserviceplans.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/appserviceplans.go @@ -119,6 +119,7 @@ func (client AppServicePlansClient) CreateOrUpdatePreparer(resourceGroupName str func (client AppServicePlansClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -198,7 +199,9 @@ func (client AppServicePlansClient) CreateOrUpdateVnetRoutePreparer(resourceGrou // CreateOrUpdateVnetRouteSender sends the CreateOrUpdateVnetRoute request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) CreateOrUpdateVnetRouteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateVnetRouteResponder handles the response to the CreateOrUpdateVnetRoute request. The method always @@ -271,7 +274,9 @@ func (client AppServicePlansClient) DeletePreparer(resourceGroupName string, nam // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -346,7 +351,9 @@ func (client AppServicePlansClient) DeleteHybridConnectionPreparer(resourceGroup // DeleteHybridConnectionSender sends the DeleteHybridConnection request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) DeleteHybridConnectionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteHybridConnectionResponder handles the response to the DeleteHybridConnection request. The method always @@ -421,7 +428,9 @@ func (client AppServicePlansClient) DeleteVnetRoutePreparer(resourceGroupName st // DeleteVnetRouteSender sends the DeleteVnetRoute request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) DeleteVnetRouteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteVnetRouteResponder handles the response to the DeleteVnetRoute request. The method always @@ -493,7 +502,9 @@ func (client AppServicePlansClient) GetPreparer(resourceGroupName string, name s // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -569,7 +580,9 @@ func (client AppServicePlansClient) GetHybridConnectionPreparer(resourceGroupNam // GetHybridConnectionSender sends the GetHybridConnection request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) GetHybridConnectionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetHybridConnectionResponder handles the response to the GetHybridConnection request. The method always @@ -642,7 +655,9 @@ func (client AppServicePlansClient) GetHybridConnectionPlanLimitPreparer(resourc // GetHybridConnectionPlanLimitSender sends the GetHybridConnectionPlanLimit request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) GetHybridConnectionPlanLimitSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetHybridConnectionPlanLimitResponder handles the response to the GetHybridConnectionPlanLimit request. The method always @@ -718,7 +733,9 @@ func (client AppServicePlansClient) GetRouteForVnetPreparer(resourceGroupName st // GetRouteForVnetSender sends the GetRouteForVnet request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) GetRouteForVnetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetRouteForVnetResponder handles the response to the GetRouteForVnet request. The method always @@ -793,7 +810,9 @@ func (client AppServicePlansClient) GetVnetFromServerFarmPreparer(resourceGroupN // GetVnetFromServerFarmSender sends the GetVnetFromServerFarm request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) GetVnetFromServerFarmSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetVnetFromServerFarmResponder handles the response to the GetVnetFromServerFarm request. The method always @@ -870,7 +889,9 @@ func (client AppServicePlansClient) GetVnetGatewayPreparer(resourceGroupName str // GetVnetGatewaySender sends the GetVnetGateway request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) GetVnetGatewaySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetVnetGatewayResponder handles the response to the GetVnetGateway request. The method always @@ -938,7 +959,9 @@ func (client AppServicePlansClient) ListPreparer(detailed *bool) (*http.Request, // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -1079,7 +1102,9 @@ func (client AppServicePlansClient) ListByResourceGroupPreparer(resourceGroupNam // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -1221,7 +1246,9 @@ func (client AppServicePlansClient) ListCapabilitiesPreparer(resourceGroupName s // ListCapabilitiesSender sends the ListCapabilities request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) ListCapabilitiesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListCapabilitiesResponder handles the response to the ListCapabilities request. The method always @@ -1297,7 +1324,9 @@ func (client AppServicePlansClient) ListHybridConnectionKeysPreparer(resourceGro // ListHybridConnectionKeysSender sends the ListHybridConnectionKeys request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) ListHybridConnectionKeysSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListHybridConnectionKeysResponder handles the response to the ListHybridConnectionKeys request. The method always @@ -1370,7 +1399,9 @@ func (client AppServicePlansClient) ListHybridConnectionsPreparer(resourceGroupN // ListHybridConnectionsSender sends the ListHybridConnections request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) ListHybridConnectionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListHybridConnectionsResponder handles the response to the ListHybridConnections request. The method always @@ -1512,7 +1543,9 @@ func (client AppServicePlansClient) ListMetricDefintionsPreparer(resourceGroupNa // ListMetricDefintionsSender sends the ListMetricDefintions request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) ListMetricDefintionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListMetricDefintionsResponder handles the response to the ListMetricDefintions request. The method always @@ -1664,7 +1697,9 @@ func (client AppServicePlansClient) ListMetricsPreparer(resourceGroupName string // ListMetricsSender sends the ListMetrics request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) ListMetricsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListMetricsResponder handles the response to the ListMetrics request. The method always @@ -1808,7 +1843,9 @@ func (client AppServicePlansClient) ListRoutesForVnetPreparer(resourceGroupName // ListRoutesForVnetSender sends the ListRoutesForVnet request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) ListRoutesForVnetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListRoutesForVnetResponder handles the response to the ListRoutesForVnet request. The method always @@ -1881,7 +1918,9 @@ func (client AppServicePlansClient) ListVnetsPreparer(resourceGroupName string, // ListVnetsSender sends the ListVnets request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) ListVnetsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListVnetsResponder handles the response to the ListVnets request. The method always @@ -1967,7 +2006,9 @@ func (client AppServicePlansClient) ListWebAppsPreparer(resourceGroupName string // ListWebAppsSender sends the ListWebApps request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) ListWebAppsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListWebAppsResponder handles the response to the ListWebApps request. The method always @@ -2112,7 +2153,9 @@ func (client AppServicePlansClient) ListWebAppsByHybridConnectionPreparer(resour // ListWebAppsByHybridConnectionSender sends the ListWebAppsByHybridConnection request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) ListWebAppsByHybridConnectionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListWebAppsByHybridConnectionResponder handles the response to the ListWebAppsByHybridConnection request. The method always @@ -2256,7 +2299,9 @@ func (client AppServicePlansClient) RebootWorkerPreparer(resourceGroupName strin // RebootWorkerSender sends the RebootWorker request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) RebootWorkerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RebootWorkerResponder handles the response to the RebootWorker request. The method always @@ -2333,7 +2378,9 @@ func (client AppServicePlansClient) RestartWebAppsPreparer(resourceGroupName str // RestartWebAppsSender sends the RestartWebApps request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) RestartWebAppsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // RestartWebAppsResponder handles the response to the RestartWebApps request. The method always @@ -2411,7 +2458,9 @@ func (client AppServicePlansClient) UpdateVnetGatewayPreparer(resourceGroupName // UpdateVnetGatewaySender sends the UpdateVnetGateway request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) UpdateVnetGatewaySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateVnetGatewayResponder handles the response to the UpdateVnetGateway request. The method always @@ -2490,7 +2539,9 @@ func (client AppServicePlansClient) UpdateVnetRoutePreparer(resourceGroupName st // UpdateVnetRouteSender sends the UpdateVnetRoute request. The method will close the // http.Response Body if it receives an error. func (client AppServicePlansClient) UpdateVnetRouteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateVnetRouteResponder handles the response to the UpdateVnetRoute request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/certificates.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/certificates.go index fc28ebb4d430..cec54a9712c5 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/certificates.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/certificates.go @@ -99,7 +99,9 @@ func (client CertificatesClient) CreateOrUpdatePreparer(resourceGroupName string // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client CertificatesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always @@ -172,7 +174,9 @@ func (client CertificatesClient) DeletePreparer(resourceGroupName string, name s // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client CertificatesClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -244,7 +248,9 @@ func (client CertificatesClient) GetPreparer(resourceGroupName string, name stri // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client CertificatesClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -305,7 +311,9 @@ func (client CertificatesClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client CertificatesClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -446,7 +454,9 @@ func (client CertificatesClient) ListByResourceGroupPreparer(resourceGroupName s // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client CertificatesClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -591,7 +601,9 @@ func (client CertificatesClient) UpdatePreparer(resourceGroupName string, name s // UpdateSender sends the Update request. The method will close the // http.Response Body if it receives an error. func (client CertificatesClient) UpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateResponder handles the response to the Update request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/client.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/client.go index 72b9e069ac77..5c52a2afb6c2 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/client.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/client.go @@ -108,7 +108,9 @@ func (client ManagementClient) CheckNameAvailabilityPreparer(request ResourceNam // CheckNameAvailabilitySender sends the CheckNameAvailability request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) CheckNameAvailabilitySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CheckNameAvailabilityResponder handles the response to the CheckNameAvailability request. The method always @@ -165,7 +167,9 @@ func (client ManagementClient) GetPublishingUserPreparer() (*http.Request, error // GetPublishingUserSender sends the GetPublishingUser request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetPublishingUserSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetPublishingUserResponder handles the response to the GetPublishingUser request. The method always @@ -235,7 +239,9 @@ func (client ManagementClient) ListGeoRegionsPreparer(sku SkuName, linuxWorkersE // ListGeoRegionsSender sends the ListGeoRegions request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) ListGeoRegionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListGeoRegionsResponder handles the response to the ListGeoRegions request. The method always @@ -365,7 +371,9 @@ func (client ManagementClient) ListPremierAddOnOffersPreparer() (*http.Request, // ListPremierAddOnOffersSender sends the ListPremierAddOnOffers request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) ListPremierAddOnOffersSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListPremierAddOnOffersResponder handles the response to the ListPremierAddOnOffers request. The method always @@ -495,7 +503,9 @@ func (client ManagementClient) ListSkusPreparer() (*http.Request, error) { // ListSkusSender sends the ListSkus request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) ListSkusSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListSkusResponder handles the response to the ListSkus request. The method always @@ -552,7 +562,9 @@ func (client ManagementClient) ListSourceControlsPreparer() (*http.Request, erro // ListSourceControlsSender sends the ListSourceControls request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) ListSourceControlsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListSourceControlsResponder handles the response to the ListSourceControls request. The method always @@ -702,7 +714,9 @@ func (client ManagementClient) MovePreparer(resourceGroupName string, moveResour // MoveSender sends the Move request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) MoveSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // MoveResponder handles the response to the Move request. The method always @@ -762,7 +776,9 @@ func (client ManagementClient) UpdatePublishingUserPreparer(userDetails User) (* // UpdatePublishingUserSender sends the UpdatePublishingUser request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) UpdatePublishingUserSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // UpdatePublishingUserResponder handles the response to the UpdatePublishingUser request. The method always @@ -827,7 +843,9 @@ func (client ManagementClient) UpdateSourceControlPreparer(sourceControlType str // UpdateSourceControlSender sends the UpdateSourceControl request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) UpdateSourceControlSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // UpdateSourceControlResponder handles the response to the UpdateSourceControl request. The method always @@ -909,7 +927,9 @@ func (client ManagementClient) ValidatePreparer(resourceGroupName string, valida // ValidateSender sends the Validate request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) ValidateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ValidateResponder handles the response to the Validate request. The method always @@ -990,7 +1010,9 @@ func (client ManagementClient) ValidateMovePreparer(resourceGroupName string, mo // ValidateMoveSender sends the ValidateMove request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) ValidateMoveSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ValidateMoveResponder handles the response to the ValidateMove request. The method always @@ -1055,7 +1077,9 @@ func (client ManagementClient) VerifyHostingEnvironmentVnetPreparer(parameters V // VerifyHostingEnvironmentVnetSender sends the VerifyHostingEnvironmentVnet request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) VerifyHostingEnvironmentVnetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // VerifyHostingEnvironmentVnetResponder handles the response to the VerifyHostingEnvironmentVnet request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/deletedwebapps.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/deletedwebapps.go index b9f08518f5fb..4c2b13eaede4 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/deletedwebapps.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/deletedwebapps.go @@ -83,7 +83,9 @@ func (client DeletedWebAppsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client DeletedWebAppsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/domains.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/domains.go index 63e43b550ceb..7f61fa2a7d50 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/domains.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/domains.go @@ -88,7 +88,9 @@ func (client DomainsClient) CheckAvailabilityPreparer(identifier NameIdentifier) // CheckAvailabilitySender sends the CheckAvailability request. The method will close the // http.Response Body if it receives an error. func (client DomainsClient) CheckAvailabilitySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CheckAvailabilityResponder handles the response to the CheckAvailability request. The method always @@ -240,6 +242,7 @@ func (client DomainsClient) CreateOrUpdatePreparer(resourceGroupName string, dom func (client DomainsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client), azure.DoPollForAsynchronous(client.PollingDelay)) } @@ -318,7 +321,9 @@ func (client DomainsClient) CreateOrUpdateOwnershipIdentifierPreparer(resourceGr // CreateOrUpdateOwnershipIdentifierSender sends the CreateOrUpdateOwnershipIdentifier request. The method will close the // http.Response Body if it receives an error. func (client DomainsClient) CreateOrUpdateOwnershipIdentifierSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // CreateOrUpdateOwnershipIdentifierResponder handles the response to the CreateOrUpdateOwnershipIdentifier request. The method always @@ -396,7 +401,9 @@ func (client DomainsClient) DeletePreparer(resourceGroupName string, domainName // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client DomainsClient) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteResponder handles the response to the Delete request. The method always @@ -470,7 +477,9 @@ func (client DomainsClient) DeleteOwnershipIdentifierPreparer(resourceGroupName // DeleteOwnershipIdentifierSender sends the DeleteOwnershipIdentifier request. The method will close the // http.Response Body if it receives an error. func (client DomainsClient) DeleteOwnershipIdentifierSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DeleteOwnershipIdentifierResponder handles the response to the DeleteOwnershipIdentifier request. The method always @@ -542,7 +551,9 @@ func (client DomainsClient) GetPreparer(resourceGroupName string, domainName str // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client DomainsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -603,7 +614,9 @@ func (client DomainsClient) GetControlCenterSsoRequestPreparer() (*http.Request, // GetControlCenterSsoRequestSender sends the GetControlCenterSsoRequest request. The method will close the // http.Response Body if it receives an error. func (client DomainsClient) GetControlCenterSsoRequestSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetControlCenterSsoRequestResponder handles the response to the GetControlCenterSsoRequest request. The method always @@ -678,7 +691,9 @@ func (client DomainsClient) GetOwnershipIdentifierPreparer(resourceGroupName str // GetOwnershipIdentifierSender sends the GetOwnershipIdentifier request. The method will close the // http.Response Body if it receives an error. func (client DomainsClient) GetOwnershipIdentifierSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetOwnershipIdentifierResponder handles the response to the GetOwnershipIdentifier request. The method always @@ -739,7 +754,9 @@ func (client DomainsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client DomainsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -880,7 +897,9 @@ func (client DomainsClient) ListByResourceGroupPreparer(resourceGroupName string // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the // http.Response Body if it receives an error. func (client DomainsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always @@ -1022,7 +1041,9 @@ func (client DomainsClient) ListOwnershipIdentifiersPreparer(resourceGroupName s // ListOwnershipIdentifiersSender sends the ListOwnershipIdentifiers request. The method will close the // http.Response Body if it receives an error. func (client DomainsClient) ListOwnershipIdentifiersSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListOwnershipIdentifiersResponder handles the response to the ListOwnershipIdentifiers request. The method always @@ -1156,7 +1177,9 @@ func (client DomainsClient) ListRecommendationsPreparer(parameters DomainRecomme // ListRecommendationsSender sends the ListRecommendations request. The method will close the // http.Response Body if it receives an error. func (client DomainsClient) ListRecommendationsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListRecommendationsResponder handles the response to the ListRecommendations request. The method always @@ -1303,7 +1326,9 @@ func (client DomainsClient) UpdateOwnershipIdentifierPreparer(resourceGroupName // UpdateOwnershipIdentifierSender sends the UpdateOwnershipIdentifier request. The method will close the // http.Response Body if it receives an error. func (client DomainsClient) UpdateOwnershipIdentifierSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // UpdateOwnershipIdentifierResponder handles the response to the UpdateOwnershipIdentifier request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/models.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/models.go index ff7cf80ee217..082a6591c7b3 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/models.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/models.go @@ -969,6 +969,25 @@ type AppServiceCertificateOrder struct { *AppServiceCertificateOrderProperties `json:"properties,omitempty"` } +// AppServiceCertificateOrderCollection is collection of certitificate orders. +type AppServiceCertificateOrderCollection struct { + autorest.Response `json:"-"` + Value *[]AppServiceCertificateOrder `json:"value,omitempty"` + NextLink *string `json:"nextLink,omitempty"` +} + +// AppServiceCertificateOrderCollectionPreparer prepares a request to retrieve the next set of results. It returns +// nil if no more results exist. +func (client AppServiceCertificateOrderCollection) AppServiceCertificateOrderCollectionPreparer() (*http.Request, error) { + if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 { + return nil, nil + } + return autorest.Prepare(&http.Request{}, + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String(client.NextLink))) +} + // AppServiceCertificateOrderProperties is appServiceCertificateOrder resource specific properties type AppServiceCertificateOrderProperties struct { Certificates *map[string]*AppServiceCertificate `json:"certificates,omitempty"` @@ -992,25 +1011,6 @@ type AppServiceCertificateOrderProperties struct { NextAutoRenewalTimeStamp *date.Time `json:"nextAutoRenewalTimeStamp,omitempty"` } -// AppServiceCertificateOrderCollection is collection of certitificate orders. -type AppServiceCertificateOrderCollection struct { - autorest.Response `json:"-"` - Value *[]AppServiceCertificateOrder `json:"value,omitempty"` - NextLink *string `json:"nextLink,omitempty"` -} - -// AppServiceCertificateOrderCollectionPreparer prepares a request to retrieve the next set of results. It returns -// nil if no more results exist. -func (client AppServiceCertificateOrderCollection) AppServiceCertificateOrderCollectionPreparer() (*http.Request, error) { - if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 { - return nil, nil - } - return autorest.Prepare(&http.Request{}, - autorest.AsJSON(), - autorest.AsGet(), - autorest.WithBaseURL(to.String(client.NextLink))) -} - // AppServiceCertificateResource is key Vault container ARM resource for a certificate that is purchased through Azure. type AppServiceCertificateResource struct { autorest.Response `json:"-"` @@ -1106,25 +1106,6 @@ type AppServicePlan struct { Sku *SkuDescription `json:"sku,omitempty"` } -// AppServicePlanProperties is appServicePlan resource specific properties -type AppServicePlanProperties struct { - Name *string `json:"name,omitempty"` - WorkerTierName *string `json:"workerTierName,omitempty"` - Status StatusOptions `json:"status,omitempty"` - Subscription *string `json:"subscription,omitempty"` - AdminSiteName *string `json:"adminSiteName,omitempty"` - HostingEnvironmentProfile *HostingEnvironmentProfile `json:"hostingEnvironmentProfile,omitempty"` - MaximumNumberOfWorkers *int32 `json:"maximumNumberOfWorkers,omitempty"` - GeoRegion *string `json:"geoRegion,omitempty"` - PerSiteScaling *bool `json:"perSiteScaling,omitempty"` - NumberOfSites *int32 `json:"numberOfSites,omitempty"` - ResourceGroup *string `json:"resourceGroup,omitempty"` - Reserved *bool `json:"reserved,omitempty"` - TargetWorkerCount *int32 `json:"targetWorkerCount,omitempty"` - TargetWorkerSizeID *int32 `json:"targetWorkerSizeId,omitempty"` - ProvisioningState ProvisioningState `json:"provisioningState,omitempty"` -} - // AppServicePlanCollection is collection of App Service plans. type AppServicePlanCollection struct { autorest.Response `json:"-"` @@ -1144,6 +1125,25 @@ func (client AppServicePlanCollection) AppServicePlanCollectionPreparer() (*http autorest.WithBaseURL(to.String(client.NextLink))) } +// AppServicePlanProperties is appServicePlan resource specific properties +type AppServicePlanProperties struct { + Name *string `json:"name,omitempty"` + WorkerTierName *string `json:"workerTierName,omitempty"` + Status StatusOptions `json:"status,omitempty"` + Subscription *string `json:"subscription,omitempty"` + AdminSiteName *string `json:"adminSiteName,omitempty"` + HostingEnvironmentProfile *HostingEnvironmentProfile `json:"hostingEnvironmentProfile,omitempty"` + MaximumNumberOfWorkers *int32 `json:"maximumNumberOfWorkers,omitempty"` + GeoRegion *string `json:"geoRegion,omitempty"` + PerSiteScaling *bool `json:"perSiteScaling,omitempty"` + NumberOfSites *int32 `json:"numberOfSites,omitempty"` + ResourceGroup *string `json:"resourceGroup,omitempty"` + Reserved *bool `json:"reserved,omitempty"` + TargetWorkerCount *int32 `json:"targetWorkerCount,omitempty"` + TargetWorkerSizeID *int32 `json:"targetWorkerSizeId,omitempty"` + ProvisioningState ProvisioningState `json:"provisioningState,omitempty"` +} + // AutoHealActions is actions which to take by the auto-heal module when a rule is triggered. type AutoHealActions struct { ActionType AutoHealActionType `json:"actionType,omitempty"` @@ -1202,24 +1202,6 @@ type BackupItem struct { *BackupItemProperties `json:"properties,omitempty"` } -// BackupItemProperties is backupItem resource specific properties -type BackupItemProperties struct { - BackupID *int32 `json:"id,omitempty"` - StorageAccountURL *string `json:"storageAccountUrl,omitempty"` - BlobName *string `json:"blobName,omitempty"` - Name *string `json:"name,omitempty"` - Status BackupItemStatus `json:"status,omitempty"` - SizeInBytes *int64 `json:"sizeInBytes,omitempty"` - Created *date.Time `json:"created,omitempty"` - Log *string `json:"log,omitempty"` - Databases *[]DatabaseBackupSetting `json:"databases,omitempty"` - Scheduled *bool `json:"scheduled,omitempty"` - LastRestoreTimeStamp *date.Time `json:"lastRestoreTimeStamp,omitempty"` - FinishedTimeStamp *date.Time `json:"finishedTimeStamp,omitempty"` - CorrelationID *string `json:"correlationId,omitempty"` - WebsiteSizeInBytes *int64 `json:"websiteSizeInBytes,omitempty"` -} - // BackupItemCollection is collection of backup items. type BackupItemCollection struct { autorest.Response `json:"-"` @@ -1239,6 +1221,24 @@ func (client BackupItemCollection) BackupItemCollectionPreparer() (*http.Request autorest.WithBaseURL(to.String(client.NextLink))) } +// BackupItemProperties is backupItem resource specific properties +type BackupItemProperties struct { + BackupID *int32 `json:"id,omitempty"` + StorageAccountURL *string `json:"storageAccountUrl,omitempty"` + BlobName *string `json:"blobName,omitempty"` + Name *string `json:"name,omitempty"` + Status BackupItemStatus `json:"status,omitempty"` + SizeInBytes *int64 `json:"sizeInBytes,omitempty"` + Created *date.Time `json:"created,omitempty"` + Log *string `json:"log,omitempty"` + Databases *[]DatabaseBackupSetting `json:"databases,omitempty"` + Scheduled *bool `json:"scheduled,omitempty"` + LastRestoreTimeStamp *date.Time `json:"lastRestoreTimeStamp,omitempty"` + FinishedTimeStamp *date.Time `json:"finishedTimeStamp,omitempty"` + CorrelationID *string `json:"correlationId,omitempty"` + WebsiteSizeInBytes *int64 `json:"websiteSizeInBytes,omitempty"` +} + // BackupRequest is description of a backup which will be performed. type BackupRequest struct { autorest.Response `json:"-"` @@ -1289,31 +1289,6 @@ type Certificate struct { *CertificateProperties `json:"properties,omitempty"` } -// CertificateProperties is certificate resource specific properties -type CertificateProperties struct { - FriendlyName *string `json:"friendlyName,omitempty"` - SubjectName *string `json:"subjectName,omitempty"` - HostNames *[]string `json:"hostNames,omitempty"` - PfxBlob *[]byte `json:"pfxBlob,omitempty"` - SiteName *string `json:"siteName,omitempty"` - SelfLink *string `json:"selfLink,omitempty"` - Issuer *string `json:"issuer,omitempty"` - IssueDate *date.Time `json:"issueDate,omitempty"` - ExpirationDate *date.Time `json:"expirationDate,omitempty"` - Password *string `json:"password,omitempty"` - Thumbprint *string `json:"thumbprint,omitempty"` - Valid *bool `json:"valid,omitempty"` - CerBlob *string `json:"cerBlob,omitempty"` - PublicKeyHash *string `json:"publicKeyHash,omitempty"` - HostingEnvironmentProfile *HostingEnvironmentProfile `json:"hostingEnvironmentProfile,omitempty"` - KeyVaultID *string `json:"keyVaultId,omitempty"` - KeyVaultSecretName *string `json:"keyVaultSecretName,omitempty"` - KeyVaultSecretStatus KeyVaultSecretStatus `json:"keyVaultSecretStatus,omitempty"` - GeoRegion *string `json:"geoRegion,omitempty"` - Name *string `json:"name,omitempty"` - ServerFarmID *string `json:"serverFarmId,omitempty"` -} - // CertificateCollection is collection of certificates. type CertificateCollection struct { autorest.Response `json:"-"` @@ -1378,6 +1353,31 @@ type CertificateOrderActionProperties struct { CreatedAt *date.Time `json:"createdAt,omitempty"` } +// CertificateProperties is certificate resource specific properties +type CertificateProperties struct { + FriendlyName *string `json:"friendlyName,omitempty"` + SubjectName *string `json:"subjectName,omitempty"` + HostNames *[]string `json:"hostNames,omitempty"` + PfxBlob *[]byte `json:"pfxBlob,omitempty"` + SiteName *string `json:"siteName,omitempty"` + SelfLink *string `json:"selfLink,omitempty"` + Issuer *string `json:"issuer,omitempty"` + IssueDate *date.Time `json:"issueDate,omitempty"` + ExpirationDate *date.Time `json:"expirationDate,omitempty"` + Password *string `json:"password,omitempty"` + Thumbprint *string `json:"thumbprint,omitempty"` + Valid *bool `json:"valid,omitempty"` + CerBlob *string `json:"cerBlob,omitempty"` + PublicKeyHash *string `json:"publicKeyHash,omitempty"` + HostingEnvironmentProfile *HostingEnvironmentProfile `json:"hostingEnvironmentProfile,omitempty"` + KeyVaultID *string `json:"keyVaultId,omitempty"` + KeyVaultSecretName *string `json:"keyVaultSecretName,omitempty"` + KeyVaultSecretStatus KeyVaultSecretStatus `json:"keyVaultSecretStatus,omitempty"` + GeoRegion *string `json:"geoRegion,omitempty"` + Name *string `json:"name,omitempty"` + ServerFarmID *string `json:"serverFarmId,omitempty"` +} + // CloningInfo is information needed for cloning operation. type CloningInfo struct { CorrelationID *string `json:"correlationId,omitempty"` @@ -1441,21 +1441,6 @@ type ContinuousWebJob struct { *ContinuousWebJobProperties `json:"properties,omitempty"` } -// ContinuousWebJobProperties is continuousWebJob resource specific properties -type ContinuousWebJobProperties struct { - Status ContinuousWebJobStatus `json:"status,omitempty"` - DetailedStatus *string `json:"detailedStatus,omitempty"` - LogURL *string `json:"logUrl,omitempty"` - Name *string `json:"name,omitempty"` - RunCommand *string `json:"runCommand,omitempty"` - URL *string `json:"url,omitempty"` - ExtraInfoURL *string `json:"extraInfoUrl,omitempty"` - JobType JobType `json:"jobType,omitempty"` - Error *string `json:"error,omitempty"` - UsingSdk *bool `json:"usingSdk,omitempty"` - Settings *map[string]interface{} `json:"settings,omitempty"` -} - // ContinuousWebJobCollection is collection of Kudu continuous web job information elements. type ContinuousWebJobCollection struct { autorest.Response `json:"-"` @@ -1475,6 +1460,21 @@ func (client ContinuousWebJobCollection) ContinuousWebJobCollectionPreparer() (* autorest.WithBaseURL(to.String(client.NextLink))) } +// ContinuousWebJobProperties is continuousWebJob resource specific properties +type ContinuousWebJobProperties struct { + Status ContinuousWebJobStatus `json:"status,omitempty"` + DetailedStatus *string `json:"detailedStatus,omitempty"` + LogURL *string `json:"logUrl,omitempty"` + Name *string `json:"name,omitempty"` + RunCommand *string `json:"runCommand,omitempty"` + URL *string `json:"url,omitempty"` + ExtraInfoURL *string `json:"extraInfoUrl,omitempty"` + JobType JobType `json:"jobType,omitempty"` + Error *string `json:"error,omitempty"` + UsingSdk *bool `json:"usingSdk,omitempty"` + Settings *map[string]interface{} `json:"settings,omitempty"` +} + // CorsSettings is cross-Origin Resource Sharing (CORS) settings for the app. type CorsSettings struct { AllowedOrigins *[]string `json:"allowedOrigins,omitempty"` @@ -1637,20 +1637,6 @@ type Deployment struct { *DeploymentProperties `json:"properties,omitempty"` } -// DeploymentProperties is deployment resource specific properties -type DeploymentProperties struct { - ID *string `json:"id,omitempty"` - Status *int32 `json:"status,omitempty"` - Message *string `json:"message,omitempty"` - Author *string `json:"author,omitempty"` - Deployer *string `json:"deployer,omitempty"` - AuthorEmail *string `json:"authorEmail,omitempty"` - StartTime *date.Time `json:"startTime,omitempty"` - EndTime *date.Time `json:"endTime,omitempty"` - Active *bool `json:"active,omitempty"` - Details *string `json:"details,omitempty"` -} - // DeploymentCollection is collection of app deployments. type DeploymentCollection struct { autorest.Response `json:"-"` @@ -1670,6 +1656,20 @@ func (client DeploymentCollection) DeploymentCollectionPreparer() (*http.Request autorest.WithBaseURL(to.String(client.NextLink))) } +// DeploymentProperties is deployment resource specific properties +type DeploymentProperties struct { + ID *string `json:"id,omitempty"` + Status *int32 `json:"status,omitempty"` + Message *string `json:"message,omitempty"` + Author *string `json:"author,omitempty"` + Deployer *string `json:"deployer,omitempty"` + AuthorEmail *string `json:"authorEmail,omitempty"` + StartTime *date.Time `json:"startTime,omitempty"` + EndTime *date.Time `json:"endTime,omitempty"` + Active *bool `json:"active,omitempty"` + Details *string `json:"details,omitempty"` +} + // Dimension is type Dimension struct { Name *string `json:"name,omitempty"` @@ -1690,30 +1690,6 @@ type Domain struct { *DomainProperties `json:"properties,omitempty"` } -// DomainProperties is domain resource specific properties -type DomainProperties struct { - ContactAdmin *Contact `json:"contactAdmin,omitempty"` - ContactBilling *Contact `json:"contactBilling,omitempty"` - ContactRegistrant *Contact `json:"contactRegistrant,omitempty"` - ContactTech *Contact `json:"contactTech,omitempty"` - RegistrationStatus DomainStatus `json:"registrationStatus,omitempty"` - ProvisioningState ProvisioningState `json:"provisioningState,omitempty"` - NameServers *[]string `json:"nameServers,omitempty"` - Privacy *bool `json:"privacy,omitempty"` - CreatedTime *date.Time `json:"createdTime,omitempty"` - ExpirationTime *date.Time `json:"expirationTime,omitempty"` - LastRenewedTime *date.Time `json:"lastRenewedTime,omitempty"` - AutoRenew *bool `json:"autoRenew,omitempty"` - ReadyForDNSRecordManagement *bool `json:"readyForDnsRecordManagement,omitempty"` - ManagedHostNames *[]HostName `json:"managedHostNames,omitempty"` - Consent *DomainPurchaseConsent `json:"consent,omitempty"` - DomainNotRenewableReasons *[]string `json:"domainNotRenewableReasons,omitempty"` - DNSType DNSType `json:"dnsType,omitempty"` - DNSZoneID *string `json:"dnsZoneId,omitempty"` - TargetDNSType DNSType `json:"targetDnsType,omitempty"` - AuthCode *string `json:"authCode,omitempty"` -} - // DomainAvailablilityCheckResult is domain availablility check result. type DomainAvailablilityCheckResult struct { autorest.Response `json:"-"` @@ -1761,11 +1737,6 @@ type DomainOwnershipIdentifier struct { *DomainOwnershipIdentifierProperties `json:"properties,omitempty"` } -// DomainOwnershipIdentifierProperties is domainOwnershipIdentifier resource specific properties -type DomainOwnershipIdentifierProperties struct { - OwnershipID *string `json:"ownershipId,omitempty"` -} - // DomainOwnershipIdentifierCollection is collection of domain ownership identifiers. type DomainOwnershipIdentifierCollection struct { autorest.Response `json:"-"` @@ -1785,6 +1756,35 @@ func (client DomainOwnershipIdentifierCollection) DomainOwnershipIdentifierColle autorest.WithBaseURL(to.String(client.NextLink))) } +// DomainOwnershipIdentifierProperties is domainOwnershipIdentifier resource specific properties +type DomainOwnershipIdentifierProperties struct { + OwnershipID *string `json:"ownershipId,omitempty"` +} + +// DomainProperties is domain resource specific properties +type DomainProperties struct { + ContactAdmin *Contact `json:"contactAdmin,omitempty"` + ContactBilling *Contact `json:"contactBilling,omitempty"` + ContactRegistrant *Contact `json:"contactRegistrant,omitempty"` + ContactTech *Contact `json:"contactTech,omitempty"` + RegistrationStatus DomainStatus `json:"registrationStatus,omitempty"` + ProvisioningState ProvisioningState `json:"provisioningState,omitempty"` + NameServers *[]string `json:"nameServers,omitempty"` + Privacy *bool `json:"privacy,omitempty"` + CreatedTime *date.Time `json:"createdTime,omitempty"` + ExpirationTime *date.Time `json:"expirationTime,omitempty"` + LastRenewedTime *date.Time `json:"lastRenewedTime,omitempty"` + AutoRenew *bool `json:"autoRenew,omitempty"` + ReadyForDNSRecordManagement *bool `json:"readyForDnsRecordManagement,omitempty"` + ManagedHostNames *[]HostName `json:"managedHostNames,omitempty"` + Consent *DomainPurchaseConsent `json:"consent,omitempty"` + DomainNotRenewableReasons *[]string `json:"domainNotRenewableReasons,omitempty"` + DNSType DNSType `json:"dnsType,omitempty"` + DNSZoneID *string `json:"dnsZoneId,omitempty"` + TargetDNSType DNSType `json:"targetDnsType,omitempty"` + AuthCode *string `json:"authCode,omitempty"` +} + // DomainPurchaseConsent is domain purchase consent object, representing acceptance of applicable legal agreements. type DomainPurchaseConsent struct { AgreementKeys *[]string `json:"agreementKeys,omitempty"` @@ -1840,20 +1840,6 @@ type FunctionEnvelope struct { *FunctionEnvelopeProperties `json:"properties,omitempty"` } -// FunctionEnvelopeProperties is functionEnvelope resource specific properties -type FunctionEnvelopeProperties struct { - Name *string `json:"name,omitempty"` - FunctionAppID *string `json:"functionAppId,omitempty"` - ScriptRootPathHref *string `json:"scriptRootPathHref,omitempty"` - ScriptHref *string `json:"scriptHref,omitempty"` - ConfigHref *string `json:"configHref,omitempty"` - SecretsFileHref *string `json:"secretsFileHref,omitempty"` - Href *string `json:"href,omitempty"` - Config *map[string]interface{} `json:"config,omitempty"` - Files *map[string]*string `json:"files,omitempty"` - TestData *string `json:"testData,omitempty"` -} - // FunctionEnvelopeCollection is collection of Kudu function information elements. type FunctionEnvelopeCollection struct { autorest.Response `json:"-"` @@ -1873,6 +1859,20 @@ func (client FunctionEnvelopeCollection) FunctionEnvelopeCollectionPreparer() (* autorest.WithBaseURL(to.String(client.NextLink))) } +// FunctionEnvelopeProperties is functionEnvelope resource specific properties +type FunctionEnvelopeProperties struct { + Name *string `json:"name,omitempty"` + FunctionAppID *string `json:"functionAppId,omitempty"` + ScriptRootPathHref *string `json:"scriptRootPathHref,omitempty"` + ScriptHref *string `json:"scriptHref,omitempty"` + ConfigHref *string `json:"configHref,omitempty"` + SecretsFileHref *string `json:"secretsFileHref,omitempty"` + Href *string `json:"href,omitempty"` + Config *map[string]interface{} `json:"config,omitempty"` + Files *map[string]*string `json:"files,omitempty"` + TestData *string `json:"testData,omitempty"` +} + // FunctionSecrets is function secrets. type FunctionSecrets struct { autorest.Response `json:"-"` @@ -1898,13 +1898,6 @@ type GeoRegion struct { *GeoRegionProperties `json:"properties,omitempty"` } -// GeoRegionProperties is geoRegion resource specific properties -type GeoRegionProperties struct { - Name *string `json:"name,omitempty"` - Description *string `json:"description,omitempty"` - DisplayName *string `json:"displayName,omitempty"` -} - // GeoRegionCollection is collection of geographical regions. type GeoRegionCollection struct { autorest.Response `json:"-"` @@ -1924,6 +1917,13 @@ func (client GeoRegionCollection) GeoRegionCollectionPreparer() (*http.Request, autorest.WithBaseURL(to.String(client.NextLink))) } +// GeoRegionProperties is geoRegion resource specific properties +type GeoRegionProperties struct { + Name *string `json:"name,omitempty"` + Description *string `json:"description,omitempty"` + DisplayName *string `json:"displayName,omitempty"` +} + // GlobalCsmSkuDescription is a Global SKU Description. type GlobalCsmSkuDescription struct { Name *string `json:"name,omitempty"` @@ -1976,20 +1976,6 @@ type HostNameBinding struct { *HostNameBindingProperties `json:"properties,omitempty"` } -// HostNameBindingProperties is hostNameBinding resource specific properties -type HostNameBindingProperties struct { - Name *string `json:"name,omitempty"` - SiteName *string `json:"siteName,omitempty"` - DomainID *string `json:"domainId,omitempty"` - AzureResourceName *string `json:"azureResourceName,omitempty"` - AzureResourceType AzureResourceType `json:"azureResourceType,omitempty"` - CustomHostNameDNSRecordType CustomHostNameDNSRecordType `json:"customHostNameDnsRecordType,omitempty"` - HostNameType HostNameType `json:"hostNameType,omitempty"` - SslState SslState `json:"sslState,omitempty"` - Thumbprint *string `json:"thumbprint,omitempty"` - VirtualIP *string `json:"virtualIP,omitempty"` -} - // HostNameBindingCollection is collection of hostname bindings. type HostNameBindingCollection struct { autorest.Response `json:"-"` @@ -2009,6 +1995,20 @@ func (client HostNameBindingCollection) HostNameBindingCollectionPreparer() (*ht autorest.WithBaseURL(to.String(client.NextLink))) } +// HostNameBindingProperties is hostNameBinding resource specific properties +type HostNameBindingProperties struct { + Name *string `json:"name,omitempty"` + SiteName *string `json:"siteName,omitempty"` + DomainID *string `json:"domainId,omitempty"` + AzureResourceName *string `json:"azureResourceName,omitempty"` + AzureResourceType AzureResourceType `json:"azureResourceType,omitempty"` + CustomHostNameDNSRecordType CustomHostNameDNSRecordType `json:"customHostNameDnsRecordType,omitempty"` + HostNameType HostNameType `json:"hostNameType,omitempty"` + SslState SslState `json:"sslState,omitempty"` + Thumbprint *string `json:"thumbprint,omitempty"` + VirtualIP *string `json:"virtualIP,omitempty"` +} + // HostNameSslState is SSL-enabled hostname. type HostNameSslState struct { Name *string `json:"name,omitempty"` @@ -2035,18 +2035,6 @@ type HybridConnection struct { *HybridConnectionProperties `json:"properties,omitempty"` } -// HybridConnectionProperties is hybridConnection resource specific properties -type HybridConnectionProperties struct { - ServiceBusNamespace *string `json:"serviceBusNamespace,omitempty"` - RelayName *string `json:"relayName,omitempty"` - RelayArmURI *string `json:"relayArmUri,omitempty"` - Hostname *string `json:"hostname,omitempty"` - Port *int32 `json:"port,omitempty"` - SendKeyName *string `json:"sendKeyName,omitempty"` - SendKeyValue *string `json:"sendKeyValue,omitempty"` - ServiceBusSuffix *string `json:"serviceBusSuffix,omitempty"` -} - // HybridConnectionCollection is collection of hostname bindings. type HybridConnectionCollection struct { autorest.Response `json:"-"` @@ -2099,6 +2087,18 @@ type HybridConnectionLimitsProperties struct { Maximum *int32 `json:"maximum,omitempty"` } +// HybridConnectionProperties is hybridConnection resource specific properties +type HybridConnectionProperties struct { + ServiceBusNamespace *string `json:"serviceBusNamespace,omitempty"` + RelayName *string `json:"relayName,omitempty"` + RelayArmURI *string `json:"relayArmUri,omitempty"` + Hostname *string `json:"hostname,omitempty"` + Port *int32 `json:"port,omitempty"` + SendKeyName *string `json:"sendKeyName,omitempty"` + SendKeyValue *string `json:"sendKeyValue,omitempty"` + ServiceBusSuffix *string `json:"serviceBusSuffix,omitempty"` +} + // Identifier is identifier. type Identifier struct { autorest.Response `json:"-"` @@ -2109,11 +2109,6 @@ type Identifier struct { *IdentifierProperties `json:"properties,omitempty"` } -// IdentifierProperties is identifier resource specific properties -type IdentifierProperties struct { - ID *string `json:"id,omitempty"` -} - // IdentifierCollection is collection of identifiers. type IdentifierCollection struct { autorest.Response `json:"-"` @@ -2133,6 +2128,11 @@ func (client IdentifierCollection) IdentifierCollectionPreparer() (*http.Request autorest.WithBaseURL(to.String(client.NextLink))) } +// IdentifierProperties is identifier resource specific properties +type IdentifierProperties struct { + ID *string `json:"id,omitempty"` +} + // IPSecurityRestriction is IP security restriction on an app. type IPSecurityRestriction struct { IPAddress *string `json:"ipAddress,omitempty"` @@ -2352,11 +2352,6 @@ type MSDeployLog struct { *MSDeployLogProperties `json:"properties,omitempty"` } -// MSDeployLogProperties is mSDeployLog resource specific properties -type MSDeployLogProperties struct { - Entries *[]MSDeployLogEntry `json:"entries,omitempty"` -} - // MSDeployLogEntry is mSDeploy log entry type MSDeployLogEntry struct { Time *date.Time `json:"time,omitempty"` @@ -2364,6 +2359,11 @@ type MSDeployLogEntry struct { Message *string `json:"message,omitempty"` } +// MSDeployLogProperties is mSDeployLog resource specific properties +type MSDeployLogProperties struct { + Entries *[]MSDeployLogEntry `json:"entries,omitempty"` +} + // MSDeployStatus is mSDeploy ARM response type MSDeployStatus struct { autorest.Response `json:"-"` @@ -2507,18 +2507,6 @@ type PremierAddOn struct { *PremierAddOnProperties `json:"properties,omitempty"` } -// PremierAddOnProperties is premierAddOn resource specific properties -type PremierAddOnProperties struct { - Sku *string `json:"sku,omitempty"` - Product *string `json:"product,omitempty"` - Vendor *string `json:"vendor,omitempty"` - PremierAddOnName *string `json:"name,omitempty"` - Location *string `json:"location,omitempty"` - Tags *map[string]*string `json:"tags,omitempty"` - MarketplacePublisher *string `json:"marketplacePublisher,omitempty"` - MarketplaceOffer *string `json:"marketplaceOffer,omitempty"` -} - // PremierAddOnOffer is premier add-on offer. type PremierAddOnOffer struct { ID *string `json:"id,omitempty"` @@ -2528,21 +2516,6 @@ type PremierAddOnOffer struct { *PremierAddOnOfferProperties `json:"properties,omitempty"` } -// PremierAddOnOfferProperties is premierAddOnOffer resource specific properties -type PremierAddOnOfferProperties struct { - Sku *string `json:"sku,omitempty"` - Product *string `json:"product,omitempty"` - Vendor *string `json:"vendor,omitempty"` - Name *string `json:"name,omitempty"` - PromoCodeRequired *bool `json:"promoCodeRequired,omitempty"` - Quota *int32 `json:"quota,omitempty"` - WebHostingPlanRestrictions AppServicePlanRestrictions `json:"webHostingPlanRestrictions,omitempty"` - PrivacyPolicyURL *string `json:"privacyPolicyUrl,omitempty"` - LegalTermsURL *string `json:"legalTermsUrl,omitempty"` - MarketplacePublisher *string `json:"marketplacePublisher,omitempty"` - MarketplaceOffer *string `json:"marketplaceOffer,omitempty"` -} - // PremierAddOnOfferCollection is collection of premier add-on offers. type PremierAddOnOfferCollection struct { autorest.Response `json:"-"` @@ -2562,6 +2535,33 @@ func (client PremierAddOnOfferCollection) PremierAddOnOfferCollectionPreparer() autorest.WithBaseURL(to.String(client.NextLink))) } +// PremierAddOnOfferProperties is premierAddOnOffer resource specific properties +type PremierAddOnOfferProperties struct { + Sku *string `json:"sku,omitempty"` + Product *string `json:"product,omitempty"` + Vendor *string `json:"vendor,omitempty"` + Name *string `json:"name,omitempty"` + PromoCodeRequired *bool `json:"promoCodeRequired,omitempty"` + Quota *int32 `json:"quota,omitempty"` + WebHostingPlanRestrictions AppServicePlanRestrictions `json:"webHostingPlanRestrictions,omitempty"` + PrivacyPolicyURL *string `json:"privacyPolicyUrl,omitempty"` + LegalTermsURL *string `json:"legalTermsUrl,omitempty"` + MarketplacePublisher *string `json:"marketplacePublisher,omitempty"` + MarketplaceOffer *string `json:"marketplaceOffer,omitempty"` +} + +// PremierAddOnProperties is premierAddOn resource specific properties +type PremierAddOnProperties struct { + Sku *string `json:"sku,omitempty"` + Product *string `json:"product,omitempty"` + Vendor *string `json:"vendor,omitempty"` + PremierAddOnName *string `json:"name,omitempty"` + Location *string `json:"location,omitempty"` + Tags *map[string]*string `json:"tags,omitempty"` + MarketplacePublisher *string `json:"marketplacePublisher,omitempty"` + MarketplaceOffer *string `json:"marketplaceOffer,omitempty"` +} + // ProcessInfo is process Information. type ProcessInfo struct { autorest.Response `json:"-"` @@ -2572,6 +2572,25 @@ type ProcessInfo struct { *ProcessInfoProperties `json:"properties,omitempty"` } +// ProcessInfoCollection is collection of Kudu process information elements. +type ProcessInfoCollection struct { + autorest.Response `json:"-"` + Value *[]ProcessInfo `json:"value,omitempty"` + NextLink *string `json:"nextLink,omitempty"` +} + +// ProcessInfoCollectionPreparer prepares a request to retrieve the next set of results. It returns +// nil if no more results exist. +func (client ProcessInfoCollection) ProcessInfoCollectionPreparer() (*http.Request, error) { + if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 { + return nil, nil + } + return autorest.Prepare(&http.Request{}, + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String(client.NextLink))) +} + // ProcessInfoProperties is processInfo resource specific properties type ProcessInfoProperties struct { ID *int32 `json:"id,omitempty"` @@ -2612,16 +2631,26 @@ type ProcessInfoProperties struct { Description *string `json:"description,omitempty"` } -// ProcessInfoCollection is collection of Kudu process information elements. -type ProcessInfoCollection struct { +// ProcessModuleInfo is process Module Information. +type ProcessModuleInfo struct { + autorest.Response `json:"-"` + ID *string `json:"id,omitempty"` + Name *string `json:"name,omitempty"` + Kind *string `json:"kind,omitempty"` + Type *string `json:"type,omitempty"` + *ProcessModuleInfoProperties `json:"properties,omitempty"` +} + +// ProcessModuleInfoCollection is collection of Kudu thread information elements. +type ProcessModuleInfoCollection struct { autorest.Response `json:"-"` - Value *[]ProcessInfo `json:"value,omitempty"` - NextLink *string `json:"nextLink,omitempty"` + Value *[]ProcessModuleInfo `json:"value,omitempty"` + NextLink *string `json:"nextLink,omitempty"` } -// ProcessInfoCollectionPreparer prepares a request to retrieve the next set of results. It returns +// ProcessModuleInfoCollectionPreparer prepares a request to retrieve the next set of results. It returns // nil if no more results exist. -func (client ProcessInfoCollection) ProcessInfoCollectionPreparer() (*http.Request, error) { +func (client ProcessModuleInfoCollection) ProcessModuleInfoCollectionPreparer() (*http.Request, error) { if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 { return nil, nil } @@ -2631,16 +2660,6 @@ func (client ProcessInfoCollection) ProcessInfoCollectionPreparer() (*http.Reque autorest.WithBaseURL(to.String(client.NextLink))) } -// ProcessModuleInfo is process Module Information. -type ProcessModuleInfo struct { - autorest.Response `json:"-"` - ID *string `json:"id,omitempty"` - Name *string `json:"name,omitempty"` - Kind *string `json:"kind,omitempty"` - Type *string `json:"type,omitempty"` - *ProcessModuleInfoProperties `json:"properties,omitempty"` -} - // ProcessModuleInfoProperties is processModuleInfo resource specific properties type ProcessModuleInfoProperties struct { BaseAddress *string `json:"baseAddress,omitempty"` @@ -2656,16 +2675,26 @@ type ProcessModuleInfoProperties struct { Language *string `json:"language,omitempty"` } -// ProcessModuleInfoCollection is collection of Kudu thread information elements. -type ProcessModuleInfoCollection struct { +// ProcessThreadInfo is process Thread Information. +type ProcessThreadInfo struct { + autorest.Response `json:"-"` + ID *string `json:"id,omitempty"` + Name *string `json:"name,omitempty"` + Kind *string `json:"kind,omitempty"` + Type *string `json:"type,omitempty"` + *ProcessThreadInfoProperties `json:"properties,omitempty"` +} + +// ProcessThreadInfoCollection is collection of Kudu thread information elements. +type ProcessThreadInfoCollection struct { autorest.Response `json:"-"` - Value *[]ProcessModuleInfo `json:"value,omitempty"` + Value *[]ProcessThreadInfo `json:"value,omitempty"` NextLink *string `json:"nextLink,omitempty"` } -// ProcessModuleInfoCollectionPreparer prepares a request to retrieve the next set of results. It returns +// ProcessThreadInfoCollectionPreparer prepares a request to retrieve the next set of results. It returns // nil if no more results exist. -func (client ProcessModuleInfoCollection) ProcessModuleInfoCollectionPreparer() (*http.Request, error) { +func (client ProcessThreadInfoCollection) ProcessThreadInfoCollectionPreparer() (*http.Request, error) { if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 { return nil, nil } @@ -2675,16 +2704,6 @@ func (client ProcessModuleInfoCollection) ProcessModuleInfoCollectionPreparer() autorest.WithBaseURL(to.String(client.NextLink))) } -// ProcessThreadInfo is process Thread Information. -type ProcessThreadInfo struct { - autorest.Response `json:"-"` - ID *string `json:"id,omitempty"` - Name *string `json:"name,omitempty"` - Kind *string `json:"kind,omitempty"` - Type *string `json:"type,omitempty"` - *ProcessThreadInfoProperties `json:"properties,omitempty"` -} - // ProcessThreadInfoProperties is processThreadInfo resource specific properties type ProcessThreadInfoProperties struct { ID *int32 `json:"id,omitempty"` @@ -2702,25 +2721,6 @@ type ProcessThreadInfoProperties struct { WaitReason *string `json:"waitReason,omitempty"` } -// ProcessThreadInfoCollection is collection of Kudu thread information elements. -type ProcessThreadInfoCollection struct { - autorest.Response `json:"-"` - Value *[]ProcessThreadInfo `json:"value,omitempty"` - NextLink *string `json:"nextLink,omitempty"` -} - -// ProcessThreadInfoCollectionPreparer prepares a request to retrieve the next set of results. It returns -// nil if no more results exist. -func (client ProcessThreadInfoCollection) ProcessThreadInfoCollectionPreparer() (*http.Request, error) { - if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 { - return nil, nil - } - return autorest.Prepare(&http.Request{}, - autorest.AsJSON(), - autorest.AsGet(), - autorest.WithBaseURL(to.String(client.NextLink))) -} - // ProxyOnlyResource is azure proxy only resource. This resource is not tracked by Azure Resource Manager. type ProxyOnlyResource struct { ID *string `json:"id,omitempty"` @@ -2739,13 +2739,6 @@ type PublicCertificate struct { *PublicCertificateProperties `json:"properties,omitempty"` } -// PublicCertificateProperties is publicCertificate resource specific properties -type PublicCertificateProperties struct { - Blob *string `json:"blob,omitempty"` - PublicCertificateLocation PublicCertificateLocation `json:"publicCertificateLocation,omitempty"` - Thumbprint *string `json:"thumbprint,omitempty"` -} - // PublicCertificateCollection is collection of public certificates type PublicCertificateCollection struct { autorest.Response `json:"-"` @@ -2765,6 +2758,13 @@ func (client PublicCertificateCollection) PublicCertificateCollectionPreparer() autorest.WithBaseURL(to.String(client.NextLink))) } +// PublicCertificateProperties is publicCertificate resource specific properties +type PublicCertificateProperties struct { + Blob *string `json:"blob,omitempty"` + PublicCertificateLocation PublicCertificateLocation `json:"publicCertificateLocation,omitempty"` + Thumbprint *string `json:"thumbprint,omitempty"` +} + // PushSettings is push settings for the App. type PushSettings struct { autorest.Response `json:"-"` @@ -2978,22 +2978,11 @@ func (client ResourceMetricCollection) ResourceMetricCollectionPreparer() (*http // ResourceMetricDefinition is metadata for the metrics. type ResourceMetricDefinition struct { - ID *string `json:"id,omitempty"` - Name *string `json:"name,omitempty"` - Kind *string `json:"kind,omitempty"` - Type *string `json:"type,omitempty"` - *ResourceMetricDefinitionProperties `json:"properties,omitempty"` -} - -// ResourceMetricDefinitionProperties is resourceMetricDefinition resource specific properties -type ResourceMetricDefinitionProperties struct { - Name *ResourceMetricName `json:"name,omitempty"` - Unit *string `json:"unit,omitempty"` - PrimaryAggregationType *string `json:"primaryAggregationType,omitempty"` - MetricAvailabilities *[]ResourceMetricAvailability `json:"metricAvailabilities,omitempty"` - ResourceURI *string `json:"resourceUri,omitempty"` - ID *string `json:"id,omitempty"` - Properties *map[string]*string `json:"properties,omitempty"` + ID *string `json:"id,omitempty"` + Name *string `json:"name,omitempty"` + Kind *string `json:"kind,omitempty"` + Type *string `json:"type,omitempty"` + *ResourceMetricDefinitionProperties `json:"properties,omitempty"` } // ResourceMetricDefinitionCollection is collection of metric definitions. @@ -3015,6 +3004,17 @@ func (client ResourceMetricDefinitionCollection) ResourceMetricDefinitionCollect autorest.WithBaseURL(to.String(client.NextLink))) } +// ResourceMetricDefinitionProperties is resourceMetricDefinition resource specific properties +type ResourceMetricDefinitionProperties struct { + Name *ResourceMetricName `json:"name,omitempty"` + Unit *string `json:"unit,omitempty"` + PrimaryAggregationType *string `json:"primaryAggregationType,omitempty"` + MetricAvailabilities *[]ResourceMetricAvailability `json:"metricAvailabilities,omitempty"` + ResourceURI *string `json:"resourceUri,omitempty"` + ID *string `json:"id,omitempty"` + Properties *map[string]*string `json:"properties,omitempty"` +} + // ResourceMetricName is name of a metric for any resource . type ResourceMetricName struct { Value *string `json:"value,omitempty"` @@ -3116,43 +3116,6 @@ type Site struct { *SiteProperties `json:"properties,omitempty"` } -// SiteProperties is site resource specific properties -type SiteProperties struct { - State *string `json:"state,omitempty"` - HostNames *[]string `json:"hostNames,omitempty"` - RepositorySiteName *string `json:"repositorySiteName,omitempty"` - UsageState UsageState `json:"usageState,omitempty"` - Enabled *bool `json:"enabled,omitempty"` - EnabledHostNames *[]string `json:"enabledHostNames,omitempty"` - AvailabilityState SiteAvailabilityState `json:"availabilityState,omitempty"` - HostNameSslStates *[]HostNameSslState `json:"hostNameSslStates,omitempty"` - ServerFarmID *string `json:"serverFarmId,omitempty"` - Reserved *bool `json:"reserved,omitempty"` - LastModifiedTimeUtc *date.Time `json:"lastModifiedTimeUtc,omitempty"` - SiteConfig *SiteConfig `json:"siteConfig,omitempty"` - TrafficManagerHostNames *[]string `json:"trafficManagerHostNames,omitempty"` - ScmSiteAlsoStopped *bool `json:"scmSiteAlsoStopped,omitempty"` - TargetSwapSlot *string `json:"targetSwapSlot,omitempty"` - HostingEnvironmentProfile *HostingEnvironmentProfile `json:"hostingEnvironmentProfile,omitempty"` - ClientAffinityEnabled *bool `json:"clientAffinityEnabled,omitempty"` - ClientCertEnabled *bool `json:"clientCertEnabled,omitempty"` - HostNamesDisabled *bool `json:"hostNamesDisabled,omitempty"` - OutboundIPAddresses *string `json:"outboundIpAddresses,omitempty"` - ContainerSize *int32 `json:"containerSize,omitempty"` - DailyMemoryTimeQuota *int32 `json:"dailyMemoryTimeQuota,omitempty"` - SuspendedTill *date.Time `json:"suspendedTill,omitempty"` - MaxNumberOfWorkers *int32 `json:"maxNumberOfWorkers,omitempty"` - CloningInfo *CloningInfo `json:"cloningInfo,omitempty"` - SnapshotInfo *SnapshotRecoveryRequest `json:"snapshotInfo,omitempty"` - ResourceGroup *string `json:"resourceGroup,omitempty"` - IsDefaultContainer *bool `json:"isDefaultContainer,omitempty"` - DefaultHostName *string `json:"defaultHostName,omitempty"` - SlotSwapStatus *SlotSwapStatus `json:"slotSwapStatus,omitempty"` - PremiumAppDeployed *bool `json:"premiumAppDeployed,omitempty"` - MicroService *string `json:"microService,omitempty"` - GatewaySiteName *string `json:"gatewaySiteName,omitempty"` -} - // SiteAuthSettings is configuration settings for the Azure App Service Authentication / Authorization feature. type SiteAuthSettings struct { autorest.Response `json:"-"` @@ -3306,6 +3269,25 @@ type SiteExtensionInfo struct { *SiteExtensionInfoProperties `json:"properties,omitempty"` } +// SiteExtensionInfoCollection is collection of Kudu site extension information elements. +type SiteExtensionInfoCollection struct { + autorest.Response `json:"-"` + Value *[]SiteExtensionInfo `json:"value,omitempty"` + NextLink *string `json:"nextLink,omitempty"` +} + +// SiteExtensionInfoCollectionPreparer prepares a request to retrieve the next set of results. It returns +// nil if no more results exist. +func (client SiteExtensionInfoCollection) SiteExtensionInfoCollectionPreparer() (*http.Request, error) { + if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 { + return nil, nil + } + return autorest.Prepare(&http.Request{}, + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String(client.NextLink))) +} + // SiteExtensionInfoProperties is siteExtensionInfo resource specific properties type SiteExtensionInfoProperties struct { ID *string `json:"id,omitempty"` @@ -3330,25 +3312,6 @@ type SiteExtensionInfoProperties struct { Comment *string `json:"comment,omitempty"` } -// SiteExtensionInfoCollection is collection of Kudu site extension information elements. -type SiteExtensionInfoCollection struct { - autorest.Response `json:"-"` - Value *[]SiteExtensionInfo `json:"value,omitempty"` - NextLink *string `json:"nextLink,omitempty"` -} - -// SiteExtensionInfoCollectionPreparer prepares a request to retrieve the next set of results. It returns -// nil if no more results exist. -func (client SiteExtensionInfoCollection) SiteExtensionInfoCollectionPreparer() (*http.Request, error) { - if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 { - return nil, nil - } - return autorest.Prepare(&http.Request{}, - autorest.AsJSON(), - autorest.AsGet(), - autorest.WithBaseURL(to.String(client.NextLink))) -} - // SiteInstance is instance of an app. type SiteInstance struct { ID *string `json:"id,omitempty"` @@ -3414,6 +3377,43 @@ type SitePhpErrorLogFlagProperties struct { MasterLogErrorsMaxLength *string `json:"masterLogErrorsMaxLength,omitempty"` } +// SiteProperties is site resource specific properties +type SiteProperties struct { + State *string `json:"state,omitempty"` + HostNames *[]string `json:"hostNames,omitempty"` + RepositorySiteName *string `json:"repositorySiteName,omitempty"` + UsageState UsageState `json:"usageState,omitempty"` + Enabled *bool `json:"enabled,omitempty"` + EnabledHostNames *[]string `json:"enabledHostNames,omitempty"` + AvailabilityState SiteAvailabilityState `json:"availabilityState,omitempty"` + HostNameSslStates *[]HostNameSslState `json:"hostNameSslStates,omitempty"` + ServerFarmID *string `json:"serverFarmId,omitempty"` + Reserved *bool `json:"reserved,omitempty"` + LastModifiedTimeUtc *date.Time `json:"lastModifiedTimeUtc,omitempty"` + SiteConfig *SiteConfig `json:"siteConfig,omitempty"` + TrafficManagerHostNames *[]string `json:"trafficManagerHostNames,omitempty"` + ScmSiteAlsoStopped *bool `json:"scmSiteAlsoStopped,omitempty"` + TargetSwapSlot *string `json:"targetSwapSlot,omitempty"` + HostingEnvironmentProfile *HostingEnvironmentProfile `json:"hostingEnvironmentProfile,omitempty"` + ClientAffinityEnabled *bool `json:"clientAffinityEnabled,omitempty"` + ClientCertEnabled *bool `json:"clientCertEnabled,omitempty"` + HostNamesDisabled *bool `json:"hostNamesDisabled,omitempty"` + OutboundIPAddresses *string `json:"outboundIpAddresses,omitempty"` + ContainerSize *int32 `json:"containerSize,omitempty"` + DailyMemoryTimeQuota *int32 `json:"dailyMemoryTimeQuota,omitempty"` + SuspendedTill *date.Time `json:"suspendedTill,omitempty"` + MaxNumberOfWorkers *int32 `json:"maxNumberOfWorkers,omitempty"` + CloningInfo *CloningInfo `json:"cloningInfo,omitempty"` + SnapshotInfo *SnapshotRecoveryRequest `json:"snapshotInfo,omitempty"` + ResourceGroup *string `json:"resourceGroup,omitempty"` + IsDefaultContainer *bool `json:"isDefaultContainer,omitempty"` + DefaultHostName *string `json:"defaultHostName,omitempty"` + SlotSwapStatus *SlotSwapStatus `json:"slotSwapStatus,omitempty"` + PremiumAppDeployed *bool `json:"premiumAppDeployed,omitempty"` + MicroService *string `json:"microService,omitempty"` + GatewaySiteName *string `json:"gatewaySiteName,omitempty"` +} + // SiteSeal is site seal type SiteSeal struct { autorest.Response `json:"-"` @@ -3525,17 +3525,6 @@ type SlotDifference struct { *SlotDifferenceProperties `json:"properties,omitempty"` } -// SlotDifferenceProperties is slotDifference resource specific properties -type SlotDifferenceProperties struct { - Type *string `json:"type,omitempty"` - SettingType *string `json:"settingType,omitempty"` - DiffRule *string `json:"diffRule,omitempty"` - SettingName *string `json:"settingName,omitempty"` - ValueInCurrentSlot *string `json:"valueInCurrentSlot,omitempty"` - ValueInTargetSlot *string `json:"valueInTargetSlot,omitempty"` - Description *string `json:"description,omitempty"` -} - // SlotDifferenceCollection is collection of slot differences. type SlotDifferenceCollection struct { autorest.Response `json:"-"` @@ -3555,6 +3544,17 @@ func (client SlotDifferenceCollection) SlotDifferenceCollectionPreparer() (*http autorest.WithBaseURL(to.String(client.NextLink))) } +// SlotDifferenceProperties is slotDifference resource specific properties +type SlotDifferenceProperties struct { + Type *string `json:"type,omitempty"` + SettingType *string `json:"settingType,omitempty"` + DiffRule *string `json:"diffRule,omitempty"` + SettingName *string `json:"settingName,omitempty"` + ValueInCurrentSlot *string `json:"valueInCurrentSlot,omitempty"` + ValueInTargetSlot *string `json:"valueInTargetSlot,omitempty"` + Description *string `json:"description,omitempty"` +} + // SlotSwapStatus is the status of the last successfull slot swap operation. type SlotSwapStatus struct { TimestampUtc *date.Time `json:"timestampUtc,omitempty"` @@ -3578,11 +3578,6 @@ type Snapshot struct { *SnapshotProperties `json:"properties,omitempty"` } -// SnapshotProperties is snapshot resource specific properties -type SnapshotProperties struct { - Time *string `json:"time,omitempty"` -} - // SnapshotCollection is collection of snapshots which can be used to revert an app to a previous time. type SnapshotCollection struct { autorest.Response `json:"-"` @@ -3602,6 +3597,11 @@ func (client SnapshotCollection) SnapshotCollectionPreparer() (*http.Request, er autorest.WithBaseURL(to.String(client.NextLink))) } +// SnapshotProperties is snapshot resource specific properties +type SnapshotProperties struct { + Time *string `json:"time,omitempty"` +} + // SnapshotRecoveryRequest is details about app recovery operation. type SnapshotRecoveryRequest struct { ID *string `json:"id,omitempty"` @@ -3636,15 +3636,6 @@ type SourceControl struct { *SourceControlProperties `json:"properties,omitempty"` } -// SourceControlProperties is sourceControl resource specific properties -type SourceControlProperties struct { - Name *string `json:"name,omitempty"` - Token *string `json:"token,omitempty"` - TokenSecret *string `json:"tokenSecret,omitempty"` - RefreshToken *string `json:"refreshToken,omitempty"` - ExpirationTime *date.Time `json:"expirationTime,omitempty"` -} - // SourceControlCollection is collection of source controls. type SourceControlCollection struct { autorest.Response `json:"-"` @@ -3664,6 +3655,15 @@ func (client SourceControlCollection) SourceControlCollectionPreparer() (*http.R autorest.WithBaseURL(to.String(client.NextLink))) } +// SourceControlProperties is sourceControl resource specific properties +type SourceControlProperties struct { + Name *string `json:"name,omitempty"` + Token *string `json:"token,omitempty"` + TokenSecret *string `json:"tokenSecret,omitempty"` + RefreshToken *string `json:"refreshToken,omitempty"` + ExpirationTime *date.Time `json:"expirationTime,omitempty"` +} + // StampCapacity is stamp capacity information. type StampCapacity struct { Name *string `json:"name,omitempty"` @@ -3791,12 +3791,6 @@ type TopLevelDomain struct { *TopLevelDomainProperties `json:"properties,omitempty"` } -// TopLevelDomainProperties is topLevelDomain resource specific properties -type TopLevelDomainProperties struct { - DomainName *string `json:"name,omitempty"` - Privacy *bool `json:"privacy,omitempty"` -} - // TopLevelDomainAgreementOption is options for retrieving the list of top level domain legal agreements. type TopLevelDomainAgreementOption struct { IncludePrivacy *bool `json:"includePrivacy,omitempty"` @@ -3822,6 +3816,12 @@ func (client TopLevelDomainCollection) TopLevelDomainCollectionPreparer() (*http autorest.WithBaseURL(to.String(client.NextLink))) } +// TopLevelDomainProperties is topLevelDomain resource specific properties +type TopLevelDomainProperties struct { + DomainName *string `json:"name,omitempty"` + Privacy *bool `json:"privacy,omitempty"` +} + // TriggeredJobHistory is triggered Web Job History. List of Triggered Web Job Run Information elements. type TriggeredJobHistory struct { autorest.Response `json:"-"` @@ -3832,11 +3832,6 @@ type TriggeredJobHistory struct { *TriggeredJobHistoryProperties `json:"properties,omitempty"` } -// TriggeredJobHistoryProperties is triggeredJobHistory resource specific properties -type TriggeredJobHistoryProperties struct { - TriggeredJobRuns *[]TriggeredJobRun `json:"triggeredJobRuns,omitempty"` -} - // TriggeredJobHistoryCollection is collection of Kudu continuous web job information elements. type TriggeredJobHistoryCollection struct { autorest.Response `json:"-"` @@ -3856,6 +3851,11 @@ func (client TriggeredJobHistoryCollection) TriggeredJobHistoryCollectionPrepare autorest.WithBaseURL(to.String(client.NextLink))) } +// TriggeredJobHistoryProperties is triggeredJobHistory resource specific properties +type TriggeredJobHistoryProperties struct { + TriggeredJobRuns *[]TriggeredJobRun `json:"triggeredJobRuns,omitempty"` +} + // TriggeredJobRun is triggered Web Job Run Information. type TriggeredJobRun struct { ID *string `json:"id,omitempty"` @@ -3890,21 +3890,6 @@ type TriggeredWebJob struct { *TriggeredWebJobProperties `json:"properties,omitempty"` } -// TriggeredWebJobProperties is triggeredWebJob resource specific properties -type TriggeredWebJobProperties struct { - LatestRun *TriggeredJobRun `json:"latestRun,omitempty"` - HistoryURL *string `json:"historyUrl,omitempty"` - SchedulerLogsURL *string `json:"schedulerLogsUrl,omitempty"` - Name *string `json:"name,omitempty"` - RunCommand *string `json:"runCommand,omitempty"` - URL *string `json:"url,omitempty"` - ExtraInfoURL *string `json:"extraInfoUrl,omitempty"` - JobType JobType `json:"jobType,omitempty"` - Error *string `json:"error,omitempty"` - UsingSdk *bool `json:"usingSdk,omitempty"` - Settings *map[string]interface{} `json:"settings,omitempty"` -} - // TriggeredWebJobCollection is collection of Kudu continuous web job information elements. type TriggeredWebJobCollection struct { autorest.Response `json:"-"` @@ -3924,6 +3909,21 @@ func (client TriggeredWebJobCollection) TriggeredWebJobCollectionPreparer() (*ht autorest.WithBaseURL(to.String(client.NextLink))) } +// TriggeredWebJobProperties is triggeredWebJob resource specific properties +type TriggeredWebJobProperties struct { + LatestRun *TriggeredJobRun `json:"latestRun,omitempty"` + HistoryURL *string `json:"historyUrl,omitempty"` + SchedulerLogsURL *string `json:"schedulerLogsUrl,omitempty"` + Name *string `json:"name,omitempty"` + RunCommand *string `json:"runCommand,omitempty"` + URL *string `json:"url,omitempty"` + ExtraInfoURL *string `json:"extraInfoUrl,omitempty"` + JobType JobType `json:"jobType,omitempty"` + Error *string `json:"error,omitempty"` + UsingSdk *bool `json:"usingSdk,omitempty"` + Settings *map[string]interface{} `json:"settings,omitempty"` +} + // Usage is usage of the quota resource. type Usage struct { ID *string `json:"id,omitempty"` @@ -3933,19 +3933,6 @@ type Usage struct { *UsageProperties `json:"properties,omitempty"` } -// UsageProperties is usage resource specific properties -type UsageProperties struct { - DisplayName *string `json:"displayName,omitempty"` - Name *string `json:"name,omitempty"` - ResourceName *string `json:"resourceName,omitempty"` - Unit *string `json:"unit,omitempty"` - CurrentValue *int64 `json:"currentValue,omitempty"` - Limit *int64 `json:"limit,omitempty"` - NextResetTime *date.Time `json:"nextResetTime,omitempty"` - ComputeMode ComputeModeOptions `json:"computeMode,omitempty"` - SiteMode *string `json:"siteMode,omitempty"` -} - // UsageCollection is collection of usages. type UsageCollection struct { autorest.Response `json:"-"` @@ -3965,6 +3952,19 @@ func (client UsageCollection) UsageCollectionPreparer() (*http.Request, error) { autorest.WithBaseURL(to.String(client.NextLink))) } +// UsageProperties is usage resource specific properties +type UsageProperties struct { + DisplayName *string `json:"displayName,omitempty"` + Name *string `json:"name,omitempty"` + ResourceName *string `json:"resourceName,omitempty"` + Unit *string `json:"unit,omitempty"` + CurrentValue *int64 `json:"currentValue,omitempty"` + Limit *int64 `json:"limit,omitempty"` + NextResetTime *date.Time `json:"nextResetTime,omitempty"` + ComputeMode ComputeModeOptions `json:"computeMode,omitempty"` + SiteMode *string `json:"siteMode,omitempty"` +} + // User is user crendentials used for publishing activity. type User struct { autorest.Response `json:"-"` diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/provider.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/provider.go index 67d9cb58a98f..d3325d651d88 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/provider.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/provider.go @@ -79,7 +79,9 @@ func (client ProviderClient) GetAvailableStacksPreparer() (*http.Request, error) // GetAvailableStacksSender sends the GetAvailableStacks request. The method will close the // http.Response Body if it receives an error. func (client ProviderClient) GetAvailableStacksSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetAvailableStacksResponder handles the response to the GetAvailableStacks request. The method always @@ -140,7 +142,9 @@ func (client ProviderClient) GetAvailableStacksOnPremPreparer() (*http.Request, // GetAvailableStacksOnPremSender sends the GetAvailableStacksOnPrem request. The method will close the // http.Response Body if it receives an error. func (client ProviderClient) GetAvailableStacksOnPremSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetAvailableStacksOnPremResponder handles the response to the GetAvailableStacksOnPrem request. The method always @@ -197,7 +201,9 @@ func (client ProviderClient) ListOperationsPreparer() (*http.Request, error) { // ListOperationsSender sends the ListOperations request. The method will close the // http.Response Body if it receives an error. func (client ProviderClient) ListOperationsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ListOperationsResponder handles the response to the ListOperations request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/recommendations.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/recommendations.go index 33e579ddd47a..1fe5b0273706 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/recommendations.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/recommendations.go @@ -96,7 +96,9 @@ func (client RecommendationsClient) DisableAllForWebAppPreparer(resourceGroupNam // DisableAllForWebAppSender sends the DisableAllForWebApp request. The method will close the // http.Response Body if it receives an error. func (client RecommendationsClient) DisableAllForWebAppSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // DisableAllForWebAppResponder handles the response to the DisableAllForWebApp request. The method always @@ -174,7 +176,9 @@ func (client RecommendationsClient) GetRuleDetailsByWebAppPreparer(resourceGroup // GetRuleDetailsByWebAppSender sends the GetRuleDetailsByWebApp request. The method will close the // http.Response Body if it receives an error. func (client RecommendationsClient) GetRuleDetailsByWebAppSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetRuleDetailsByWebAppResponder handles the response to the GetRuleDetailsByWebApp request. The method always @@ -246,7 +250,9 @@ func (client RecommendationsClient) ListPreparer(featured *bool, filter string) // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client RecommendationsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -324,7 +330,9 @@ func (client RecommendationsClient) ListHistoryForWebAppPreparer(resourceGroupNa // ListHistoryForWebAppSender sends the ListHistoryForWebApp request. The method will close the // http.Response Body if it receives an error. func (client RecommendationsClient) ListHistoryForWebAppSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListHistoryForWebAppResponder handles the response to the ListHistoryForWebApp request. The method always @@ -406,7 +414,9 @@ func (client RecommendationsClient) ListRecommendedRulesForWebAppPreparer(resour // ListRecommendedRulesForWebAppSender sends the ListRecommendedRulesForWebApp request. The method will close the // http.Response Body if it receives an error. func (client RecommendationsClient) ListRecommendedRulesForWebAppSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListRecommendedRulesForWebAppResponder handles the response to the ListRecommendedRulesForWebApp request. The method always @@ -467,7 +477,9 @@ func (client RecommendationsClient) ResetAllFiltersPreparer() (*http.Request, er // ResetAllFiltersSender sends the ResetAllFilters request. The method will close the // http.Response Body if it receives an error. func (client RecommendationsClient) ResetAllFiltersSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ResetAllFiltersResponder handles the response to the ResetAllFilters request. The method always @@ -539,7 +551,9 @@ func (client RecommendationsClient) ResetAllFiltersForWebAppPreparer(resourceGro // ResetAllFiltersForWebAppSender sends the ResetAllFiltersForWebApp request. The method will close the // http.Response Body if it receives an error. func (client RecommendationsClient) ResetAllFiltersForWebAppSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ResetAllFiltersForWebAppResponder handles the response to the ResetAllFiltersForWebApp request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/topleveldomains.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/topleveldomains.go index 90961ad252cd..3f910078b20b 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/topleveldomains.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/topleveldomains.go @@ -86,7 +86,9 @@ func (client TopLevelDomainsClient) GetPreparer(name string) (*http.Request, err // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client TopLevelDomainsClient) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always @@ -147,7 +149,9 @@ func (client TopLevelDomainsClient) ListPreparer() (*http.Request, error) { // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client TopLevelDomainsClient) ListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always @@ -282,7 +286,9 @@ func (client TopLevelDomainsClient) ListAgreementsPreparer(name string, agreemen // ListAgreementsSender sends the ListAgreements request. The method will close the // http.Response Body if it receives an error. func (client TopLevelDomainsClient) ListAgreementsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + azure.DoRetryWithRegistration(client.Client)) } // ListAgreementsResponder handles the response to the ListAgreements request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/version.go index 664c735561a4..ad2b088d2c1c 100755 --- a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/version.go @@ -19,10 +19,10 @@ package web // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-web/" + return "Azure-SDK-For-Go/v11.1.1-beta arm-web/" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/dataplane/keyvault/client.go b/vendor/github.com/Azure/azure-sdk-for-go/dataplane/keyvault/client.go index 00eafa0742fd..27b398c9efbf 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/dataplane/keyvault/client.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/dataplane/keyvault/client.go @@ -105,7 +105,9 @@ func (client ManagementClient) BackupKeyPreparer(vaultBaseURL string, keyName st // BackupKeySender sends the BackupKey request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) BackupKeySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // BackupKeyResponder handles the response to the BackupKey request. The method always @@ -173,7 +175,9 @@ func (client ManagementClient) BackupSecretPreparer(vaultBaseURL string, secretN // BackupSecretSender sends the BackupSecret request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) BackupSecretSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // BackupSecretResponder handles the response to the BackupSecret request. The method always @@ -256,7 +260,9 @@ func (client ManagementClient) CreateCertificatePreparer(vaultBaseURL string, ce // CreateCertificateSender sends the CreateCertificate request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) CreateCertificateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // CreateCertificateResponder handles the response to the CreateCertificate request. The method always @@ -333,7 +339,9 @@ func (client ManagementClient) CreateKeyPreparer(vaultBaseURL string, keyName st // CreateKeySender sends the CreateKey request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) CreateKeySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // CreateKeyResponder handles the response to the CreateKey request. The method always @@ -413,7 +421,9 @@ func (client ManagementClient) DecryptPreparer(vaultBaseURL string, keyName stri // DecryptSender sends the Decrypt request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) DecryptSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // DecryptResponder handles the response to the Decrypt request. The method always @@ -482,7 +492,9 @@ func (client ManagementClient) DeleteCertificatePreparer(vaultBaseURL string, ce // DeleteCertificateSender sends the DeleteCertificate request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) DeleteCertificateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // DeleteCertificateResponder handles the response to the DeleteCertificate request. The method always @@ -546,7 +558,9 @@ func (client ManagementClient) DeleteCertificateContactsPreparer(vaultBaseURL st // DeleteCertificateContactsSender sends the DeleteCertificateContacts request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) DeleteCertificateContactsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // DeleteCertificateContactsResponder handles the response to the DeleteCertificateContacts request. The method always @@ -614,7 +628,9 @@ func (client ManagementClient) DeleteCertificateIssuerPreparer(vaultBaseURL stri // DeleteCertificateIssuerSender sends the DeleteCertificateIssuer request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) DeleteCertificateIssuerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // DeleteCertificateIssuerResponder handles the response to the DeleteCertificateIssuer request. The method always @@ -683,7 +699,9 @@ func (client ManagementClient) DeleteCertificateOperationPreparer(vaultBaseURL s // DeleteCertificateOperationSender sends the DeleteCertificateOperation request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) DeleteCertificateOperationSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // DeleteCertificateOperationResponder handles the response to the DeleteCertificateOperation request. The method always @@ -753,7 +771,9 @@ func (client ManagementClient) DeleteKeyPreparer(vaultBaseURL string, keyName st // DeleteKeySender sends the DeleteKey request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) DeleteKeySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // DeleteKeyResponder handles the response to the DeleteKey request. The method always @@ -830,7 +850,9 @@ func (client ManagementClient) DeleteSasDefinitionPreparer(vaultBaseURL string, // DeleteSasDefinitionSender sends the DeleteSasDefinition request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) DeleteSasDefinitionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // DeleteSasDefinitionResponder handles the response to the DeleteSasDefinition request. The method always @@ -898,7 +920,9 @@ func (client ManagementClient) DeleteSecretPreparer(vaultBaseURL string, secretN // DeleteSecretSender sends the DeleteSecret request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) DeleteSecretSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // DeleteSecretResponder handles the response to the DeleteSecret request. The method always @@ -972,7 +996,9 @@ func (client ManagementClient) DeleteStorageAccountPreparer(vaultBaseURL string, // DeleteStorageAccountSender sends the DeleteStorageAccount request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) DeleteStorageAccountSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // DeleteStorageAccountResponder handles the response to the DeleteStorageAccount request. The method always @@ -1054,7 +1080,9 @@ func (client ManagementClient) EncryptPreparer(vaultBaseURL string, keyName stri // EncryptSender sends the Encrypt request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) EncryptSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // EncryptResponder handles the response to the Encrypt request. The method always @@ -1124,7 +1152,9 @@ func (client ManagementClient) GetCertificatePreparer(vaultBaseURL string, certi // GetCertificateSender sends the GetCertificate request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetCertificateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetCertificateResponder handles the response to the GetCertificate request. The method always @@ -1188,7 +1218,9 @@ func (client ManagementClient) GetCertificateContactsPreparer(vaultBaseURL strin // GetCertificateContactsSender sends the GetCertificateContacts request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetCertificateContactsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetCertificateContactsResponder handles the response to the GetCertificateContacts request. The method always @@ -1256,7 +1288,9 @@ func (client ManagementClient) GetCertificateIssuerPreparer(vaultBaseURL string, // GetCertificateIssuerSender sends the GetCertificateIssuer request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetCertificateIssuerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetCertificateIssuerResponder handles the response to the GetCertificateIssuer request. The method always @@ -1333,7 +1367,9 @@ func (client ManagementClient) GetCertificateIssuersPreparer(vaultBaseURL string // GetCertificateIssuersSender sends the GetCertificateIssuers request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetCertificateIssuersSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetCertificateIssuersResponder handles the response to the GetCertificateIssuers request. The method always @@ -1471,7 +1507,9 @@ func (client ManagementClient) GetCertificateOperationPreparer(vaultBaseURL stri // GetCertificateOperationSender sends the GetCertificateOperation request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetCertificateOperationSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetCertificateOperationResponder handles the response to the GetCertificateOperation request. The method always @@ -1540,7 +1578,9 @@ func (client ManagementClient) GetCertificatePolicyPreparer(vaultBaseURL string, // GetCertificatePolicySender sends the GetCertificatePolicy request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetCertificatePolicySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetCertificatePolicyResponder handles the response to the GetCertificatePolicy request. The method always @@ -1616,7 +1656,9 @@ func (client ManagementClient) GetCertificatesPreparer(vaultBaseURL string, maxr // GetCertificatesSender sends the GetCertificates request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetCertificatesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetCertificatesResponder handles the response to the GetCertificates request. The method always @@ -1767,7 +1809,9 @@ func (client ManagementClient) GetCertificateVersionsPreparer(vaultBaseURL strin // GetCertificateVersionsSender sends the GetCertificateVersions request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetCertificateVersionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetCertificateVersionsResponder handles the response to the GetCertificateVersions request. The method always @@ -1905,7 +1949,9 @@ func (client ManagementClient) GetDeletedCertificatePreparer(vaultBaseURL string // GetDeletedCertificateSender sends the GetDeletedCertificate request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetDeletedCertificateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetDeletedCertificateResponder handles the response to the GetDeletedCertificate request. The method always @@ -1982,7 +2028,9 @@ func (client ManagementClient) GetDeletedCertificatesPreparer(vaultBaseURL strin // GetDeletedCertificatesSender sends the GetDeletedCertificates request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetDeletedCertificatesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetDeletedCertificatesResponder handles the response to the GetDeletedCertificates request. The method always @@ -2119,7 +2167,9 @@ func (client ManagementClient) GetDeletedKeyPreparer(vaultBaseURL string, keyNam // GetDeletedKeySender sends the GetDeletedKey request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetDeletedKeySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetDeletedKeyResponder handles the response to the GetDeletedKey request. The method always @@ -2195,7 +2245,9 @@ func (client ManagementClient) GetDeletedKeysPreparer(vaultBaseURL string, maxre // GetDeletedKeysSender sends the GetDeletedKeys request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetDeletedKeysSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetDeletedKeysResponder handles the response to the GetDeletedKeys request. The method always @@ -2332,7 +2384,9 @@ func (client ManagementClient) GetDeletedSecretPreparer(vaultBaseURL string, sec // GetDeletedSecretSender sends the GetDeletedSecret request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetDeletedSecretSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetDeletedSecretResponder handles the response to the GetDeletedSecret request. The method always @@ -2408,7 +2462,9 @@ func (client ManagementClient) GetDeletedSecretsPreparer(vaultBaseURL string, ma // GetDeletedSecretsSender sends the GetDeletedSecrets request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetDeletedSecretsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetDeletedSecretsResponder handles the response to the GetDeletedSecrets request. The method always @@ -2547,7 +2603,9 @@ func (client ManagementClient) GetKeyPreparer(vaultBaseURL string, keyName strin // GetKeySender sends the GetKey request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetKeySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetKeyResponder handles the response to the GetKey request. The method always @@ -2626,7 +2684,9 @@ func (client ManagementClient) GetKeysPreparer(vaultBaseURL string, maxresults * // GetKeysSender sends the GetKeys request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetKeysSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetKeysResponder handles the response to the GetKeys request. The method always @@ -2776,7 +2836,9 @@ func (client ManagementClient) GetKeyVersionsPreparer(vaultBaseURL string, keyNa // GetKeyVersionsSender sends the GetKeyVersions request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetKeyVersionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetKeyVersionsResponder handles the response to the GetKeyVersions request. The method always @@ -2922,7 +2984,9 @@ func (client ManagementClient) GetSasDefinitionPreparer(vaultBaseURL string, sto // GetSasDefinitionSender sends the GetSasDefinition request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetSasDefinitionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetSasDefinitionResponder handles the response to the GetSasDefinition request. The method always @@ -3005,7 +3069,9 @@ func (client ManagementClient) GetSasDefinitionsPreparer(vaultBaseURL string, st // GetSasDefinitionsSender sends the GetSasDefinitions request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetSasDefinitionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetSasDefinitionsResponder handles the response to the GetSasDefinitions request. The method always @@ -3143,7 +3209,9 @@ func (client ManagementClient) GetSecretPreparer(vaultBaseURL string, secretName // GetSecretSender sends the GetSecret request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetSecretSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetSecretResponder handles the response to the GetSecret request. The method always @@ -3220,7 +3288,9 @@ func (client ManagementClient) GetSecretsPreparer(vaultBaseURL string, maxresult // GetSecretsSender sends the GetSecrets request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetSecretsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetSecretsResponder handles the response to the GetSecrets request. The method always @@ -3372,7 +3442,9 @@ func (client ManagementClient) GetSecretVersionsPreparer(vaultBaseURL string, se // GetSecretVersionsSender sends the GetSecretVersions request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetSecretVersionsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetSecretVersionsResponder handles the response to the GetSecretVersions request. The method always @@ -3515,7 +3587,9 @@ func (client ManagementClient) GetStorageAccountPreparer(vaultBaseURL string, st // GetStorageAccountSender sends the GetStorageAccount request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetStorageAccountSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetStorageAccountResponder handles the response to the GetStorageAccount request. The method always @@ -3591,7 +3665,9 @@ func (client ManagementClient) GetStorageAccountsPreparer(vaultBaseURL string, m // GetStorageAccountsSender sends the GetStorageAccounts request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) GetStorageAccountsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // GetStorageAccountsResponder handles the response to the GetStorageAccounts request. The method always @@ -3746,7 +3822,9 @@ func (client ManagementClient) ImportCertificatePreparer(vaultBaseURL string, ce // ImportCertificateSender sends the ImportCertificate request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) ImportCertificateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ImportCertificateResponder handles the response to the ImportCertificate request. The method always @@ -3825,7 +3903,9 @@ func (client ManagementClient) ImportKeyPreparer(vaultBaseURL string, keyName st // ImportKeySender sends the ImportKey request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) ImportKeySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // ImportKeyResponder handles the response to the ImportKey request. The method always @@ -3902,7 +3982,9 @@ func (client ManagementClient) MergeCertificatePreparer(vaultBaseURL string, cer // MergeCertificateSender sends the MergeCertificate request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) MergeCertificateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // MergeCertificateResponder handles the response to the MergeCertificate request. The method always @@ -3972,7 +4054,9 @@ func (client ManagementClient) PurgeDeletedCertificatePreparer(vaultBaseURL stri // PurgeDeletedCertificateSender sends the PurgeDeletedCertificate request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) PurgeDeletedCertificateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // PurgeDeletedCertificateResponder handles the response to the PurgeDeletedCertificate request. The method always @@ -4039,7 +4123,9 @@ func (client ManagementClient) PurgeDeletedKeyPreparer(vaultBaseURL string, keyN // PurgeDeletedKeySender sends the PurgeDeletedKey request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) PurgeDeletedKeySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // PurgeDeletedKeyResponder handles the response to the PurgeDeletedKey request. The method always @@ -4106,7 +4192,9 @@ func (client ManagementClient) PurgeDeletedSecretPreparer(vaultBaseURL string, s // PurgeDeletedSecretSender sends the PurgeDeletedSecret request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) PurgeDeletedSecretSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // PurgeDeletedSecretResponder handles the response to the PurgeDeletedSecret request. The method always @@ -4175,7 +4263,9 @@ func (client ManagementClient) RecoverDeletedCertificatePreparer(vaultBaseURL st // RecoverDeletedCertificateSender sends the RecoverDeletedCertificate request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) RecoverDeletedCertificateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // RecoverDeletedCertificateResponder handles the response to the RecoverDeletedCertificate request. The method always @@ -4243,7 +4333,9 @@ func (client ManagementClient) RecoverDeletedKeyPreparer(vaultBaseURL string, ke // RecoverDeletedKeySender sends the RecoverDeletedKey request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) RecoverDeletedKeySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // RecoverDeletedKeyResponder handles the response to the RecoverDeletedKey request. The method always @@ -4312,7 +4404,9 @@ func (client ManagementClient) RecoverDeletedSecretPreparer(vaultBaseURL string, // RecoverDeletedSecretSender sends the RecoverDeletedSecret request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) RecoverDeletedSecretSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // RecoverDeletedSecretResponder handles the response to the RecoverDeletedSecret request. The method always @@ -4390,7 +4484,9 @@ func (client ManagementClient) RegenerateStorageAccountKeyPreparer(vaultBaseURL // RegenerateStorageAccountKeySender sends the RegenerateStorageAccountKey request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) RegenerateStorageAccountKeySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // RegenerateStorageAccountKeyResponder handles the response to the RegenerateStorageAccountKey request. The method always @@ -4469,7 +4565,9 @@ func (client ManagementClient) RestoreKeyPreparer(vaultBaseURL string, parameter // RestoreKeySender sends the RestoreKey request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) RestoreKeySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // RestoreKeyResponder handles the response to the RestoreKey request. The method always @@ -4541,7 +4639,9 @@ func (client ManagementClient) RestoreSecretPreparer(vaultBaseURL string, parame // RestoreSecretSender sends the RestoreSecret request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) RestoreSecretSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // RestoreSecretResponder handles the response to the RestoreSecret request. The method always @@ -4608,7 +4708,9 @@ func (client ManagementClient) SetCertificateContactsPreparer(vaultBaseURL strin // SetCertificateContactsSender sends the SetCertificateContacts request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) SetCertificateContactsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // SetCertificateContactsResponder handles the response to the SetCertificateContacts request. The method always @@ -4684,7 +4786,9 @@ func (client ManagementClient) SetCertificateIssuerPreparer(vaultBaseURL string, // SetCertificateIssuerSender sends the SetCertificateIssuer request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) SetCertificateIssuerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // SetCertificateIssuerResponder handles the response to the SetCertificateIssuer request. The method always @@ -4766,7 +4870,9 @@ func (client ManagementClient) SetSasDefinitionPreparer(vaultBaseURL string, sto // SetSasDefinitionSender sends the SetSasDefinition request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) SetSasDefinitionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // SetSasDefinitionResponder handles the response to the SetSasDefinition request. The method always @@ -4845,7 +4951,9 @@ func (client ManagementClient) SetSecretPreparer(vaultBaseURL string, secretName // SetSecretSender sends the SetSecret request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) SetSecretSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // SetSecretResponder handles the response to the SetSecret request. The method always @@ -4925,7 +5033,9 @@ func (client ManagementClient) SetStorageAccountPreparer(vaultBaseURL string, st // SetStorageAccountSender sends the SetStorageAccount request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) SetStorageAccountSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // SetStorageAccountResponder handles the response to the SetStorageAccount request. The method always @@ -5003,7 +5113,9 @@ func (client ManagementClient) SignPreparer(vaultBaseURL string, keyName string, // SignSender sends the Sign request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) SignSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // SignResponder handles the response to the Sign request. The method always @@ -5082,7 +5194,9 @@ func (client ManagementClient) UnwrapKeyPreparer(vaultBaseURL string, keyName st // UnwrapKeySender sends the UnwrapKey request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) UnwrapKeySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // UnwrapKeyResponder handles the response to the UnwrapKey request. The method always @@ -5155,7 +5269,9 @@ func (client ManagementClient) UpdateCertificatePreparer(vaultBaseURL string, ce // UpdateCertificateSender sends the UpdateCertificate request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) UpdateCertificateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // UpdateCertificateResponder handles the response to the UpdateCertificate request. The method always @@ -5226,7 +5342,9 @@ func (client ManagementClient) UpdateCertificateIssuerPreparer(vaultBaseURL stri // UpdateCertificateIssuerSender sends the UpdateCertificateIssuer request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) UpdateCertificateIssuerSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // UpdateCertificateIssuerResponder handles the response to the UpdateCertificateIssuer request. The method always @@ -5297,7 +5415,9 @@ func (client ManagementClient) UpdateCertificateOperationPreparer(vaultBaseURL s // UpdateCertificateOperationSender sends the UpdateCertificateOperation request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) UpdateCertificateOperationSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // UpdateCertificateOperationResponder handles the response to the UpdateCertificateOperation request. The method always @@ -5367,7 +5487,9 @@ func (client ManagementClient) UpdateCertificatePolicyPreparer(vaultBaseURL stri // UpdateCertificatePolicySender sends the UpdateCertificatePolicy request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) UpdateCertificatePolicySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // UpdateCertificatePolicyResponder handles the response to the UpdateCertificatePolicy request. The method always @@ -5439,7 +5561,9 @@ func (client ManagementClient) UpdateKeyPreparer(vaultBaseURL string, keyName st // UpdateKeySender sends the UpdateKey request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) UpdateKeySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // UpdateKeyResponder handles the response to the UpdateKey request. The method always @@ -5519,7 +5643,9 @@ func (client ManagementClient) UpdateSasDefinitionPreparer(vaultBaseURL string, // UpdateSasDefinitionSender sends the UpdateSasDefinition request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) UpdateSasDefinitionSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // UpdateSasDefinitionResponder handles the response to the UpdateSasDefinition request. The method always @@ -5591,7 +5717,9 @@ func (client ManagementClient) UpdateSecretPreparer(vaultBaseURL string, secretN // UpdateSecretSender sends the UpdateSecret request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) UpdateSecretSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // UpdateSecretResponder handles the response to the UpdateSecret request. The method always @@ -5667,7 +5795,9 @@ func (client ManagementClient) UpdateStorageAccountPreparer(vaultBaseURL string, // UpdateStorageAccountSender sends the UpdateStorageAccount request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) UpdateStorageAccountSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // UpdateStorageAccountResponder handles the response to the UpdateStorageAccount request. The method always @@ -5748,7 +5878,9 @@ func (client ManagementClient) VerifyPreparer(vaultBaseURL string, keyName strin // VerifySender sends the Verify request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) VerifySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // VerifyResponder handles the response to the Verify request. The method always @@ -5829,7 +5961,9 @@ func (client ManagementClient) WrapKeyPreparer(vaultBaseURL string, keyName stri // WrapKeySender sends the WrapKey request. The method will close the // http.Response Body if it receives an error. func (client ManagementClient) WrapKeySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req) + return autorest.SendWithSender(client, + req, + autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) } // WrapKeyResponder handles the response to the WrapKey request. The method always diff --git a/vendor/github.com/Azure/azure-sdk-for-go/dataplane/keyvault/version.go b/vendor/github.com/Azure/azure-sdk-for-go/dataplane/keyvault/version.go index 64ff8541e0e5..6b0efe68e0b2 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/dataplane/keyvault/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/dataplane/keyvault/version.go @@ -19,10 +19,10 @@ package keyvault // UserAgent returns the UserAgent string to use when sending http.Requests. func UserAgent() string { - return "Azure-SDK-For-Go/v11.0.0-beta arm-keyvault/2016-10-01" + return "Azure-SDK-For-Go/v11.1.1-beta arm-keyvault/2016-10-01" } // Version returns the semantic version (see http://semver.org) of the client. func Version() string { - return "v11.0.0-beta" + return "v11.1.1-beta" } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/blob.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/blob.go index 0e48f3894151..5047bfbb24b8 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/storage/blob.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/blob.go @@ -104,7 +104,7 @@ type BlobProperties struct { CacheControl string `xml:"Cache-Control" header:"x-ms-blob-cache-control"` ContentLanguage string `xml:"Cache-Language" header:"x-ms-blob-content-language"` ContentDisposition string `xml:"Content-Disposition" header:"x-ms-blob-content-disposition"` - BlobType BlobType `xml:"x-ms-blob-blob-type"` + BlobType BlobType `xml:"BlobType"` SequenceNumber int64 `xml:"x-ms-blob-sequence-number"` CopyID string `xml:"CopyId"` CopyStatus string `xml:"CopyStatus"` @@ -549,27 +549,7 @@ func (b *Blob) GetMetadata(options *GetBlobMetadataOptions) error { } func (b *Blob) writeMetadata(h http.Header) { - metadata := make(map[string]string) - for k, v := range h { - // Can't trust CanonicalHeaderKey() to munge case - // reliably. "_" is allowed in identifiers: - // https://msdn.microsoft.com/en-us/library/azure/dd179414.aspx - // https://msdn.microsoft.com/library/aa664670(VS.71).aspx - // http://tools.ietf.org/html/rfc7230#section-3.2 - // ...but "_" is considered invalid by - // CanonicalMIMEHeaderKey in - // https://golang.org/src/net/textproto/reader.go?s=14615:14659#L542 - // so k can be "X-Ms-Meta-Lol" or "x-ms-meta-lol_rofl". - k = strings.ToLower(k) - if len(v) == 0 || !strings.HasPrefix(k, strings.ToLower(userDefinedMetadataHeaderPrefix)) { - continue - } - // metadata["lol"] = content of the last X-Ms-Meta-Lol header - k = k[len(userDefinedMetadataHeaderPrefix):] - metadata[k] = v[len(v)-1] - } - - b.Metadata = BlobMetadata(metadata) + b.Metadata = BlobMetadata(writeMetadata(h)) } // DeleteBlobOptions includes the options for a delete blob operation diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/blobserviceclient.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/blobserviceclient.go index 8fe21b0cfd98..e6b9704ee183 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/storage/blobserviceclient.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/blobserviceclient.go @@ -15,6 +15,7 @@ package storage // limitations under the License. import ( + "encoding/xml" "fmt" "net/http" "net/url" @@ -85,21 +86,53 @@ func (b BlobStorageClient) ListContainers(params ListContainersParameters) (*Con uri := b.client.getEndpoint(blobServiceName, "", q) headers := b.client.getStandardHeaders() - var out ContainerListResponse + type ContainerAlias struct { + bsc *BlobStorageClient + Name string `xml:"Name"` + Properties ContainerProperties `xml:"Properties"` + Metadata BlobMetadata + sasuri url.URL + } + type ContainerListResponseAlias struct { + XMLName xml.Name `xml:"EnumerationResults"` + Xmlns string `xml:"xmlns,attr"` + Prefix string `xml:"Prefix"` + Marker string `xml:"Marker"` + NextMarker string `xml:"NextMarker"` + MaxResults int64 `xml:"MaxResults"` + Containers []ContainerAlias `xml:"Containers>Container"` + } + + var outAlias ContainerListResponseAlias resp, err := b.client.exec(http.MethodGet, uri, headers, nil, b.auth) if err != nil { return nil, err } defer resp.body.Close() - err = xmlUnmarshal(resp.body, &out) + err = xmlUnmarshal(resp.body, &outAlias) if err != nil { return nil, err } - // assign our client to the newly created Container objects - for i := range out.Containers { - out.Containers[i].bsc = &b + out := ContainerListResponse{ + XMLName: outAlias.XMLName, + Xmlns: outAlias.Xmlns, + Prefix: outAlias.Prefix, + Marker: outAlias.Marker, + NextMarker: outAlias.NextMarker, + MaxResults: outAlias.MaxResults, + Containers: make([]Container, len(outAlias.Containers)), + } + for i, cnt := range outAlias.Containers { + out.Containers[i] = Container{ + bsc: &b, + Name: cnt.Name, + Properties: cnt.Properties, + Metadata: map[string]string(cnt.Metadata), + sasuri: cnt.sasuri, + } } + return &out, err } @@ -124,3 +157,26 @@ func (p ListContainersParameters) getParameters() url.Values { return out } + +func writeMetadata(h http.Header) map[string]string { + metadata := make(map[string]string) + for k, v := range h { + // Can't trust CanonicalHeaderKey() to munge case + // reliably. "_" is allowed in identifiers: + // https://msdn.microsoft.com/en-us/library/azure/dd179414.aspx + // https://msdn.microsoft.com/library/aa664670(VS.71).aspx + // http://tools.ietf.org/html/rfc7230#section-3.2 + // ...but "_" is considered invalid by + // CanonicalMIMEHeaderKey in + // https://golang.org/src/net/textproto/reader.go?s=14615:14659#L542 + // so k can be "X-Ms-Meta-Lol" or "x-ms-meta-lol_rofl". + k = strings.ToLower(k) + if len(v) == 0 || !strings.HasPrefix(k, strings.ToLower(userDefinedMetadataHeaderPrefix)) { + continue + } + // metadata["lol"] = content of the last X-Ms-Meta-Lol header + k = k[len(userDefinedMetadataHeaderPrefix):] + metadata[k] = v[len(v)-1] + } + return metadata +} diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/client.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/client.go index 8f6cd95da718..a9ae9d11fc3e 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/storage/client.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/client.go @@ -31,6 +31,7 @@ import ( "net/url" "regexp" "runtime" + "strconv" "strings" "time" @@ -69,6 +70,11 @@ const ( userAgentHeader = "User-Agent" userDefinedMetadataHeaderPrefix = "x-ms-meta-" + + connectionStringAccountName = "accountname" + connectionStringAccountKey = "accountkey" + connectionStringEndpointSuffix = "endpointsuffix" + connectionStringEndpointProtocol = "defaultendpointsprotocol" ) var ( @@ -204,6 +210,45 @@ func (e UnexpectedStatusCodeError) Got() int { return e.got } +// NewClientFromConnectionString creates a Client from the connection string. +func NewClientFromConnectionString(input string) (Client, error) { + var ( + accountName, accountKey, endpointSuffix string + useHTTPS = defaultUseHTTPS + ) + + for _, pair := range strings.Split(input, ";") { + if pair == "" { + continue + } + + equalDex := strings.IndexByte(pair, '=') + if equalDex <= 0 { + return Client{}, fmt.Errorf("Invalid connection segment %q", pair) + } + + value := pair[equalDex+1:] + key := strings.ToLower(pair[:equalDex]) + switch key { + case connectionStringAccountName: + accountName = value + case connectionStringAccountKey: + accountKey = value + case connectionStringEndpointSuffix: + endpointSuffix = value + case connectionStringEndpointProtocol: + useHTTPS = value == "https" + default: + // ignored + } + } + + if accountName == StorageEmulatorAccountName { + return NewEmulatorClient() + } + return NewClient(accountName, accountKey, endpointSuffix, DefaultAPIVersion, useHTTPS) +} + // NewBasicClient constructs a Client with given storage service name and // key. func NewBasicClient(accountName, accountKey string) (Client, error) { @@ -613,12 +658,13 @@ func (c Client) exec(verb, url string, headers map[string]string, body io.Reader return nil, errors.New("azure/storage: error creating request: " + err.Error()) } - // if a body was provided ensure that the content length was set. - // http.NewRequest() will automatically do this for a handful of types - // and for those that it doesn't we will handle here. - if body != nil && req.ContentLength < 1 { - if lr, ok := body.(*io.LimitedReader); ok { - setContentLengthFromLimitedReader(req, lr) + // http.NewRequest() will automatically set req.ContentLength for a handful of types + // otherwise we will handle here. + if req.ContentLength < 1 { + if clstr, ok := headers["Content-Length"]; ok { + if cl, err := strconv.ParseInt(clstr, 10, 64); err == nil { + req.ContentLength = cl + } } } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/container.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/container.go index 8963c7a89b37..9f23248836f3 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/storage/container.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/container.go @@ -512,6 +512,81 @@ func (c *Container) ListBlobs(params ListBlobsParameters) (BlobListResponse, err return out, err } +// ContainerMetadataOptions includes options for container metadata operations +type ContainerMetadataOptions struct { + Timeout uint + LeaseID string `header:"x-ms-lease-id"` + RequestID string `header:"x-ms-client-request-id"` +} + +// SetMetadata replaces the metadata for the specified container. +// +// Some keys may be converted to Camel-Case before sending. All keys +// are returned in lower case by GetBlobMetadata. HTTP header names +// are case-insensitive so case munging should not matter to other +// applications either. +// +// See https://docs.microsoft.com/en-us/rest/api/storageservices/set-container-metadata +func (c *Container) SetMetadata(options *ContainerMetadataOptions) error { + params := url.Values{ + "comp": {"metadata"}, + "restype": {"container"}, + } + headers := c.bsc.client.getStandardHeaders() + headers = c.bsc.client.addMetadataToHeaders(headers, c.Metadata) + + if options != nil { + params = addTimeout(params, options.Timeout) + headers = mergeHeaders(headers, headersFromStruct(*options)) + } + + uri := c.bsc.client.getEndpoint(blobServiceName, c.buildPath(), params) + + resp, err := c.bsc.client.exec(http.MethodPut, uri, headers, nil, c.bsc.auth) + if err != nil { + return err + } + readAndCloseBody(resp.body) + return checkRespCode(resp.statusCode, []int{http.StatusOK}) +} + +// GetMetadata returns all user-defined metadata for the specified container. +// +// All metadata keys will be returned in lower case. (HTTP header +// names are case-insensitive.) +// +// See https://docs.microsoft.com/en-us/rest/api/storageservices/get-container-metadata +func (c *Container) GetMetadata(options *ContainerMetadataOptions) error { + params := url.Values{ + "comp": {"metadata"}, + "restype": {"container"}, + } + headers := c.bsc.client.getStandardHeaders() + + if options != nil { + params = addTimeout(params, options.Timeout) + headers = mergeHeaders(headers, headersFromStruct(*options)) + } + + uri := c.bsc.client.getEndpoint(blobServiceName, c.buildPath(), params) + + resp, err := c.bsc.client.exec(http.MethodGet, uri, headers, nil, c.bsc.auth) + if err != nil { + return err + } + readAndCloseBody(resp.body) + if err := checkRespCode(resp.statusCode, []int{http.StatusOK}); err != nil { + return err + } + + c.writeMetadata(resp.headers) + return nil +} + +func (c *Container) writeMetadata(h http.Header) { + c.Metadata = writeMetadata(h) +} + func generateContainerACLpayload(policies []ContainerAccessPolicy) (io.Reader, int, error) { sil := SignedIdentifiers{ SignedIdentifiers: []SignedIdentifier{}, diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/pageblob.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/pageblob.go index c59fd4b50b9d..f07166521696 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/storage/pageblob.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/pageblob.go @@ -87,10 +87,10 @@ func (b *Blob) modifyRange(blobRange BlobRange, bytes io.Reader, options *PutPag return errors.New("the value for rangeEnd must be greater than or equal to rangeStart") } if blobRange.Start%512 != 0 { - return errors.New("the value for rangeStart must be a modulus of 512") + return errors.New("the value for rangeStart must be a multiple of 512") } if blobRange.End%512 != 511 { - return errors.New("the value for rangeEnd must be a modulus of 511") + return errors.New("the value for rangeEnd must be a multiple of 512 - 1") } params := url.Values{"comp": {"page"}} @@ -147,7 +147,7 @@ func (b *Blob) GetPageRanges(options *GetPageRangesOptions) (GetPageRangesRespon params = addTimeout(params, options.Timeout) params = addSnapshot(params, options.Snapshot) if options.PreviousSnapshot != nil { - params.Add("prevsnapshot", timeRfc1123Formatted(*options.PreviousSnapshot)) + params.Add("prevsnapshot", timeRFC3339Formatted(*options.PreviousSnapshot)) } if options.Range != nil { headers["Range"] = options.Range.String() diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/util.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/util.go index 7734b8f886f7..089a74a8cc67 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/storage/util.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/util.go @@ -71,6 +71,10 @@ func timeRfc1123Formatted(t time.Time) string { return t.Format(http.TimeFormat) } +func timeRFC3339Formatted(t time.Time) string { + return t.Format("2006-01-02T15:04:05.0000000Z") +} + func mergeParams(v1, v2 url.Values) url.Values { out := url.Values{} for k, v := range v1 { @@ -172,7 +176,7 @@ func addTimeout(params url.Values, timeout uint) url.Values { func addSnapshot(params url.Values, snapshot *time.Time) url.Values { if snapshot != nil { - params.Add("snapshot", snapshot.Format("2006-01-02T15:04:05.0000000Z")) + params.Add("snapshot", timeRFC3339Formatted(*snapshot)) } return params } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/util_1.7.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/util_1.7.go deleted file mode 100644 index 67ff6ca03fe3..000000000000 --- a/vendor/github.com/Azure/azure-sdk-for-go/storage/util_1.7.go +++ /dev/null @@ -1,26 +0,0 @@ -// +build !go1.8 - -// Copyright 2017 Microsoft Corporation -// -// 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 storage - -import ( - "io" - "net/http" -) - -func setContentLengthFromLimitedReader(req *http.Request, lr *io.LimitedReader) { - req.ContentLength = lr.N -} diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/util_1.8.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/util_1.8.go deleted file mode 100644 index eada102c0cff..000000000000 --- a/vendor/github.com/Azure/azure-sdk-for-go/storage/util_1.8.go +++ /dev/null @@ -1,32 +0,0 @@ -// +build go1.8 - -// Copyright 2017 Microsoft Corporation -// -// 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 storage - -import ( - "io" - "io/ioutil" - "net/http" -) - -func setContentLengthFromLimitedReader(req *http.Request, lr *io.LimitedReader) { - req.ContentLength = lr.N - snapshot := *lr - req.GetBody = func() (io.ReadCloser, error) { - r := snapshot - return ioutil.NopCloser(&r), nil - } -} diff --git a/vendor/vendor.json b/vendor/vendor.json index 61d21adef407..de47e7dc39ba 100644 --- a/vendor/vendor.json +++ b/vendor/vendor.json @@ -3,260 +3,260 @@ "ignore": "test github.com/hashicorp/terraform/backend", "package": [ { - "checksumSHA1": "gbW7LXRNnauwH+xOFKO6t8/S0CA=", + "checksumSHA1": "cLJryrfFsQ0kxvT26jyrRASjqyE=", "path": "github.com/Azure/azure-sdk-for-go/arm/appinsights", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "gTsLuhrt6QYOBQfwZg5o3qqmpD4=", + "checksumSHA1": "1TjThMsS9q9PFA1Ku6VpArJpwrc=", "path": "github.com/Azure/azure-sdk-for-go/arm/authorization", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "BAuGN+QtZ0+4CHiQk1X/YUiQQCU=", + "checksumSHA1": "dLLvvMHpeu3J7VxCLRUQKDHZWX4=", "path": "github.com/Azure/azure-sdk-for-go/arm/automation", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "/wdbPgLEW4PnyV9LijdNZkkkYV0=", + "checksumSHA1": "Ne7TSUwMhG0j3gjU/xK+mpF8+iI=", "path": "github.com/Azure/azure-sdk-for-go/arm/cdn", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "kQYXDiK2Ud3+PQv1pHREleesGHA=", + "checksumSHA1": "sgst5KZzsaGRp3Q6Qg9+EFXzloo=", "path": "github.com/Azure/azure-sdk-for-go/arm/compute", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "HRNfrRfPNcmLkdlFGqRjJSR2EHo=", + "checksumSHA1": "A1kAbUQOdO46tH0VVmib+++GxNc=", "path": "github.com/Azure/azure-sdk-for-go/arm/containerinstance", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "NifYjlphPThgDyEeGjVuswBgLgc=", + "checksumSHA1": "rYa0VeazE13rwuRokLQ6NjK+PKk=", "path": "github.com/Azure/azure-sdk-for-go/arm/containerregistry", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "465Fe5s/eHhUSVgARqSLH6Op32s=", + "checksumSHA1": "wt107iTLA62ppLn3KHWcCazDRhI=", "path": "github.com/Azure/azure-sdk-for-go/arm/containerservice", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "DGUZQ+NfP6I+5uiCj0Pi0m3A8wA=", + "checksumSHA1": "vuYaWbUWFk+uh7YR1uCpeoXD5lM=", "path": "github.com/Azure/azure-sdk-for-go/arm/cosmos-db", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { "checksumSHA1": "TZa+aR1MLk+nQVZaUWNPWCBHeBQ=", "path": "github.com/Azure/azure-sdk-for-go/arm/disk", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "rBLtPA/CxcJ5fQl6JpgjZOR019g=", + "checksumSHA1": "s6FLUuLGdNO9o3tLucJ92BWCGKM=", "path": "github.com/Azure/azure-sdk-for-go/arm/dns", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "UwrCv4ps3w9sGucIvOXQ13nZyAQ=", + "checksumSHA1": "aDYe656iEsKhC2MChDgin/bEOBo=", "path": "github.com/Azure/azure-sdk-for-go/arm/eventgrid", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "ea00AX29LIaYZgtgeKs+J4VQJLs=", + "checksumSHA1": "qVIgSktHgjRL+m6O3YR/C3QX94w=", "path": "github.com/Azure/azure-sdk-for-go/arm/eventhub", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "+XL0vZeCtpRc9oe+0e6fuRVgJhY=", + "checksumSHA1": "InelJwKuAnbd6CGuCB6pNMhAXlI=", "path": "github.com/Azure/azure-sdk-for-go/arm/graphrbac", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "ALyRCjT78W2bC4r8R/wexKF8ASQ=", + "checksumSHA1": "7lanQDNfujqC80Pmr+h0GQH00D4=", "path": "github.com/Azure/azure-sdk-for-go/arm/keyvault", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "CUnwQihTgQ2V6Vv4WsXR+7D86oo=", + "checksumSHA1": "bb4XrZmhiQKz+tl2ycSykFCnyx4=", "path": "github.com/Azure/azure-sdk-for-go/arm/mysql", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "8r4urZglONMsALA3N9JjjKXEMao=", + "checksumSHA1": "ogmv4nD4MyLgjk0eRughDtWvSZQ=", "path": "github.com/Azure/azure-sdk-for-go/arm/network", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "W5gCm8Is/QE37+0AcVr45QgCR3E=", + "checksumSHA1": "dV30DwwWfqE+HxqIrJDSQL6C6vU=", "path": "github.com/Azure/azure-sdk-for-go/arm/operationalinsights", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "WA17pR4Q+poao0yQ6I7Qyf6CGuc=", + "checksumSHA1": "8a0hsMvOcVsHLBIsLJurLL885eQ=", "path": "github.com/Azure/azure-sdk-for-go/arm/postgresql", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "Ls6pJtI4wzP96wM59amGacYlWxQ=", + "checksumSHA1": "OMI3k1lMtyKXMwJKrAGE0pP5pdo=", "path": "github.com/Azure/azure-sdk-for-go/arm/redis", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "bhJG74moCO/VErpBcGNWg6P77ek=", + "checksumSHA1": "2A4jetKtPI0BebL2+2IfZyMHFuY=", "path": "github.com/Azure/azure-sdk-for-go/arm/resources/locks", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "v3sNtVRCd3dMI1nSb8E5+IFuKsg=", + "checksumSHA1": "/c1STvJS8QAjYpbWC1taB8Jb6oY=", "path": "github.com/Azure/azure-sdk-for-go/arm/resources/resources", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "yrIYQbeU6VKbyaRqcgFSmxun8XQ=", + "checksumSHA1": "+37p6Yqa/A1CC0Y2P1fX+JTftmE=", "path": "github.com/Azure/azure-sdk-for-go/arm/resources/subscriptions", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "mXeO/8ooKJfbzYd/j8KjIeXOx2k=", + "checksumSHA1": "iQ7v67Q37TOdd65RjezPdHkic+U=", "path": "github.com/Azure/azure-sdk-for-go/arm/scheduler", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "i17oNXh69575/WkRES0g8U21TGQ=", + "checksumSHA1": "R0z0S9aDThvTeRWz9v07mvhZM0M=", "path": "github.com/Azure/azure-sdk-for-go/arm/search", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "SR29rm3i51ZeSEDZvmdQ80VxCzM=", + "checksumSHA1": "w27ZgdEpmK5PMEYRoq0isCXDoP8=", "path": "github.com/Azure/azure-sdk-for-go/arm/servicebus", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "zRSN+jujTfNbOvhcQEOch6YTD6E=", + "checksumSHA1": "8ayQzyFNFa5GHy/RgLvNY0cI8lw=", "path": "github.com/Azure/azure-sdk-for-go/arm/sql", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "mUr+CfHry/vyDz3SeO2f7UXI/PI=", + "checksumSHA1": "nXZ5ngUwVap9VKe+dGPNsAfN8ow=", "path": "github.com/Azure/azure-sdk-for-go/arm/storage", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "2nIhDWQyJjBL+y1mgVgObtWXGaU=", + "checksumSHA1": "7uh2CPPBNaws4WnaUv9D2VQ7gb0=", "path": "github.com/Azure/azure-sdk-for-go/arm/trafficmanager", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "f1BQBElAon5ZP55Ju1ke5tAgff0=", + "checksumSHA1": "tGPwaWleaPVxYU/4G5wmKYyPhc0=", "path": "github.com/Azure/azure-sdk-for-go/arm/web", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "34CybL+YSKkBQz4t4wfOGrqc+OQ=", + "checksumSHA1": "hOnaPIkeDhBG2PFf+qAJe8Rgmh4=", "path": "github.com/Azure/azure-sdk-for-go/dataplane/keyvault", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { - "checksumSHA1": "AGv81P7W6EtAm9PhVypziKuhlz4=", + "checksumSHA1": "YhsdEgNxWnYrqYtlBRbwI66DVgw=", "path": "github.com/Azure/azure-sdk-for-go/storage", - "revision": "80f6cbcb1d6295ebb8fbeb5afab826a94aa67d11", - "revisionTime": "2017-10-06T17:43:09Z", - "version": "v11.1.0-beta", - "versionExact": "v11.1.0-beta" + "revision": "7692b0cef22674113fcf71cc17ac3ccc1a7fef48", + "revisionTime": "2017-11-07T22:03:28Z", + "version": "v11.2.2-beta", + "versionExact": "v11.2.2-beta" }, { "checksumSHA1": "tXSzwlsAPETo3wSlIX6o8GqGZLY=", From c664ac6033fcfb46ece6c78884d57375ffb04d15 Mon Sep 17 00:00:00 2001 From: Tom Harvey Date: Fri, 1 Dec 2017 15:20:29 +0000 Subject: [PATCH 37/55] Updating to include #593 --- CHANGELOG.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index d445a5189d04..1994e854c989 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,7 +11,8 @@ IMPROVEMENTS: * core: appending additions to the User Agent, so we don't overwrite the Go SDK User Agent info [GH-587] * `azurerm_eventhub_namespace` - capacity can now be configured up to 20 [GH-556] * `azurerm_eventhub_namespace` - support for AutoInflating/MaximumThroughputCapacity [GH-569] -* `azurerm_image`: fixing an out of index error when flattening image data disks [GH-589] +* `azurerm_image` - fixing an out of index error when flattening image data disks [GH-589] +* `azurerm_virtual_machine` - removing the deprecated `diagnostics_profile` field [GH-593] * `azurerm_virtual_machine_scale_set` - Support for updating the customData field [GH-559] ## 0.3.3 (November 14, 2017) From 4d94018420fe65eb902cb043ecbe2ab9715c5fb3 Mon Sep 17 00:00:00 2001 From: tombuildsstuff Date: Mon, 4 Dec 2017 10:19:46 +0000 Subject: [PATCH 38/55] Fixing the Management Lock validation --- azurerm/resource_arm_management_lock.go | 8 ++++++-- azurerm/resource_arm_management_lock_test.go | 2 +- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/azurerm/resource_arm_management_lock.go b/azurerm/resource_arm_management_lock.go index 47e661bb1144..70b4ebdd7504 100644 --- a/azurerm/resource_arm_management_lock.go +++ b/azurerm/resource_arm_management_lock.go @@ -161,8 +161,12 @@ func parseAzureRMLockId(id string) (*AzureManagementLockId, error) { func validateArmManagementLockName(v interface{}, k string) (ws []string, es []error) { input := v.(string) - if !regexp.MustCompile(`\A([A-Za-z0-9\-_]{1, 260})\z`).MatchString(input) { - es = append(es, fmt.Errorf("%s can only consist of alphanumeric characters, dashes and underscores - and must be a maxiumum of 260 characters", k)) + if !regexp.MustCompile(`[A-Za-z0-9-_]`).MatchString(input) { + es = append(es, fmt.Errorf("%s can only consist of alphanumeric characters, dashes and underscores", k)) + } + + if len(input) >= 260 { + es = append(es, fmt.Errorf("%s can only be a maximum of 260 characters", k)) } return diff --git a/azurerm/resource_arm_management_lock_test.go b/azurerm/resource_arm_management_lock_test.go index 9c57436b6f08..e75d7113c5a1 100644 --- a/azurerm/resource_arm_management_lock_test.go +++ b/azurerm/resource_arm_management_lock_test.go @@ -31,7 +31,7 @@ func TestValidateManagementLockName(t *testing.T) { } for _, test := range testCases { - _, es := validateArmStorageAccountName(test.input, "name") + _, es := validateArmManagementLockName(test.input, "name") if test.shouldError && len(es) == 0 { t.Fatalf("Expected validating name %q to fail", test.input) From ea220633987fee8ea8a025427761dab25e9136a2 Mon Sep 17 00:00:00 2001 From: tombuildsstuff Date: Mon, 4 Dec 2017 11:07:26 +0000 Subject: [PATCH 39/55] Adding a default value for the identity field --- azurerm/resource_arm_virtual_machine.go | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/azurerm/resource_arm_virtual_machine.go b/azurerm/resource_arm_virtual_machine.go index 0d51abf56073..a2eeabbfdd33 100644 --- a/azurerm/resource_arm_virtual_machine.go +++ b/azurerm/resource_arm_virtual_machine.go @@ -675,9 +675,7 @@ func resourceArmVirtualMachineRead(d *schema.ResourceData, meta interface{}) err } } - if resp.Identity != nil { - d.Set("identity", flattenAzureRmVirtualMachineIdentity(resp.Identity)) - } + d.Set("identity", flattenAzureRmVirtualMachineIdentity(resp.Identity)) if resp.VirtualMachineProperties.AvailabilitySet != nil { d.Set("availability_set_id", strings.ToLower(*resp.VirtualMachineProperties.AvailabilitySet.ID)) @@ -908,6 +906,10 @@ func flattenAzureRmVirtualMachineImageReference(image *compute.ImageReference) [ } func flattenAzureRmVirtualMachineIdentity(identity *compute.VirtualMachineIdentity) []interface{} { + if identity == nil { + return make([]interface{}, 0) + } + result := make(map[string]interface{}) result["type"] = string(identity.Type) if identity.PrincipalID != nil { From 868ed36c917f4e2c7217b78a4dd3842a7ba027ce Mon Sep 17 00:00:00 2001 From: Tom Harvey Date: Mon, 4 Dec 2017 12:08:29 +0000 Subject: [PATCH 40/55] Updating to include #482 --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 1994e854c989..bea61c23ea1c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,6 +13,7 @@ IMPROVEMENTS: * `azurerm_eventhub_namespace` - support for AutoInflating/MaximumThroughputCapacity [GH-569] * `azurerm_image` - fixing an out of index error when flattening image data disks [GH-589] * `azurerm_virtual_machine` - removing the deprecated `diagnostics_profile` field [GH-593] +* `azurerm_virtual_machine` - support for managed service identity [GH-482] * `azurerm_virtual_machine_scale_set` - Support for updating the customData field [GH-559] ## 0.3.3 (November 14, 2017) From ad6d27e0f60643a60d0b95b9409fa207a25732db Mon Sep 17 00:00:00 2001 From: Tom Harvey Date: Wed, 6 Dec 2017 09:36:38 +0000 Subject: [PATCH 41/55] Updating to include #574 --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index bea61c23ea1c..9fa785c4e700 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,7 @@ FEATURES: IMPROVEMENTS: * authentication: add support for the latest Azure CLI configuration [GH-573] +* authentication: conditional loading of the Subscription ID / Tenant ID / Environment [GH-574] * core: appending additions to the User Agent, so we don't overwrite the Go SDK User Agent info [GH-587] * `azurerm_eventhub_namespace` - capacity can now be configured up to 20 [GH-556] * `azurerm_eventhub_namespace` - support for AutoInflating/MaximumThroughputCapacity [GH-569] From 3cc2133fb5d1a75c4b5b95b950201ee53be8c720 Mon Sep 17 00:00:00 2001 From: tombuildsstuff Date: Wed, 6 Dec 2017 11:14:10 +0000 Subject: [PATCH 42/55] Adding settings to the hash Test passes: ``` $ acctests azurerm TestAccAzureRMVirtualMachineScaleSet_extensionUpdate === RUN TestAccAzureRMVirtualMachineScaleSet_extensionUpdate --- PASS: TestAccAzureRMVirtualMachineScaleSet_extensionUpdate (593.13s) PASS ok github.com/terraform-providers/terraform-provider-azurerm/azurerm 593.153s ``` --- .../resource_arm_virtual_machine_scale_set.go | 16 +- ...urce_arm_virtual_machine_scale_set_test.go | 149 ++++++++++++++++++ 2 files changed, 163 insertions(+), 2 deletions(-) diff --git a/azurerm/resource_arm_virtual_machine_scale_set.go b/azurerm/resource_arm_virtual_machine_scale_set.go index e4c7a35a98c1..b0740863f59b 100644 --- a/azurerm/resource_arm_virtual_machine_scale_set.go +++ b/azurerm/resource_arm_virtual_machine_scale_set.go @@ -197,7 +197,7 @@ func resourceArmVirtualMachineScaleSet() *schema.Resource { }, }, }, - Set: resourceArmVirtualMachineScaleSetOsProfileLWindowsConfigHash, + Set: resourceArmVirtualMachineScaleSetOsProfileWindowsConfigHash, }, "os_profile_linux_config": { @@ -1166,7 +1166,7 @@ func resourceArmVirtualMachineScaleSetOsProfileLinuxConfigHash(v interface{}) in return hashcode.String(buf.String()) } -func resourceArmVirtualMachineScaleSetOsProfileLWindowsConfigHash(v interface{}) int { +func resourceArmVirtualMachineScaleSetOsProfileWindowsConfigHash(v interface{}) int { var buf bytes.Buffer m := v.(map[string]interface{}) if m["provision_vm_agent"] != nil { @@ -1189,6 +1189,18 @@ func resourceArmVirtualMachineScaleSetExtensionHash(v interface{}) int { buf.WriteString(fmt.Sprintf("%t-", m["auto_upgrade_minor_version"].(bool))) } + // we need to ensure the whitespace is consistent + settings := m["settings"].(string) + if settings != "" { + expandedSettings, err := structure.ExpandJsonFromString(settings) + if err == nil { + serialisedSettings, err := structure.FlattenJsonToString(expandedSettings) + if err == nil { + buf.WriteString(fmt.Sprintf("%s-", serialisedSettings)) + } + } + } + return hashcode.String(buf.String()) } diff --git a/azurerm/resource_arm_virtual_machine_scale_set_test.go b/azurerm/resource_arm_virtual_machine_scale_set_test.go index ffdea5290223..08fd04934c1a 100644 --- a/azurerm/resource_arm_virtual_machine_scale_set_test.go +++ b/azurerm/resource_arm_virtual_machine_scale_set_test.go @@ -437,6 +437,35 @@ func TestAccAzureRMVirtualMachineScaleSet_extension(t *testing.T) { }) } +func TestAccAzureRMVirtualMachineScaleSet_extensionUpdate(t *testing.T) { + resourceName := "azurerm_virtual_machine_scale_set.test" + ri := acctest.RandInt() + location := testLocation() + config := testAccAzureRMVirtualMachineScaleSetExtensionTemplate(ri, location) + updatedConfig := testAccAzureRMVirtualMachineScaleSetExtensionTemplateUpdated(ri, location) + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMVirtualMachineScaleSetDestroy, + Steps: []resource.TestStep{ + { + Config: config, + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMVirtualMachineScaleSetExists(resourceName), + testCheckAzureRMVirtualMachineScaleSetExtension(resourceName), + ), + }, + { + Config: updatedConfig, + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMVirtualMachineScaleSetExists(resourceName), + testCheckAzureRMVirtualMachineScaleSetExtension(resourceName), + ), + }, + }, + }) +} + func TestAccAzureRMVirtualMachineScaleSet_multipleExtensions(t *testing.T) { ri := acctest.RandInt() config := testAccAzureRMVirtualMachineScaleSetMultipleExtensionsTemplate(ri, testLocation()) @@ -2252,6 +2281,14 @@ resource "azurerm_virtual_machine_scale_set" "test" { admin_password = "Passwword1234" } + os_profile_linux_config { + disable_password_authentication = true + ssh_keys { + path = "/home/myadmin/.ssh/authorized_keys" + key_data = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDCsTcryUl51Q2VSEHqDRNmceUFo55ZtcIwxl2QITbN1RREti5ml/VTytC0yeBOvnZA4x4CFpdw/lCDPk0yrH9Ei5vVkXmOrExdTlT3qI7YaAzj1tUVlBd4S6LX1F7y6VLActvdHuDDuXZXzCDd/97420jrDfWZqJMlUK/EmCE5ParCeHIRIvmBxcEnGfFIsw8xQZl0HphxWOtJil8qsUWSdMyCiJYYQpMoMliO99X40AUc4/AlsyPyT5ddbKk08YrZ+rKDVHF7o29rh4vi5MmHkVgVQHKiKybWlHq+b71gIAUQk9wrJxD+dqt4igrmDSpIjfjwnd+l5UIn5fJSO5DYV4YT/4hwK7OKmuo7OFHD0WyY5YnkYEMtFgzemnRBdE8ulcT60DQpVgRMXFWHvhyCWy0L6sgj1QWDZlLpvsIvNfHsyhKFMG1frLnMt/nP0+YCcfg+v1JYeCKjeoJxB8DWcRBsjzItY0CGmzP8UYZiYKl/2u+2TgFS5r7NWH11bxoUzjKdaa1NLw+ieA8GlBFfCbfWe6YVB9ggUte4VtYFMZGxOjS2bAiYtfgTKFJv+XqORAwExG6+G2eDxIDyo80/OA9IG7Xv/jwQr7D6KDjDuULFcN/iTxuttoKrHeYz1hf5ZQlBdllwJHYx6fK2g8kha6r2JIQKocvsAXiiONqSfw== hello@world.com" + } + } + network_profile { name = "TestNetworkProfile" primary = true @@ -2300,6 +2337,118 @@ SETTINGS `, rInt, location, rInt, rInt, rInt, rInt, rInt) } +func testAccAzureRMVirtualMachineScaleSetExtensionTemplateUpdated(rInt int, location string) string { + return fmt.Sprintf(` +resource "azurerm_resource_group" "test" { + name = "acctestrg-%d" + location = "%s" +} + +resource "azurerm_virtual_network" "test" { + name = "acctvn-%d" + address_space = ["10.0.0.0/16"] + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" +} + +resource "azurerm_subnet" "test" { + name = "acctsub-%d" + resource_group_name = "${azurerm_resource_group.test.name}" + virtual_network_name = "${azurerm_virtual_network.test.name}" + address_prefix = "10.0.2.0/24" +} + +resource "azurerm_storage_account" "test" { + name = "accsa%d" + resource_group_name = "${azurerm_resource_group.test.name}" + location = "${azurerm_resource_group.test.location}" + account_tier = "Standard" + account_replication_type = "LRS" +} + +resource "azurerm_storage_container" "test" { + name = "vhds" + resource_group_name = "${azurerm_resource_group.test.name}" + storage_account_name = "${azurerm_storage_account.test.name}" + container_access_type = "private" +} + +resource "azurerm_virtual_machine_scale_set" "test" { + name = "acctvmss-%d" + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" + upgrade_policy_mode = "Manual" + overprovision = false + + sku { + name = "Standard_D1_v2" + tier = "Standard" + capacity = 1 + } + + os_profile { + computer_name_prefix = "testvm-%d" + admin_username = "myadmin" + admin_password = "Passwword1234" + } + + os_profile_linux_config { + disable_password_authentication = true + ssh_keys { + path = "/home/myadmin/.ssh/authorized_keys" + key_data = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDCsTcryUl51Q2VSEHqDRNmceUFo55ZtcIwxl2QITbN1RREti5ml/VTytC0yeBOvnZA4x4CFpdw/lCDPk0yrH9Ei5vVkXmOrExdTlT3qI7YaAzj1tUVlBd4S6LX1F7y6VLActvdHuDDuXZXzCDd/97420jrDfWZqJMlUK/EmCE5ParCeHIRIvmBxcEnGfFIsw8xQZl0HphxWOtJil8qsUWSdMyCiJYYQpMoMliO99X40AUc4/AlsyPyT5ddbKk08YrZ+rKDVHF7o29rh4vi5MmHkVgVQHKiKybWlHq+b71gIAUQk9wrJxD+dqt4igrmDSpIjfjwnd+l5UIn5fJSO5DYV4YT/4hwK7OKmuo7OFHD0WyY5YnkYEMtFgzemnRBdE8ulcT60DQpVgRMXFWHvhyCWy0L6sgj1QWDZlLpvsIvNfHsyhKFMG1frLnMt/nP0+YCcfg+v1JYeCKjeoJxB8DWcRBsjzItY0CGmzP8UYZiYKl/2u+2TgFS5r7NWH11bxoUzjKdaa1NLw+ieA8GlBFfCbfWe6YVB9ggUte4VtYFMZGxOjS2bAiYtfgTKFJv+XqORAwExG6+G2eDxIDyo80/OA9IG7Xv/jwQr7D6KDjDuULFcN/iTxuttoKrHeYz1hf5ZQlBdllwJHYx6fK2g8kha6r2JIQKocvsAXiiONqSfw== hello@world.com" + } + } + + network_profile { + name = "TestNetworkProfile" + primary = true + + ip_configuration { + name = "TestIPConfiguration" + subnet_id = "${azurerm_subnet.test.id}" + } + } + + storage_profile_os_disk { + name = "os-disk" + caching = "ReadWrite" + create_option = "FromImage" + vhd_containers = ["${azurerm_storage_account.test.primary_blob_endpoint}${azurerm_storage_container.test.name}"] + } + + storage_profile_image_reference { + publisher = "Canonical" + offer = "UbuntuServer" + sku = "16.04-LTS" + version = "latest" + } + + extension { + name = "CustomScript" + publisher = "Microsoft.Azure.Extensions" + type = "CustomScript" + type_handler_version = "2.0" + auto_upgrade_minor_version = true + + settings = < Date: Wed, 6 Dec 2017 16:50:49 +0000 Subject: [PATCH 43/55] Updating to include #609 --- CHANGELOG.md | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 9fa785c4e700..b46d6e6efbef 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,15 +7,16 @@ FEATURES: IMPROVEMENTS: -* authentication: add support for the latest Azure CLI configuration [GH-573] -* authentication: conditional loading of the Subscription ID / Tenant ID / Environment [GH-574] -* core: appending additions to the User Agent, so we don't overwrite the Go SDK User Agent info [GH-587] +* authentication - add support for the latest Azure CLI configuration [GH-573] +* authentication - conditional loading of the Subscription ID / Tenant ID / Environment [GH-574] +* core - appending additions to the User Agent, so we don't overwrite the Go SDK User Agent info [GH-587] * `azurerm_eventhub_namespace` - capacity can now be configured up to 20 [GH-556] * `azurerm_eventhub_namespace` - support for AutoInflating/MaximumThroughputCapacity [GH-569] * `azurerm_image` - fixing an out of index error when flattening image data disks [GH-589] * `azurerm_virtual_machine` - removing the deprecated `diagnostics_profile` field [GH-593] * `azurerm_virtual_machine` - support for managed service identity [GH-482] * `azurerm_virtual_machine_scale_set` - Support for updating the customData field [GH-559] +* `azurerm_virtual_machine_scale_set` - ensuring changes to the `settings` object are detected [GH-609] ## 0.3.3 (November 14, 2017) From 257361e09ed7b323eae40e94afdbc1322b6b6034 Mon Sep 17 00:00:00 2001 From: tombuildsstuff Date: Thu, 7 Dec 2017 18:41:23 +0000 Subject: [PATCH 44/55] Local Network Gateways: support for BGP Settings ``` $ acctests azurerm TestAccAzureRMLocalNetworkGateway_ === RUN TestAccAzureRMLocalNetworkGateway_importBasic --- PASS: TestAccAzureRMLocalNetworkGateway_importBasic (82.23s) === RUN TestAccAzureRMLocalNetworkGateway_basic --- PASS: TestAccAzureRMLocalNetworkGateway_basic (81.29s) === RUN TestAccAzureRMLocalNetworkGateway_disappears --- PASS: TestAccAzureRMLocalNetworkGateway_disappears (79.17s) === RUN TestAccAzureRMLocalNetworkGateway_bgpSettings --- PASS: TestAccAzureRMLocalNetworkGateway_bgpSettings (78.70s) === RUN TestAccAzureRMLocalNetworkGateway_bgpSettingsDisable --- PASS: TestAccAzureRMLocalNetworkGateway_bgpSettingsDisable (96.18s) === RUN TestAccAzureRMLocalNetworkGateway_bgpSettingsEnable --- PASS: TestAccAzureRMLocalNetworkGateway_bgpSettingsEnable (97.39s) === RUN TestAccAzureRMLocalNetworkGateway_bgpSettingsComplete --- PASS: TestAccAzureRMLocalNetworkGateway_bgpSettingsComplete (79.68s) PASS ok github.com/terraform-providers/terraform-provider-azurerm/azurerm 594.680s ``` --- azurerm/resource_arm_local_network_gateway.go | 134 ++++++++--- ...resource_arm_local_network_gateway_test.go | 216 ++++++++++++++++-- .../r/local_network_gateway.html.markdown | 15 ++ 3 files changed, 309 insertions(+), 56 deletions(-) diff --git a/azurerm/resource_arm_local_network_gateway.go b/azurerm/resource_arm_local_network_gateway.go index a0384371c1e6..cdc7f7b79a32 100644 --- a/azurerm/resource_arm_local_network_gateway.go +++ b/azurerm/resource_arm_local_network_gateway.go @@ -2,7 +2,6 @@ package azurerm import ( "fmt" - "net/http" "github.com/Azure/azure-sdk-for-go/arm/network" "github.com/hashicorp/terraform/helper/schema" @@ -42,22 +41,48 @@ func resourceArmLocalNetworkGateway() *schema.Resource { Type: schema.TypeString, }, }, + + "bgp_settings": { + Type: schema.TypeList, + Optional: true, + MaxItems: 1, // TODO: confirm + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "asn": { + Type: schema.TypeInt, + Required: true, + }, + + "bgp_peering_address": { + Type: schema.TypeString, + Required: true, + }, + + "peer_weight": { + Type: schema.TypeInt, + Optional: true, + Computed: true, + }, + }, + }, + }, }, } } func resourceArmLocalNetworkGatewayCreate(d *schema.ResourceData, meta interface{}) error { - lnetClient := meta.(*ArmClient).localNetConnClient + client := meta.(*ArmClient).localNetConnClient name := d.Get("name").(string) location := d.Get("location").(string) resGroup := d.Get("resource_group_name").(string) ipAddress := d.Get("gateway_address").(string) - // fetch the 'address_space_prefixes: - prefixes := []string{} - for _, pref := range d.Get("address_space").([]interface{}) { - prefixes = append(prefixes, pref.(string)) + addressSpaces := expandLocalNetworkGatewayAddressSpaces(d) + + bgpSettings, err := expandLocalNetworkGatewayBGPSettings(d) + if err != nil { + return err } gateway := network.LocalNetworkGateway{ @@ -65,24 +90,25 @@ func resourceArmLocalNetworkGatewayCreate(d *schema.ResourceData, meta interface Location: &location, LocalNetworkGatewayPropertiesFormat: &network.LocalNetworkGatewayPropertiesFormat{ LocalNetworkAddressSpace: &network.AddressSpace{ - AddressPrefixes: &prefixes, + AddressPrefixes: &addressSpaces, }, GatewayIPAddress: &ipAddress, + BgpSettings: bgpSettings, }, } - _, error := lnetClient.CreateOrUpdate(resGroup, name, gateway, make(chan struct{})) - err := <-error + _, createError := client.CreateOrUpdate(resGroup, name, gateway, make(chan struct{})) + err = <-createError if err != nil { - return fmt.Errorf("Error creating Azure ARM Local Network Gateway '%s': %s", name, err) + return fmt.Errorf("Error creating Local Network Gateway %q: %+v", name, err) } - read, err := lnetClient.Get(resGroup, name) + read, err := client.Get(resGroup, name) if err != nil { return err } if read.ID == nil { - return fmt.Errorf("Cannot read Virtual Network %s (resource group %s) ID", name, resGroup) + return fmt.Errorf("Cannot read Local Network Gateway ID %q (resource group %q) ID", name, resGroup) } d.SetId(*read.ID) @@ -90,46 +116,49 @@ func resourceArmLocalNetworkGatewayCreate(d *schema.ResourceData, meta interface return resourceArmLocalNetworkGatewayRead(d, meta) } -// resourceArmLocalNetworkGatewayRead goes ahead and reads the state of the corresponding ARM local network gateway. func resourceArmLocalNetworkGatewayRead(d *schema.ResourceData, meta interface{}) error { - lnetClient := meta.(*ArmClient).localNetConnClient + client := meta.(*ArmClient).localNetConnClient id, err := parseAzureResourceID(d.Id()) if err != nil { return err } name := id.Path["localNetworkGateways"] - if name == "" { - return fmt.Errorf("Cannot find 'localNetworkGateways' in '%s', make sure it is specified in the ID parameter", d.Id()) - } resGroup := id.ResourceGroup - resp, err := lnetClient.Get(resGroup, name) + resp, err := client.Get(resGroup, name) if err != nil { if utils.ResponseWasNotFound(resp.Response) { d.SetId("") return nil } - return fmt.Errorf("Error reading the state of Azure ARM local network gateway '%s': %s", name, err) + + return fmt.Errorf("Error reading the state of Local Network Gateway %q (Resource Group %q): %+v", name, resGroup, err) } - d.Set("resource_group_name", resGroup) d.Set("name", resp.Name) + d.Set("resource_group_name", resGroup) d.Set("location", azureRMNormalizeLocation(*resp.Location)) - d.Set("gateway_address", resp.LocalNetworkGatewayPropertiesFormat.GatewayIPAddress) - prefs := []string{} - if ps := *resp.LocalNetworkGatewayPropertiesFormat.LocalNetworkAddressSpace.AddressPrefixes; ps != nil { - prefs = ps + if props := resp.LocalNetworkGatewayPropertiesFormat; props != nil { + d.Set("gateway_address", props.GatewayIPAddress) + + if lnas := props.LocalNetworkAddressSpace; lnas != nil { + if prefixes := lnas.AddressPrefixes; prefixes != nil { + d.Set("address_space", *prefixes) + } + } + flattenedSettings := flattenLocalNetworkGatewayBGPSettings(props.BgpSettings) + if err := d.Set("bgp_settings", flattenedSettings); err != nil { + return err + } } - d.Set("address_space", prefs) return nil } -// resourceArmLocalNetworkGatewayDelete deletes the specified ARM local network gateway. func resourceArmLocalNetworkGatewayDelete(d *schema.ResourceData, meta interface{}) error { - lnetClient := meta.(*ArmClient).localNetConnClient + client := meta.(*ArmClient).localNetConnClient id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -138,17 +167,58 @@ func resourceArmLocalNetworkGatewayDelete(d *schema.ResourceData, meta interface name := id.Path["localNetworkGateways"] resGroup := id.ResourceGroup - deleteResp, error := lnetClient.Delete(resGroup, name, make(chan struct{})) + deleteResp, error := client.Delete(resGroup, name, make(chan struct{})) resp := <-deleteResp err = <-error - if resp.StatusCode == http.StatusNotFound { - return nil - } - if err != nil { + if utils.ResponseWasNotFound(resp) { + return nil + } + return fmt.Errorf("Error issuing Azure ARM delete request of local network gateway '%s': %s", name, err) } return nil } + +func expandLocalNetworkGatewayBGPSettings(d *schema.ResourceData) (*network.BgpSettings, error) { + v, exists := d.GetOk("bgp_settings") + if !exists { + return nil, nil + } + + settings := v.([]interface{}) + setting := settings[0].(map[string]interface{}) + + bgpSettings := network.BgpSettings{} + bgpSettings.Asn = utils.Int64(int64(setting["asn"].(int))) + bgpSettings.BgpPeeringAddress = utils.String(setting["bgp_peering_address"].(string)) + bgpSettings.PeerWeight = utils.Int32(int32(setting["peer_weight"].(int))) + + return &bgpSettings, nil +} + +func expandLocalNetworkGatewayAddressSpaces(d *schema.ResourceData) []string { + prefixes := make([]string, 0) + + for _, pref := range d.Get("address_space").([]interface{}) { + prefixes = append(prefixes, pref.(string)) + } + + return prefixes +} + +func flattenLocalNetworkGatewayBGPSettings(input *network.BgpSettings) []interface{} { + output := make(map[string]interface{}, 0) + + if input == nil { + return []interface{}{} + } + + output["asn"] = int(*input.Asn) + output["bgp_peering_address"] = *input.BgpPeeringAddress + output["peer_weight"] = int(*input.PeerWeight) + + return []interface{}{output} +} diff --git a/azurerm/resource_arm_local_network_gateway_test.go b/azurerm/resource_arm_local_network_gateway_test.go index 77484b0c6067..9a91018f8083 100644 --- a/azurerm/resource_arm_local_network_gateway_test.go +++ b/azurerm/resource_arm_local_network_gateway_test.go @@ -2,12 +2,12 @@ package azurerm import ( "fmt" - "net/http" "testing" "github.com/hashicorp/terraform/helper/acctest" "github.com/hashicorp/terraform/helper/resource" "github.com/hashicorp/terraform/terraform" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" ) func TestAccAzureRMLocalNetworkGateway_basic(t *testing.T) { @@ -54,6 +54,123 @@ func TestAccAzureRMLocalNetworkGateway_disappears(t *testing.T) { }) } +func TestAccAzureRMLocalNetworkGateway_bgpSettings(t *testing.T) { + name := "azurerm_local_network_gateway.test" + rInt := acctest.RandInt() + location := testLocation() + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMLocalNetworkGatewayDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMLocalNetworkGatewayConfig_bgpSettings(rInt, location), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMLocalNetworkGatewayExists(name), + resource.TestCheckResourceAttr(name, "gateway_address", "127.0.0.1"), + resource.TestCheckResourceAttr(name, "address_space.0", "127.0.0.0/8"), + resource.TestCheckResourceAttr(name, "bgp_settings.#", "1"), + ), + }, + }, + }) +} + +func TestAccAzureRMLocalNetworkGateway_bgpSettingsDisable(t *testing.T) { + name := "azurerm_local_network_gateway.test" + rInt := acctest.RandInt() + location := testLocation() + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMLocalNetworkGatewayDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMLocalNetworkGatewayConfig_bgpSettings(rInt, location), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMLocalNetworkGatewayExists(name), + resource.TestCheckResourceAttr(name, "gateway_address", "127.0.0.1"), + resource.TestCheckResourceAttr(name, "address_space.0", "127.0.0.0/8"), + resource.TestCheckResourceAttr(name, "bgp_settings.#", "1"), + resource.TestCheckResourceAttr(name, "bgp_settings.0.asn", "2468"), + resource.TestCheckResourceAttr(name, "bgp_settings.0.bgp_peering_address", "10.104.1.1"), + ), + }, + { + Config: testAccAzureRMLocalNetworkGatewayConfig_basic(rInt, location), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMLocalNetworkGatewayExists(name), + resource.TestCheckResourceAttr(name, "gateway_address", "127.0.0.1"), + resource.TestCheckResourceAttr(name, "address_space.0", "127.0.0.0/8"), + resource.TestCheckResourceAttr(name, "bgp_settings.#", "0"), + ), + }, + }, + }) +} + +func TestAccAzureRMLocalNetworkGateway_bgpSettingsEnable(t *testing.T) { + name := "azurerm_local_network_gateway.test" + rInt := acctest.RandInt() + location := testLocation() + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMLocalNetworkGatewayDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMLocalNetworkGatewayConfig_basic(rInt, location), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMLocalNetworkGatewayExists(name), + resource.TestCheckResourceAttr(name, "gateway_address", "127.0.0.1"), + resource.TestCheckResourceAttr(name, "address_space.0", "127.0.0.0/8"), + resource.TestCheckResourceAttr(name, "bgp_settings.#", "0"), + ), + }, + { + Config: testAccAzureRMLocalNetworkGatewayConfig_bgpSettings(rInt, location), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMLocalNetworkGatewayExists(name), + resource.TestCheckResourceAttr(name, "gateway_address", "127.0.0.1"), + resource.TestCheckResourceAttr(name, "address_space.0", "127.0.0.0/8"), + resource.TestCheckResourceAttr(name, "bgp_settings.#", "1"), + resource.TestCheckResourceAttr(name, "bgp_settings.0.asn", "2468"), + resource.TestCheckResourceAttr(name, "bgp_settings.0.bgp_peering_address", "10.104.1.1"), + ), + }, + }, + }) +} + +func TestAccAzureRMLocalNetworkGateway_bgpSettingsComplete(t *testing.T) { + name := "azurerm_local_network_gateway.test" + rInt := acctest.RandInt() + location := testLocation() + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMLocalNetworkGatewayDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMLocalNetworkGatewayConfig_bgpSettingsComplete(rInt, location), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMLocalNetworkGatewayExists(name), + resource.TestCheckResourceAttr(name, "gateway_address", "127.0.0.1"), + resource.TestCheckResourceAttr(name, "address_space.0", "127.0.0.0/8"), + resource.TestCheckResourceAttr(name, "bgp_settings.#", "1"), + resource.TestCheckResourceAttr(name, "bgp_settings.0.asn", "2468"), + resource.TestCheckResourceAttr(name, "bgp_settings.0.bgp_peering_address", "10.104.1.1"), + resource.TestCheckResourceAttr(name, "bgp_settings.0.peer_weight", "15"), + ), + }, + }, + }) +} + // testCheckAzureRMLocalNetworkGatewayExists returns the resurce.TestCheckFunc // which checks whether or not the expected local network gateway exists both // in the schema, and on Azure. @@ -74,14 +191,15 @@ func testCheckAzureRMLocalNetworkGatewayExists(name string) resource.TestCheckFu resGrp := id.ResourceGroup // and finally, check that it exists on Azure: - lnetClient := testAccProvider.Meta().(*ArmClient).localNetConnClient + client := testAccProvider.Meta().(*ArmClient).localNetConnClient - resp, err := lnetClient.Get(resGrp, localNetName) + resp, err := client.Get(resGrp, localNetName) if err != nil { - if resp.StatusCode == http.StatusNotFound { - return fmt.Errorf("Local network gateway '%s' (resource group '%s') does not exist on Azure.", localNetName, resGrp) + if utils.ResponseWasNotFound(resp.Response) { + return fmt.Errorf("Local network gateway %q (resource group %q) does not exist on Azure.", localNetName, resGrp) } - return fmt.Errorf("Error reading the state of local network gateway '%s': %+v", localNetName, err) + + return fmt.Errorf("Error reading the state of local network gateway %q: %+v", localNetName, err) } return nil @@ -105,16 +223,16 @@ func testCheckAzureRMLocalNetworkGatewayDisappears(name string) resource.TestChe resGrp := id.ResourceGroup // and finally, check that it exists on Azure: - lnetClient := testAccProvider.Meta().(*ArmClient).localNetConnClient + client := testAccProvider.Meta().(*ArmClient).localNetConnClient - deleteResp, error := lnetClient.Delete(resGrp, localNetName, make(chan struct{})) + deleteResp, error := client.Delete(resGrp, localNetName, make(chan struct{})) resp := <-deleteResp err = <-error if err != nil { - if resp.StatusCode == http.StatusNotFound { - return fmt.Errorf("Local network gateway '%s' (resource group '%s') does not exist on Azure.", localNetName, resGrp) + if utils.ResponseWasNotFound(resp) { + return fmt.Errorf("Local network gateway %q (resource group %q) does not exist on Azure.", localNetName, resGrp) } - return fmt.Errorf("Error deleting the state of local network gateway '%s': %+v", localNetName, err) + return fmt.Errorf("Error deleting the state of local network gateway %q: %+v", localNetName, err) } return nil @@ -134,16 +252,18 @@ func testCheckAzureRMLocalNetworkGatewayDestroy(s *terraform.State) error { localNetName := id.Path["localNetworkGateways"] resGrp := id.ResourceGroup - lnetClient := testAccProvider.Meta().(*ArmClient).localNetConnClient - resp, err := lnetClient.Get(resGrp, localNetName) + client := testAccProvider.Meta().(*ArmClient).localNetConnClient + resp, err := client.Get(resGrp, localNetName) if err != nil { - return nil - } + if utils.ResponseWasNotFound(resp.Response) { + return nil + } - if resp.StatusCode != http.StatusNotFound { - return fmt.Errorf("Local network gateway still exists:\n%#v", resp.LocalNetworkGatewayPropertiesFormat) + return err } + + return fmt.Errorf("Local network gateway still exists:\n%#v", resp.LocalNetworkGatewayPropertiesFormat) } return nil @@ -152,16 +272,64 @@ func testCheckAzureRMLocalNetworkGatewayDestroy(s *terraform.State) error { func testAccAzureRMLocalNetworkGatewayConfig_basic(rInt int, location string) string { return fmt.Sprintf(` resource "azurerm_resource_group" "test" { - name = "acctest-%d" - location = "%s" + name = "acctest-%d" + location = "%s" } resource "azurerm_local_network_gateway" "test" { - name = "acctestlng-%d" - location = "${azurerm_resource_group.test.location}" - resource_group_name = "${azurerm_resource_group.test.name}" - gateway_address = "127.0.0.1" - address_space = ["127.0.0.0/8"] + name = "acctestlng-%d" + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" + gateway_address = "127.0.0.1" + address_space = ["127.0.0.0/8"] } + +`, rInt, location, rInt) +} + +func testAccAzureRMLocalNetworkGatewayConfig_bgpSettings(rInt int, location string) string { + return fmt.Sprintf(` +resource "azurerm_resource_group" "test" { + name = "acctest-%d" + location = "%s" +} + +resource "azurerm_local_network_gateway" "test" { + name = "acctestlng-%d" + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" + gateway_address = "127.0.0.1" + address_space = ["127.0.0.0/8"] + + bgp_settings { + asn = 2468 + bgp_peering_address = "10.104.1.1" + } +} + +`, rInt, location, rInt) +} + +func testAccAzureRMLocalNetworkGatewayConfig_bgpSettingsComplete(rInt int, location string) string { + return fmt.Sprintf(` +resource "azurerm_resource_group" "test" { + name = "acctest-%d" + location = "%s" +} + +resource "azurerm_local_network_gateway" "test" { + name = "acctestlng-%d" + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" + gateway_address = "127.0.0.1" + address_space = ["127.0.0.0/8"] + + bgp_settings { + asn = 2468 + bgp_peering_address = "10.104.1.1" + peer_weight = 15 + } +} + `, rInt, location, rInt) } diff --git a/website/docs/r/local_network_gateway.html.markdown b/website/docs/r/local_network_gateway.html.markdown index 2c7c2dd1aa57..77bec0182650 100644 --- a/website/docs/r/local_network_gateway.html.markdown +++ b/website/docs/r/local_network_gateway.html.markdown @@ -47,6 +47,21 @@ The following arguments are supported: * `address_space` - (Required) The list of string CIDRs representing the address spaces the gateway exposes. +* `bgp_settings` - (Optional) A `bgp_settings` block as defined below containing the + Local Network Gateway's BGP speaker settings. + +--- + +`bgp_settings` supports the following: + +* `asn` - (Required) The BGP speaker's ASN. + +* `bgp_peering_address` - (Required) The BGP peering address and BGP identifier + of this BGP speaker. + +* `peer_weight` - (Optional) The weight added to routes learned from this + BGP speaker. + ## Attributes Reference The following attributes are exported: From b58f95b3370b006d45ea8075af3e6ba607ec7a7b Mon Sep 17 00:00:00 2001 From: tombuildsstuff Date: Thu, 7 Dec 2017 18:43:06 +0000 Subject: [PATCH 45/55] Refactoring --- azurerm/resource_arm_local_network_gateway.go | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/azurerm/resource_arm_local_network_gateway.go b/azurerm/resource_arm_local_network_gateway.go index cdc7f7b79a32..03d39c7e56c3 100644 --- a/azurerm/resource_arm_local_network_gateway.go +++ b/azurerm/resource_arm_local_network_gateway.go @@ -45,7 +45,7 @@ func resourceArmLocalNetworkGateway() *schema.Resource { "bgp_settings": { Type: schema.TypeList, Optional: true, - MaxItems: 1, // TODO: confirm + MaxItems: 1, Elem: &schema.Resource{ Schema: map[string]*schema.Schema{ "asn": { @@ -176,7 +176,7 @@ func resourceArmLocalNetworkGatewayDelete(d *schema.ResourceData, meta interface return nil } - return fmt.Errorf("Error issuing Azure ARM delete request of local network gateway '%s': %s", name, err) + return fmt.Errorf("Error issuing delete request for local network gateway %q: %+v", name, err) } return nil @@ -191,10 +191,11 @@ func expandLocalNetworkGatewayBGPSettings(d *schema.ResourceData) (*network.BgpS settings := v.([]interface{}) setting := settings[0].(map[string]interface{}) - bgpSettings := network.BgpSettings{} - bgpSettings.Asn = utils.Int64(int64(setting["asn"].(int))) - bgpSettings.BgpPeeringAddress = utils.String(setting["bgp_peering_address"].(string)) - bgpSettings.PeerWeight = utils.Int32(int32(setting["peer_weight"].(int))) + bgpSettings := network.BgpSettings{ + Asn: utils.Int64(int64(setting["asn"].(int))), + BgpPeeringAddress: utils.String(setting["bgp_peering_address"].(string)), + PeerWeight: utils.Int32(int32(setting["peer_weight"].(int))), + } return &bgpSettings, nil } From a36e197bb69c4fbf245f0b47d2755924bd38478b Mon Sep 17 00:00:00 2001 From: tombuildsstuff Date: Thu, 7 Dec 2017 18:46:16 +0000 Subject: [PATCH 46/55] Adding an import test for BGP Settings: ``` $ acctests azurerm TestAccAzureRMLocalNetworkGateway_importBGPSettingsComplete === RUN TestAccAzureRMLocalNetworkGateway_importBGPSettingsComplete --- PASS: TestAccAzureRMLocalNetworkGateway_importBGPSettingsComplete (80.96s) PASS ok github.com/terraform-providers/terraform-provider-azurerm/azurerm 80.987s ``` --- .../import_arm_local_network_gateway_test.go | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/azurerm/import_arm_local_network_gateway_test.go b/azurerm/import_arm_local_network_gateway_test.go index 47b20cd42864..1ddf471efb05 100644 --- a/azurerm/import_arm_local_network_gateway_test.go +++ b/azurerm/import_arm_local_network_gateway_test.go @@ -28,3 +28,25 @@ func TestAccAzureRMLocalNetworkGateway_importBasic(t *testing.T) { }, }) } + +func TestAccAzureRMLocalNetworkGateway_importBGPSettingsComplete(t *testing.T) { + resourceName := "azurerm_local_network_gateway.test" + rInt := acctest.RandInt() + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testCheckAzureRMLocalNetworkGatewayDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMLocalNetworkGatewayConfig_bgpSettingsComplete(rInt, testLocation()), + }, + + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + }, + }, + }) +} From d340a00fb9a4fb478c8603bcd58a7a765d07d37d Mon Sep 17 00:00:00 2001 From: tombuildsstuff Date: Fri, 8 Dec 2017 11:02:16 +0000 Subject: [PATCH 47/55] Splitting the data source out into it's own step --- azurerm/data_source_virtual_network_test.go | 142 ++++++++++++-------- 1 file changed, 87 insertions(+), 55 deletions(-) diff --git a/azurerm/data_source_virtual_network_test.go b/azurerm/data_source_virtual_network_test.go index 8830b6c40391..6e55fa488453 100644 --- a/azurerm/data_source_virtual_network_test.go +++ b/azurerm/data_source_virtual_network_test.go @@ -37,14 +37,17 @@ func TestAccDataSourceArmVirtualNetwork_peering(t *testing.T) { ri := acctest.RandInt() name_vnet_1 := fmt.Sprintf("acctestvnet-1-%d", ri) - config := testAccDataSourceArmVirtualNetwork_peering(ri, testLocation()) + location := testLocation() resource.Test(t, resource.TestCase{ PreCheck: func() { testAccPreCheck(t) }, Providers: testAccProviders, Steps: []resource.TestStep{ { - Config: config, + Config: testAccDataSourceArmVirtualNetwork_peering(ri, location), + }, + { + Config: testAccDataSourceArmVirtualNetwork_peeringWithDataSource(ri, location), Check: resource.ComposeTestCheckFunc( resource.TestCheckResourceAttr(dataSourceName, "name", name_vnet_1), resource.TestCheckResourceAttr(dataSourceName, "address_spaces.0", "10.0.1.0/24"), @@ -57,63 +60,92 @@ func TestAccDataSourceArmVirtualNetwork_peering(t *testing.T) { func testAccDataSourceArmVirtualNetwork_basic(rInt int, location string) string { return fmt.Sprintf(` - resource "azurerm_resource_group" "test" { - name = "acctest%d-rg" - location = "%s" - } - - resource "azurerm_virtual_network" "test" { - name = "acctestvnet-%d" - address_space = ["10.0.0.0/16"] - location = "${azurerm_resource_group.test.location}" - resource_group_name = "${azurerm_resource_group.test.name}" - dns_servers = ["10.0.0.4"] - - subnet { - name = "subnet1" - address_prefix = "10.0.1.0/24" - } - } - - data "azurerm_virtual_network" "test" { - resource_group_name = "${azurerm_resource_group.test.name}" - name = "${azurerm_virtual_network.test.name}" - } +resource "azurerm_resource_group" "test" { + name = "acctest%d-rg" + location = "%s" +} +resource "azurerm_virtual_network" "test" { + name = "acctestvnet-%d" + address_space = ["10.0.0.0/16"] + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" + dns_servers = ["10.0.0.4"] + + subnet { + name = "subnet1" + address_prefix = "10.0.1.0/24" + } +} + +data "azurerm_virtual_network" "test" { + resource_group_name = "${azurerm_resource_group.test.name}" + name = "${azurerm_virtual_network.test.name}" +} `, rInt, location, rInt) } func testAccDataSourceArmVirtualNetwork_peering(rInt int, location string) string { return fmt.Sprintf(` - resource "azurerm_resource_group" "test" { - name = "acctest%d-rg" - location = "%s" - } - - resource "azurerm_virtual_network" "test1" { - name = "acctestvnet-1-%d" - address_space = ["10.0.1.0/24"] - location = "${azurerm_resource_group.test.location}" - resource_group_name = "${azurerm_resource_group.test.name}" - } - - resource "azurerm_virtual_network" "test2" { - name = "acctestvnet-2-%d" - address_space = ["10.0.2.0/24"] - location = "${azurerm_resource_group.test.location}" - resource_group_name = "${azurerm_resource_group.test.name}" - } - - resource "azurerm_virtual_network_peering" "test1" { - name = "peer-1to2" - resource_group_name = "${azurerm_resource_group.test.name}" - virtual_network_name = "${azurerm_virtual_network.test1.name}" - remote_virtual_network_id = "${azurerm_virtual_network.test2.id}" - } - - data "azurerm_virtual_network" "test" { - resource_group_name = "${azurerm_resource_group.test.name}" - name = "${azurerm_virtual_network.test1.name}" - } - `, rInt, location, rInt, rInt) +resource "azurerm_resource_group" "test" { + name = "acctest%d-rg" + location = "%s" +} + +resource "azurerm_virtual_network" "test1" { + name = "acctestvnet-1-%d" + address_space = ["10.0.1.0/24"] + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" +} + +resource "azurerm_virtual_network" "test2" { + name = "acctestvnet-2-%d" + address_space = ["10.0.2.0/24"] + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" +} + +resource "azurerm_virtual_network_peering" "test1" { + name = "peer-1to2" + resource_group_name = "${azurerm_resource_group.test.name}" + virtual_network_name = "${azurerm_virtual_network.test1.name}" + remote_virtual_network_id = "${azurerm_virtual_network.test2.id}" +} +`, rInt, location, rInt, rInt) +} + +func testAccDataSourceArmVirtualNetwork_peeringWithDataSource(rInt int, location string) string { + return fmt.Sprintf(` +resource "azurerm_resource_group" "test" { + name = "acctest%d-rg" + location = "%s" +} + +resource "azurerm_virtual_network" "test1" { + name = "acctestvnet-1-%d" + address_space = ["10.0.1.0/24"] + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" +} + +resource "azurerm_virtual_network" "test2" { + name = "acctestvnet-2-%d" + address_space = ["10.0.2.0/24"] + location = "${azurerm_resource_group.test.location}" + resource_group_name = "${azurerm_resource_group.test.name}" +} + +resource "azurerm_virtual_network_peering" "test1" { + name = "peer-1to2" + resource_group_name = "${azurerm_resource_group.test.name}" + virtual_network_name = "${azurerm_virtual_network.test1.name}" + remote_virtual_network_id = "${azurerm_virtual_network.test2.id}" +} + +data "azurerm_virtual_network" "test" { + resource_group_name = "${azurerm_resource_group.test.name}" + name = "${azurerm_virtual_network.test1.name}" +} +`, rInt, location, rInt, rInt) } From e9a3ea64802b9adb9131d525d96dfb34afc35d88 Mon Sep 17 00:00:00 2001 From: tombuildsstuff Date: Fri, 8 Dec 2017 12:05:06 +0000 Subject: [PATCH 48/55] Minor refactoring --- azurerm/data_source_virtual_network.go | 18 +++++++++--------- azurerm/data_source_virtual_network_test.go | 4 ++-- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/azurerm/data_source_virtual_network.go b/azurerm/data_source_virtual_network.go index 8fa68d5061b9..f8084f51b985 100644 --- a/azurerm/data_source_virtual_network.go +++ b/azurerm/data_source_virtual_network.go @@ -55,15 +55,15 @@ func dataSourceArmVirtualNetwork() *schema.Resource { } func dataSourceArmVnetRead(d *schema.ResourceData, meta interface{}) error { - vnetClient := meta.(*ArmClient).vnetClient + client := meta.(*ArmClient).vnetClient resGroup := d.Get("resource_group_name").(string) name := d.Get("name").(string) - resp, err := vnetClient.Get(resGroup, name, "") + resp, err := client.Get(resGroup, name, "") if err != nil { if utils.ResponseWasNotFound(resp.Response) { - return fmt.Errorf("Error making Read request on Azure virtual network %s: %+v", name, err) + return fmt.Errorf("Error making Read request on Azure virtual network %q (resource group %q): %+v", name, resGroup, err) } return err } @@ -71,13 +71,13 @@ func dataSourceArmVnetRead(d *schema.ResourceData, meta interface{}) error { d.SetId(*resp.ID) if props := resp.VirtualNetworkPropertiesFormat; props != nil { - address_spaces := flattenVnetAddressPrefixes(props.AddressSpace.AddressPrefixes) - if err := d.Set("address_spaces", address_spaces); err != nil { + addressSpaces := flattenVnetAddressPrefixes(props.AddressSpace.AddressPrefixes) + if err := d.Set("address_spaces", addressSpaces); err != nil { return err } - dns_servers := flattenVnetAddressPrefixes(props.DhcpOptions.DNSServers) - if err := d.Set("dns_servers", dns_servers); err != nil { + dnsServers := flattenVnetAddressPrefixes(props.DhcpOptions.DNSServers) + if err := d.Set("dns_servers", dnsServers); err != nil { return err } @@ -86,8 +86,8 @@ func dataSourceArmVnetRead(d *schema.ResourceData, meta interface{}) error { return err } - vnet_peerings := flattenVnetPeerings(props.VirtualNetworkPeerings) - if err := d.Set("vnet_peerings", vnet_peerings); err != nil { + vnetPeerings := flattenVnetPeerings(props.VirtualNetworkPeerings) + if err := d.Set("vnet_peerings", vnetPeerings); err != nil { return err } } diff --git a/azurerm/data_source_virtual_network_test.go b/azurerm/data_source_virtual_network_test.go index 6e55fa488453..74d3c9090eb6 100644 --- a/azurerm/data_source_virtual_network_test.go +++ b/azurerm/data_source_virtual_network_test.go @@ -36,7 +36,7 @@ func TestAccDataSourceArmVirtualNetwork_peering(t *testing.T) { dataSourceName := "data.azurerm_virtual_network.test" ri := acctest.RandInt() - name_vnet_1 := fmt.Sprintf("acctestvnet-1-%d", ri) + virtualNetworkName := fmt.Sprintf("acctestvnet-1-%d", ri) location := testLocation() resource.Test(t, resource.TestCase{ @@ -49,7 +49,7 @@ func TestAccDataSourceArmVirtualNetwork_peering(t *testing.T) { { Config: testAccDataSourceArmVirtualNetwork_peeringWithDataSource(ri, location), Check: resource.ComposeTestCheckFunc( - resource.TestCheckResourceAttr(dataSourceName, "name", name_vnet_1), + resource.TestCheckResourceAttr(dataSourceName, "name", virtualNetworkName), resource.TestCheckResourceAttr(dataSourceName, "address_spaces.0", "10.0.1.0/24"), resource.TestCheckResourceAttr(dataSourceName, "vnet_peerings.%", "1"), ), From bc6c64989c2a9226057d5851bfaba0d82850c1d1 Mon Sep 17 00:00:00 2001 From: Tom Harvey Date: Fri, 8 Dec 2017 12:43:21 +0000 Subject: [PATCH 49/55] Updating to include #533 --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index b46d6e6efbef..4cb1b01ae3d7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,7 @@ FEATURES: +* **New Data Source:** `azurerm_virtual_network` [GH-533] * **New Resource:** `azurerm_management_lock` [GH-575] * **New Resource:** `azurerm_network_watcher` [GH-571] From 1c12384ce126eefc1ab13e0b5d6155c91f0c4d5d Mon Sep 17 00:00:00 2001 From: tombuildsstuff Date: Fri, 8 Dec 2017 13:49:02 +0000 Subject: [PATCH 50/55] Exporting the Default Hostname field --- azurerm/resource_arm_app_service.go | 6 ++++++ website/docs/r/app_service.html.markdown | 2 ++ 2 files changed, 8 insertions(+) diff --git a/azurerm/resource_arm_app_service.go b/azurerm/resource_arm_app_service.go index ecbea344681f..fadca55fe990 100644 --- a/azurerm/resource_arm_app_service.go +++ b/azurerm/resource_arm_app_service.go @@ -229,6 +229,11 @@ func resourceArmAppService() *schema.Resource { // TODO: (tombuildsstuff) support Update once the API is fixed: // https://github.com/Azure/azure-rest-api-specs/issues/1697 "tags": tagsForceNewSchema(), + + "default_site_hostname": { + Type: schema.TypeString, + Computed: true, + }, }, } } @@ -382,6 +387,7 @@ func resourceArmAppServiceRead(d *schema.ResourceData, meta interface{}) error { d.Set("app_service_plan_id", props.ServerFarmID) d.Set("client_affinity_enabled", props.ClientAffinityEnabled) d.Set("enabled", props.Enabled) + d.Set("default_site_hostname", props.DefaultHostName) } if err := d.Set("app_settings", flattenAppServiceAppSettings(appSettingsResp.Properties)); err != nil { diff --git a/website/docs/r/app_service.html.markdown b/website/docs/r/app_service.html.markdown index 35b580b25adc..0f0eaf7e4d18 100644 --- a/website/docs/r/app_service.html.markdown +++ b/website/docs/r/app_service.html.markdown @@ -166,6 +166,8 @@ The following attributes are exported: * `id` - The ID of the App Service. +* `default_site_hostname` - The Default Hostname associated with the App Service - such as `mysite.azurewebsites.net` + ## Import App Services can be imported using the `resource id`, e.g. From 10633c6c860686f0c5d098a0036281c71bf757af Mon Sep 17 00:00:00 2001 From: tombuildsstuff Date: Fri, 8 Dec 2017 14:00:49 +0000 Subject: [PATCH 51/55] Updating the App Service example to be complete This removes support for Publishing, since the SCM URL's aren't consistent across Sovereign Clouds (China/Germany/Govt etc) Switches to using the new `default_site_hostname` field introduced in #612 rather than assuming what it is --- examples/app-service-asp-net/README.md | 23 ------- examples/app-service-asp-net/app.tf | 66 ------------------- examples/app-service-asp-net/variables.tf | 29 -------- examples/app-service-asp-net/web-package.zip | Bin 378 -> 0 bytes examples/app-service/README.md | 15 +++++ examples/app-service/app.tf | 50 ++++++++++++++ examples/app-service/variables.tf | 21 ++++++ 7 files changed, 86 insertions(+), 118 deletions(-) delete mode 100644 examples/app-service-asp-net/README.md delete mode 100644 examples/app-service-asp-net/app.tf delete mode 100644 examples/app-service-asp-net/variables.tf delete mode 100644 examples/app-service-asp-net/web-package.zip create mode 100644 examples/app-service/README.md create mode 100644 examples/app-service/app.tf create mode 100644 examples/app-service/variables.tf diff --git a/examples/app-service-asp-net/README.md b/examples/app-service-asp-net/README.md deleted file mode 100644 index d0190b8b7a23..000000000000 --- a/examples/app-service-asp-net/README.md +++ /dev/null @@ -1,23 +0,0 @@ -# ASP.NET App-Service Sample - -Sample to deploy an ASP.NET application into Azure App-Services. - -## Creates - -1. A Resource Group -2. An App Service Plan -3. An App Service for usage with .NET -4. Deploy a simple app into (3). - -## Usage - -- Provide values to all variables (credentials and names). -- Create with `terraform apply` -- Destroy all with `terraform destroy --force` - - -## Prerequisites - -- Uses `curl` for application publication. Preinstall curl in your system and add it to the system path. - -**Note:** The Sample uses a local provisioner prepared for a DOS shell (trivial changes needed for a bash shell). \ No newline at end of file diff --git a/examples/app-service-asp-net/app.tf b/examples/app-service-asp-net/app.tf deleted file mode 100644 index 1ba51ae510fd..000000000000 --- a/examples/app-service-asp-net/app.tf +++ /dev/null @@ -1,66 +0,0 @@ -# Configure the Microsoft Azure Provider -provider "azurerm" { - # if you're using a Service Principal (shared account) then either set the environment variables, or fill these in: - # subscription_id = "..." - # client_id = "..." - # client_secret = "..." - # tenant_id = "..." -} - -resource "azurerm_resource_group" "g1" { - name = "${var.resource_group_name}" - location = "${var.location}" -} - -resource "azurerm_app_service_plan" "plan0" { - name = "service-plan0" - location = "${var.location}" - resource_group_name = "${azurerm_resource_group.g1.name}" - - sku { - tier = "Basic" # Basic | Standard | ... - size = "B1" # B1 | S1 | ... - } -} - -# underscores not supported as app_service name -> if not: you will receive error 400 - -resource "azurerm_app_service" "common_service" { - name = "${var.app_service_name}" - location = "${var.location}" - resource_group_name = "${azurerm_resource_group.g1.name}" - app_service_plan_id = "${azurerm_app_service_plan.plan0.id}" - - site_config { - dotnet_framework_version = "v4.0" - remote_debugging_enabled = true - remote_debugging_version = "VS2015" - } - - # app_settings { - # "SOME_KEY" = "some-value" - # } - # connection_string { - # name = "Database" - # type = "SQLServer" - # value = "Server=some-server.mydomain.com;Integrated Security=SSPI" - # } - - provisioner "local-exec" { - command = "curl -k -u ${var.deploy_user}:${var.deploy_pass} -X PUT --data-binary @${var.deployZipFile} https://${azurerm_app_service.common_service.name}.scm.azurewebsites.net/api/zip/site/wwwroot/" - - # interpreter = ["cmd"] - } -} - -output "service" { - value = "${azurerm_app_service.common_service.name}" -} - -output "service_url" { - value = "https://${azurerm_app_service.common_service.name}.azurewebsites.net" -} - -output "admin_url" { - value = "https://${azurerm_app_service.common_service.name}.scm.azurewebsites.net" -} diff --git a/examples/app-service-asp-net/variables.tf b/examples/app-service-asp-net/variables.tf deleted file mode 100644 index 78abf98e6a59..000000000000 --- a/examples/app-service-asp-net/variables.tf +++ /dev/null @@ -1,29 +0,0 @@ -variable "resource_group_name" { - type = "string" - default = "yourGroupName" -} - -variable "location" { - type = "string" - default = "westeurope" -} - -variable "app_service_name" { - type = "string" - - # will create -> mySite123456.azurewebsites.net #should be unique - # default = "mySite123456" -} - -variable "deploy_user" { - type = "string" -} - -variable "deploy_pass" { - type = "string" -} - -variable "deployZipFile" { - type = "string" - default = "web-package.zip" -} diff --git a/examples/app-service-asp-net/web-package.zip b/examples/app-service-asp-net/web-package.zip deleted file mode 100644 index 2291a451f720284b27924254f1867e79bd2e5e68..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 378 zcmWIWW@Zs#U|`^2_%XrL`|CZ29CIMg4T!mbI5RILwL&kWBsXXCNsW_dH$Hy)Xp845 z|CKC;A|g3PJa27+iiGYQ-f2^X8b Date: Fri, 8 Dec 2017 15:41:55 +0000 Subject: [PATCH 52/55] Updating to include #594 --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4cb1b01ae3d7..ad89b2afcb3f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,7 @@ IMPROVEMENTS: * authentication - add support for the latest Azure CLI configuration [GH-573] * authentication - conditional loading of the Subscription ID / Tenant ID / Environment [GH-574] * core - appending additions to the User Agent, so we don't overwrite the Go SDK User Agent info [GH-587] +* core: Upgrading to v11.2.2-beta of the Azure SDK for Go [GH-594] * `azurerm_eventhub_namespace` - capacity can now be configured up to 20 [GH-556] * `azurerm_eventhub_namespace` - support for AutoInflating/MaximumThroughputCapacity [GH-569] * `azurerm_image` - fixing an out of index error when flattening image data disks [GH-589] From 40e0f0aec8c523dbde3cb24d0596959188240cde Mon Sep 17 00:00:00 2001 From: Tom Harvey Date: Fri, 8 Dec 2017 15:58:13 +0000 Subject: [PATCH 53/55] Updating to include #611 --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index ad89b2afcb3f..7df216508d77 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,6 +15,7 @@ IMPROVEMENTS: * `azurerm_eventhub_namespace` - capacity can now be configured up to 20 [GH-556] * `azurerm_eventhub_namespace` - support for AutoInflating/MaximumThroughputCapacity [GH-569] * `azurerm_image` - fixing an out of index error when flattening image data disks [GH-589] +* `azurerm_local_network_gateway` - support for BGP Settings [GH-611] * `azurerm_virtual_machine` - removing the deprecated `diagnostics_profile` field [GH-593] * `azurerm_virtual_machine` - support for managed service identity [GH-482] * `azurerm_virtual_machine_scale_set` - Support for updating the customData field [GH-559] From f717de20f59d13a589b311ae05aa74bdcf90d1ba Mon Sep 17 00:00:00 2001 From: Tom Harvey Date: Fri, 8 Dec 2017 15:59:17 +0000 Subject: [PATCH 54/55] Updating to include #612 --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7df216508d77..0b120d66228d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,6 +12,7 @@ IMPROVEMENTS: * authentication - conditional loading of the Subscription ID / Tenant ID / Environment [GH-574] * core - appending additions to the User Agent, so we don't overwrite the Go SDK User Agent info [GH-587] * core: Upgrading to v11.2.2-beta of the Azure SDK for Go [GH-594] +* `azurerm_app_service` - exposing the Default Hostname as a Computed field [GH-612] * `azurerm_eventhub_namespace` - capacity can now be configured up to 20 [GH-556] * `azurerm_eventhub_namespace` - support for AutoInflating/MaximumThroughputCapacity [GH-569] * `azurerm_image` - fixing an out of index error when flattening image data disks [GH-589] From 897428ef8db7b01bfc048b1a5bd1bb57184c0460 Mon Sep 17 00:00:00 2001 From: trotttrotttrott Date: Fri, 8 Dec 2017 10:43:58 -0800 Subject: [PATCH 55/55] Remove leading line break from key_vault_key docs Leading line break causes page metadata to be ignored. --- website/docs/r/key_vault_key.html.markdown | 1 - 1 file changed, 1 deletion(-) diff --git a/website/docs/r/key_vault_key.html.markdown b/website/docs/r/key_vault_key.html.markdown index 3a017fa0eab3..2c5adf0f6113 100644 --- a/website/docs/r/key_vault_key.html.markdown +++ b/website/docs/r/key_vault_key.html.markdown @@ -1,4 +1,3 @@ - --- layout: "azurerm" page_title: "Azure Resource Manager: azurerm_key_vault_key"