From f197fab07b3324df23a2d49a7cc25a3afef6f1c3 Mon Sep 17 00:00:00 2001 From: tombuildsstuff Date: Mon, 22 Jan 2018 10:56:38 +0100 Subject: [PATCH] Upgrading the Networking Data Sources / Resources onto the new SDK --- azurerm/config.go | 211 +++++++----------- azurerm/data_source_network_security_group.go | 3 +- azurerm/data_source_public_ip.go | 9 +- azurerm/data_source_subnet.go | 3 +- azurerm/data_source_virtual_network.go | 5 +- azurerm/express_route_circuit.go | 5 +- azurerm/loadbalancer.go | 12 +- azurerm/resource_arm_application_gateway.go | 36 +-- .../resource_arm_application_gateway_test.go | 49 ++-- azurerm/resource_arm_express_route_circuit.go | 47 ++-- ...resource_arm_express_route_circuit_test.go | 15 +- azurerm/resource_arm_loadbalancer.go | 133 ++++++----- ...e_arm_loadbalancer_backend_address_pool.go | 92 ++++---- ..._loadbalancer_backend_address_pool_test.go | 19 +- azurerm/resource_arm_loadbalancer_nat_pool.go | 92 ++++---- ...resource_arm_loadbalancer_nat_pool_test.go | 19 +- azurerm/resource_arm_loadbalancer_nat_rule.go | 62 ++--- ...resource_arm_loadbalancer_nat_rule_test.go | 19 +- azurerm/resource_arm_loadbalancer_probe.go | 62 ++--- .../resource_arm_loadbalancer_probe_test.go | 17 +- azurerm/resource_arm_loadbalancer_rule.go | 48 ++-- .../resource_arm_loadbalancer_rule_test.go | 17 +- azurerm/resource_arm_loadbalancer_test.go | 18 +- azurerm/resource_arm_local_network_gateway.go | 36 ++- ...resource_arm_local_network_gateway_test.go | 25 ++- azurerm/resource_arm_network_interface.go | 30 ++- .../resource_arm_network_interface_test.go | 41 +++- .../resource_arm_network_security_group.go | 60 ++--- ...esource_arm_network_security_group_test.go | 16 +- azurerm/resource_arm_network_security_rule.go | 46 ++-- ...resource_arm_network_security_rule_test.go | 22 +- azurerm/resource_arm_network_watcher.go | 24 +- azurerm/resource_arm_network_watcher_test.go | 21 +- azurerm/resource_arm_public_ip.go | 82 ++++--- azurerm/resource_arm_public_ip_test.go | 26 ++- azurerm/resource_arm_route.go | 32 ++- azurerm/resource_arm_route_table.go | 36 +-- azurerm/resource_arm_route_table_test.go | 24 +- azurerm/resource_arm_route_test.go | 23 +- azurerm/resource_arm_subnet.go | 34 ++- azurerm/resource_arm_subnet_test.go | 34 +-- azurerm/resource_arm_virtual_network.go | 59 +++-- .../resource_arm_virtual_network_peering.go | 34 ++- ...source_arm_virtual_network_peering_test.go | 23 +- azurerm/resource_arm_virtual_network_test.go | 47 ++-- 45 files changed, 1033 insertions(+), 735 deletions(-) diff --git a/azurerm/config.go b/azurerm/config.go index 85140cc55716..e11c3941b341 100644 --- a/azurerm/config.go +++ b/azurerm/config.go @@ -18,7 +18,6 @@ import ( "github.com/Azure/azure-sdk-for-go/arm/disk" "github.com/Azure/azure-sdk-for-go/arm/dns" "github.com/Azure/azure-sdk-for-go/arm/keyvault" - "github.com/Azure/azure-sdk-for-go/arm/network" "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" @@ -31,6 +30,7 @@ import ( "github.com/Azure/azure-sdk-for-go/services/eventhub/mgmt/2017-04-01/eventhub" "github.com/Azure/azure-sdk-for-go/services/graphrbac/1.6/graphrbac" "github.com/Azure/azure-sdk-for-go/services/mysql/mgmt/2017-04-30-preview/mysql" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2016-06-01/subscriptions" "github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2016-09-01/locks" "github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2017-05-10/resources" @@ -78,24 +78,8 @@ type ArmClient struct { automationCredentialClient automation.CredentialClient automationScheduleClient automation.ScheduleClient - applicationGatewayClient network.ApplicationGatewaysClient - ifaceClient network.InterfacesClient - expressRouteCircuitClient network.ExpressRouteCircuitsClient - loadBalancerClient network.LoadBalancersClient - localNetConnClient network.LocalNetworkGatewaysClient - publicIPClient network.PublicIPAddressesClient - secGroupClient network.SecurityGroupsClient - secRuleClient network.SecurityRulesClient - subnetClient network.SubnetsClient - netUsageClient network.UsagesClient - vnetGatewayConnectionsClient network.VirtualNetworkGatewayConnectionsClient - vnetGatewayClient network.VirtualNetworkGatewaysClient - vnetClient network.VirtualNetworksClient - vnetPeeringsClient network.VirtualNetworkPeeringsClient - routeTablesClient network.RouteTablesClient - routesClient network.RoutesClient - dnsClient dns.RecordSetsClient - zonesClient dns.ZonesClient + dnsClient dns.RecordSetsClient + zonesClient dns.ZonesClient containerRegistryClient containerregistry.RegistriesClient containerServicesClient containerservice.ContainerServicesClient @@ -142,7 +126,23 @@ type ArmClient struct { sqlServersClient sql.ServersClient // Networking - watcherClient network.WatchersClient + applicationGatewayClient network.ApplicationGatewaysClient + expressRouteCircuitClient network.ExpressRouteCircuitsClient + ifaceClient network.InterfacesClient + loadBalancerClient network.LoadBalancersClient + localNetConnClient network.LocalNetworkGatewaysClient + publicIPClient network.PublicIPAddressesClient + routesClient network.RoutesClient + routeTablesClient network.RouteTablesClient + secGroupClient network.SecurityGroupsClient + secRuleClient network.SecurityRulesClient + subnetClient network.SubnetsClient + netUsageClient network.UsagesClient + vnetGatewayConnectionsClient network.VirtualNetworkGatewayConnectionsClient + vnetGatewayClient network.VirtualNetworkGatewaysClient + vnetClient network.VirtualNetworksClient + vnetPeeringsClient network.VirtualNetworkPeeringsClient + watcherClient network.WatchersClient // Resources managementLocksClient locks.ManagementLocksClient @@ -367,13 +367,6 @@ func getArmClient(c *authentication.Config) (*ArmClient, error) { vmc.SkipResourceProviderRegistration = c.SkipProviderRegistration client.vmClient = vmc - agc := network.NewApplicationGatewaysClientWithBaseURI(endpoint, c.SubscriptionID) - setUserAgent(&agc.Client) - agc.Authorizer = auth - agc.Sender = sender - agc.SkipResourceProviderRegistration = c.SkipProviderRegistration - client.applicationGatewayClient = agc - crc := containerregistry.NewRegistriesClientWithBaseURI(endpoint, c.SubscriptionID) setUserAgent(&crc.Client) crc.Authorizer = auth @@ -402,34 +395,6 @@ func getArmClient(c *authentication.Config) (*ArmClient, error) { img.SkipResourceProviderRegistration = c.SkipProviderRegistration client.imageClient = img - ifc := network.NewInterfacesClientWithBaseURI(endpoint, c.SubscriptionID) - setUserAgent(&ifc.Client) - ifc.Authorizer = auth - ifc.Sender = sender - ifc.SkipResourceProviderRegistration = c.SkipProviderRegistration - client.ifaceClient = ifc - - erc := network.NewExpressRouteCircuitsClientWithBaseURI(endpoint, c.SubscriptionID) - setUserAgent(&erc.Client) - erc.Authorizer = auth - erc.Sender = sender - erc.SkipResourceProviderRegistration = c.SkipProviderRegistration - client.expressRouteCircuitClient = erc - - lbc := network.NewLoadBalancersClientWithBaseURI(endpoint, c.SubscriptionID) - setUserAgent(&lbc.Client) - lbc.Authorizer = auth - lbc.Sender = sender - lbc.SkipResourceProviderRegistration = c.SkipProviderRegistration - client.loadBalancerClient = lbc - - lgc := network.NewLocalNetworkGatewaysClientWithBaseURI(endpoint, c.SubscriptionID) - setUserAgent(&lgc.Client) - lgc.Authorizer = auth - lgc.Sender = sender - lgc.SkipResourceProviderRegistration = c.SkipProviderRegistration - client.localNetConnClient = lgc - opwc := operationalinsights.NewWorkspacesClient(c.SubscriptionID) setUserAgent(&opwc.Client) opwc.Authorizer = auth @@ -437,76 +402,6 @@ func getArmClient(c *authentication.Config) (*ArmClient, error) { opwc.SkipResourceProviderRegistration = c.SkipProviderRegistration client.workspacesClient = opwc - pipc := network.NewPublicIPAddressesClientWithBaseURI(endpoint, c.SubscriptionID) - setUserAgent(&pipc.Client) - pipc.Authorizer = auth - pipc.Sender = sender - pipc.SkipResourceProviderRegistration = c.SkipProviderRegistration - client.publicIPClient = pipc - - sgc := network.NewSecurityGroupsClientWithBaseURI(endpoint, c.SubscriptionID) - setUserAgent(&sgc.Client) - sgc.Authorizer = auth - sgc.Sender = sender - sgc.SkipResourceProviderRegistration = c.SkipProviderRegistration - client.secGroupClient = sgc - - src := network.NewSecurityRulesClientWithBaseURI(endpoint, c.SubscriptionID) - setUserAgent(&src.Client) - src.Authorizer = auth - src.Sender = sender - src.SkipResourceProviderRegistration = c.SkipProviderRegistration - client.secRuleClient = src - - snc := network.NewSubnetsClientWithBaseURI(endpoint, c.SubscriptionID) - setUserAgent(&snc.Client) - snc.Authorizer = auth - snc.Sender = sender - snc.SkipResourceProviderRegistration = c.SkipProviderRegistration - client.subnetClient = snc - - vgcc := network.NewVirtualNetworkGatewayConnectionsClientWithBaseURI(endpoint, c.SubscriptionID) - setUserAgent(&vgcc.Client) - vgcc.Authorizer = auth - vgcc.Sender = sender - vgcc.SkipResourceProviderRegistration = c.SkipProviderRegistration - client.vnetGatewayConnectionsClient = vgcc - - vgc := network.NewVirtualNetworkGatewaysClientWithBaseURI(endpoint, c.SubscriptionID) - setUserAgent(&vgc.Client) - vgc.Authorizer = auth - vgc.Sender = sender - vgc.SkipResourceProviderRegistration = c.SkipProviderRegistration - client.vnetGatewayClient = vgc - - vnc := network.NewVirtualNetworksClientWithBaseURI(endpoint, c.SubscriptionID) - setUserAgent(&vnc.Client) - vnc.Authorizer = auth - vnc.Sender = sender - vnc.SkipResourceProviderRegistration = c.SkipProviderRegistration - client.vnetClient = vnc - - vnpc := network.NewVirtualNetworkPeeringsClientWithBaseURI(endpoint, c.SubscriptionID) - setUserAgent(&vnpc.Client) - vnpc.Authorizer = auth - vnpc.Sender = sender - vnpc.SkipResourceProviderRegistration = c.SkipProviderRegistration - client.vnetPeeringsClient = vnpc - - rtc := network.NewRouteTablesClientWithBaseURI(endpoint, c.SubscriptionID) - setUserAgent(&rtc.Client) - rtc.Authorizer = auth - rtc.Sender = sender - rtc.SkipResourceProviderRegistration = c.SkipProviderRegistration - client.routeTablesClient = rtc - - rc := network.NewRoutesClientWithBaseURI(endpoint, c.SubscriptionID) - setUserAgent(&rc.Client) - rc.Authorizer = auth - rc.Sender = sender - rc.SkipResourceProviderRegistration = c.SkipProviderRegistration - client.routesClient = rc - dn := dns.NewRecordSetsClientWithBaseURI(endpoint, c.SubscriptionID) setUserAgent(&dn.Client) dn.Authorizer = auth @@ -781,12 +676,68 @@ func (c *ArmClient) registerKeyVaultClients(endpoint, subscriptionId string, aut } func (c *ArmClient) registerNetworkingClients(endpoint, subscriptionId string, auth autorest.Authorizer, sender autorest.Sender) { - // TODO: move the other networking stuff in here, gradually + applicationGatewaysClient := network.NewApplicationGatewaysClientWithBaseURI(endpoint, subscriptionId) + c.configureClient(&applicationGatewaysClient.Client, auth) + c.applicationGatewayClient = applicationGatewaysClient + + expressRouteCircuitsClient := network.NewExpressRouteCircuitsClientWithBaseURI(endpoint, subscriptionId) + c.configureClient(&expressRouteCircuitsClient.Client, auth) + c.expressRouteCircuitClient = expressRouteCircuitsClient + + interfacesClient := network.NewInterfacesClientWithBaseURI(endpoint, subscriptionId) + c.configureClient(&interfacesClient.Client, auth) + c.ifaceClient = interfacesClient + + loadBalancersClient := network.NewLoadBalancersClientWithBaseURI(endpoint, subscriptionId) + c.configureClient(&loadBalancersClient.Client, auth) + c.loadBalancerClient = loadBalancersClient + + localNetworkGatewaysClient := network.NewLocalNetworkGatewaysClientWithBaseURI(endpoint, subscriptionId) + c.configureClient(&localNetworkGatewaysClient.Client, auth) + c.localNetConnClient = localNetworkGatewaysClient + + gatewaysClient := network.NewVirtualNetworkGatewaysClientWithBaseURI(endpoint, subscriptionId) + c.configureClient(&gatewaysClient.Client, auth) + c.vnetGatewayClient = gatewaysClient + + gatewayConnectionsClient := network.NewVirtualNetworkGatewayConnectionsClientWithBaseURI(endpoint, subscriptionId) + c.configureClient(&gatewayConnectionsClient.Client, auth) + c.vnetGatewayConnectionsClient = gatewayConnectionsClient + + networksClient := network.NewVirtualNetworksClientWithBaseURI(endpoint, subscriptionId) + c.configureClient(&networksClient.Client, auth) + c.vnetClient = networksClient + + peeringsClient := network.NewVirtualNetworkPeeringsClientWithBaseURI(endpoint, subscriptionId) + c.configureClient(&peeringsClient.Client, auth) + c.vnetPeeringsClient = peeringsClient + + publicIPAddressesClient := network.NewPublicIPAddressesClientWithBaseURI(endpoint, subscriptionId) + c.configureClient(&publicIPAddressesClient.Client, auth) + c.publicIPClient = publicIPAddressesClient + + routesClient := network.NewRoutesClientWithBaseURI(endpoint, subscriptionId) + c.configureClient(&routesClient.Client, auth) + c.routesClient = routesClient + + routeTablesClient := network.NewRouteTablesClientWithBaseURI(endpoint, subscriptionId) + c.configureClient(&routeTablesClient.Client, auth) + c.routeTablesClient = routeTablesClient + + securityGroupsClient := network.NewSecurityGroupsClientWithBaseURI(endpoint, subscriptionId) + c.configureClient(&securityGroupsClient.Client, auth) + c.secGroupClient = securityGroupsClient + + securityRulesClient := network.NewSecurityRulesClientWithBaseURI(endpoint, subscriptionId) + c.configureClient(&securityRulesClient.Client, auth) + c.secRuleClient = securityRulesClient + + subnetsClient := network.NewSubnetsClientWithBaseURI(endpoint, subscriptionId) + c.configureClient(&subnetsClient.Client, auth) + c.subnetClient = subnetsClient + watchersClient := network.NewWatchersClientWithBaseURI(endpoint, subscriptionId) - setUserAgent(&watchersClient.Client) - watchersClient.Authorizer = auth - watchersClient.Sender = sender - watchersClient.SkipResourceProviderRegistration = c.skipProviderRegistration + c.configureClient(&watchersClient.Client, auth) c.watcherClient = watchersClient } diff --git a/azurerm/data_source_network_security_group.go b/azurerm/data_source_network_security_group.go index f3681a837b61..9c981f511802 100644 --- a/azurerm/data_source_network_security_group.go +++ b/azurerm/data_source_network_security_group.go @@ -85,11 +85,12 @@ func dataSourceArmNetworkSecurityGroup() *schema.Resource { func dataSourceArmNetworkSecurityGroupRead(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).secGroupClient + ctx := meta.(*ArmClient).StopContext resourceGroup := d.Get("resource_group_name").(string) name := d.Get("name").(string) - resp, err := client.Get(resourceGroup, name, "") + resp, err := client.Get(ctx, resourceGroup, name, "") if err != nil { if utils.ResponseWasNotFound(resp.Response) { d.SetId("") diff --git a/azurerm/data_source_public_ip.go b/azurerm/data_source_public_ip.go index a156c9e42d16..6553c671de40 100644 --- a/azurerm/data_source_public_ip.go +++ b/azurerm/data_source_public_ip.go @@ -2,9 +2,9 @@ package azurerm import ( "fmt" - "net/http" "github.com/hashicorp/terraform/helper/schema" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" ) func dataSourceArmPublicIP() *schema.Resource { @@ -44,14 +44,15 @@ func dataSourceArmPublicIP() *schema.Resource { } func dataSourceArmPublicIPRead(d *schema.ResourceData, meta interface{}) error { - publicIPClient := meta.(*ArmClient).publicIPClient + client := meta.(*ArmClient).publicIPClient + ctx := meta.(*ArmClient).StopContext resGroup := d.Get("resource_group_name").(string) name := d.Get("name").(string) - resp, err := publicIPClient.Get(resGroup, name, "") + resp, err := client.Get(ctx, resGroup, name, "") if err != nil { - if resp.StatusCode == http.StatusNotFound { + if utils.ResponseWasNotFound(resp.Response) { d.SetId("") } return fmt.Errorf("Error making Read request on Azure public ip %s: %s", name, err) diff --git a/azurerm/data_source_subnet.go b/azurerm/data_source_subnet.go index 2a8d7c3e740b..042e702ffa25 100644 --- a/azurerm/data_source_subnet.go +++ b/azurerm/data_source_subnet.go @@ -53,12 +53,13 @@ func dataSourceArmSubnet() *schema.Resource { func dataSourceArmSubnetRead(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).subnetClient + ctx := meta.(*ArmClient).StopContext name := d.Get("name").(string) virtualNetworkName := d.Get("virtual_network_name").(string) resourceGroupName := d.Get("resource_group_name").(string) - resp, err := client.Get(resourceGroupName, virtualNetworkName, name, "") + resp, err := client.Get(ctx, resourceGroupName, virtualNetworkName, name, "") if err != nil { return fmt.Errorf("Error reading Subnet: %+v", err) } diff --git a/azurerm/data_source_virtual_network.go b/azurerm/data_source_virtual_network.go index f8084f51b985..ca8338cf1a86 100644 --- a/azurerm/data_source_virtual_network.go +++ b/azurerm/data_source_virtual_network.go @@ -3,7 +3,7 @@ package azurerm import ( "fmt" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/terraform/helper/schema" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" ) @@ -56,11 +56,12 @@ func dataSourceArmVirtualNetwork() *schema.Resource { func dataSourceArmVnetRead(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).vnetClient + ctx := meta.(*ArmClient).StopContext resGroup := d.Get("resource_group_name").(string) name := d.Get("name").(string) - resp, err := client.Get(resGroup, name, "") + resp, err := client.Get(ctx, resGroup, name, "") if err != nil { if utils.ResponseWasNotFound(resp.Response) { return fmt.Errorf("Error making Read request on Azure virtual network %q (resource group %q): %+v", name, resGroup, err) diff --git a/azurerm/express_route_circuit.go b/azurerm/express_route_circuit.go index 5ceaef8107cc..b383f15e72cf 100644 --- a/azurerm/express_route_circuit.go +++ b/azurerm/express_route_circuit.go @@ -3,7 +3,7 @@ package azurerm import ( "fmt" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/errwrap" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" ) @@ -22,13 +22,14 @@ func extractResourceGroupAndErcName(resourceId string) (resourceGroup string, na func retrieveErcByResourceId(resourceId string, meta interface{}) (erc *network.ExpressRouteCircuit, resourceGroup string, e error) { ercClient := meta.(*ArmClient).expressRouteCircuitClient + ctx := meta.(*ArmClient).StopContext resGroup, name, err := extractResourceGroupAndErcName(resourceId) if err != nil { return nil, "", errwrap.Wrapf("Error Parsing Azure Resource ID - {{err}}", err) } - resp, err := ercClient.Get(resGroup, name) + resp, err := ercClient.Get(ctx, resGroup, name) if err != nil { if utils.ResponseWasNotFound(resp.Response) { return nil, "", nil diff --git a/azurerm/loadbalancer.go b/azurerm/loadbalancer.go index ac3af979aaf8..ed2e8e48d9ef 100644 --- a/azurerm/loadbalancer.go +++ b/azurerm/loadbalancer.go @@ -1,12 +1,13 @@ package azurerm import ( + "context" "fmt" "net/http" "regexp" "strings" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/errwrap" "github.com/hashicorp/terraform/helper/resource" "github.com/hashicorp/terraform/helper/schema" @@ -24,14 +25,15 @@ func resourceGroupAndLBNameFromId(loadBalancerId string) (string, string, error) } func retrieveLoadBalancerById(loadBalancerId string, meta interface{}) (*network.LoadBalancer, bool, error) { - loadBalancerClient := meta.(*ArmClient).loadBalancerClient + client := meta.(*ArmClient).loadBalancerClient + ctx := meta.(*ArmClient).StopContext resGroup, name, err := resourceGroupAndLBNameFromId(loadBalancerId) if err != nil { return nil, false, errwrap.Wrapf("Error Getting LoadBalancer Name and Group: {{err}}", err) } - resp, err := loadBalancerClient.Get(resGroup, name, "") + resp, err := client.Get(ctx, resGroup, name, "") if err != nil { if resp.StatusCode == http.StatusNotFound { return nil, false, nil @@ -126,9 +128,9 @@ func findLoadBalancerProbeByName(lb *network.LoadBalancer, name string) (*networ return nil, -1, false } -func loadbalancerStateRefreshFunc(client *ArmClient, resourceGroupName string, loadbalancer string) resource.StateRefreshFunc { +func loadbalancerStateRefreshFunc(ctx context.Context, client network.LoadBalancersClient, resourceGroupName string, loadbalancer string) resource.StateRefreshFunc { return func() (interface{}, string, error) { - res, err := client.loadBalancerClient.Get(resourceGroupName, loadbalancer, "") + res, err := client.Get(ctx, resourceGroupName, loadbalancer, "") if err != nil { return nil, "", fmt.Errorf("Error issuing read request in loadbalancerStateRefreshFunc to Azure ARM for LoadBalancer '%s' (RG: '%s'): %s", loadbalancer, resourceGroupName, err) } diff --git a/azurerm/resource_arm_application_gateway.go b/azurerm/resource_arm_application_gateway.go index 6b564ae8efa3..021c2993754e 100644 --- a/azurerm/resource_arm_application_gateway.go +++ b/azurerm/resource_arm_application_gateway.go @@ -5,9 +5,8 @@ import ( "fmt" "log" "strings" - // "time" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/errwrap" "github.com/hashicorp/terraform/helper/hashcode" "github.com/hashicorp/terraform/helper/schema" @@ -682,6 +681,7 @@ func resourceArmApplicationGateway() *schema.Resource { func resourceArmApplicationGatewayCreateUpdate(d *schema.ResourceData, meta interface{}) error { armClient := meta.(*ArmClient) client := armClient.applicationGatewayClient + ctx := armClient.StopContext log.Printf("[INFO] preparing arguments for AzureRM ApplicationGateway creation.") @@ -721,15 +721,19 @@ func resourceArmApplicationGatewayCreateUpdate(d *schema.ResourceData, meta inte ApplicationGatewayPropertiesFormat: &properties, } - _, errChan := client.CreateOrUpdate(resGroup, name, gateway, make(chan struct{})) - err := <-errChan + future, err := client.CreateOrUpdate(ctx, resGroup, name, gateway) if err != nil { - return errwrap.Wrapf("Error Creating/Updating ApplicationGateway {{err}}", err) + return fmt.Errorf("Error Creating/Updating ApplicationGateway %q (Resource Group %q): %+v", name, resGroup, err) } - read, err := client.Get(resGroup, name) + err = future.WaitForCompletion(ctx, client.Client) if err != nil { - return errwrap.Wrapf("Error Getting ApplicationGateway {{err}}", err) + return fmt.Errorf("Error Creating/Updating ApplicationGateway %q (Resource Group %q): %+v", name, resGroup, err) + } + + read, err := client.Get(ctx, resGroup, name) + if err != nil { + return fmt.Errorf("Error retrieving ApplicationGateway %q (Resource Group %q): %+v", name, resGroup, err) } if read.ID == nil { return fmt.Errorf("Cannot read ApplicationGateway %s (resource group %s) ID", name, resGroup) @@ -807,6 +811,7 @@ func resourceArmApplicationGatewayRead(d *schema.ResourceData, meta interface{}) func resourceArmApplicationGatewayDelete(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).applicationGatewayClient + ctx := meta.(*ArmClient).StopContext id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -815,10 +820,14 @@ func resourceArmApplicationGatewayDelete(d *schema.ResourceData, meta interface{ resGroup := id.ResourceGroup name := id.Path["applicationGateways"] - _, errChan := client.Delete(resGroup, name, make(chan struct{})) - err = <-errChan + future, err := client.Delete(ctx, resGroup, name) + if err != nil { + return fmt.Errorf("Error deleting for AppGateway %q (Resource Group %q): %+v", name, resGroup, err) + } + + err = future.WaitForCompletion(ctx, client.Client) if err != nil { - return errwrap.Wrapf("Error Deleting ApplicationGateway {{err}}", err) + return fmt.Errorf("Error waiting for deletion of AppGateway %q (Resource Group %q): %+v", name, resGroup, err) } d.SetId("") @@ -836,15 +845,16 @@ func ApplicationGatewayResGroupAndNameFromID(ApplicationGatewayID string) (strin return resGroup, name, nil } -func retrieveApplicationGatewayById(ApplicationGatewayID string, meta interface{}) (*network.ApplicationGateway, bool, error) { +func retrieveApplicationGatewayById(applicationGatewayID string, meta interface{}) (*network.ApplicationGateway, bool, error) { client := meta.(*ArmClient).applicationGatewayClient + ctx := meta.(*ArmClient).StopContext - resGroup, name, err := ApplicationGatewayResGroupAndNameFromID(ApplicationGatewayID) + resGroup, name, err := ApplicationGatewayResGroupAndNameFromID(applicationGatewayID) if err != nil { return nil, false, errwrap.Wrapf("Error Getting ApplicationGateway Name and Group: {{err}}", err) } - resp, err := client.Get(resGroup, name) + resp, err := client.Get(ctx, resGroup, name) if err != nil { if utils.ResponseWasNotFound(resp.Response) { return nil, false, nil diff --git a/azurerm/resource_arm_application_gateway_test.go b/azurerm/resource_arm_application_gateway_test.go index 6abdd2ca038d..4936723b8286 100644 --- a/azurerm/resource_arm_application_gateway_test.go +++ b/azurerm/resource_arm_application_gateway_test.go @@ -10,6 +10,7 @@ import ( "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/helpers/response" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" ) @@ -27,20 +28,21 @@ func testSweepApplicationGateways(region string) error { } client := (*armClient).applicationGatewayClient + ctx := (*armClient).StopContext log.Printf("Retrieving the Application Gateways..") - results, err := client.ListAll() + results, err := client.ListAll(ctx) if err != nil { return fmt.Errorf("Error Listing on Application Gateways: %+v", err) } - for _, network := range *results.Value { + for _, network := range results.Values() { id, err := parseAzureResourceID(*network.ID) if err != nil { return fmt.Errorf("Error parsing Azure Resource ID %q", id) } - resourceGroupName := id.ResourceGroup + resourceGroup := id.ResourceGroup name := *network.Name location := *network.Location @@ -48,12 +50,19 @@ func testSweepApplicationGateways(region string) error { continue } - log.Printf("Deleting Application Gateway %q", name) - deleteResponse, deleteErr := client.Delete(resourceGroupName, name, make(chan struct{})) - resp := <-deleteResponse - err = <-deleteErr + log.Printf("Deleting Application Gateway %q (Resource Group %q)", name, resourceGroup) + future, err := client.Delete(ctx, resourceGroup, name) if err != nil { - if utils.ResponseWasNotFound(resp) { + if response.WasNotFound(future.Response()) { + continue + } + + return err + } + + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + if response.WasNotFound(future.Response()) { continue } @@ -203,8 +212,9 @@ func testCheckAzureRMApplicationGatewayExists(name string) resource.TestCheckFun } conn := testAccProvider.Meta().(*ArmClient).applicationGatewayClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext - resp, err := conn.Get(resourceGroup, ApplicationGatewayName) + resp, err := conn.Get(ctx, resourceGroup, ApplicationGatewayName) if err != nil { if utils.ResponseWasNotFound(resp.Response) { return fmt.Errorf("Bad: App Gateway %q (resource group: %q) does not exist", ApplicationGatewayName, resourceGroup) @@ -224,18 +234,19 @@ func testCheckAzureRMApplicationGatewaySslCertificateAssigned(name string, certN return fmt.Errorf("Not found: %s", name) } - ApplicationGatewayName := rs.Primary.Attributes["name"] + gatewayName := 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 App Gateway: %q", ApplicationGatewayName) + return fmt.Errorf("Bad: no resource group found in state for App Gateway: %q", gatewayName) } conn := testAccProvider.Meta().(*ArmClient).applicationGatewayClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext - resp, err := conn.Get(resourceGroup, ApplicationGatewayName) + resp, err := conn.Get(ctx, resourceGroup, gatewayName) if err != nil { if utils.ResponseWasNotFound(resp.Response) { - return fmt.Errorf("Bad: App Gateway %q (resource group: %q) does not exist", ApplicationGatewayName, resourceGroup) + return fmt.Errorf("Bad: App Gateway %q (resource group: %q) does not exist", gatewayName, resourceGroup) } return fmt.Errorf("Bad: Get on ApplicationGatewayClient: %+v", err) @@ -270,18 +281,19 @@ func testCheckAzureRMApplicationGatewayAuthenticationCertificateAssigned(name st return fmt.Errorf("Not found: %s", name) } - ApplicationGatewayName := rs.Primary.Attributes["name"] + gatewayName := 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 App Gateway: %q", ApplicationGatewayName) + return fmt.Errorf("Bad: no resource group found in state for App Gateway: %q", gatewayName) } conn := testAccProvider.Meta().(*ArmClient).applicationGatewayClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext - resp, err := conn.Get(resourceGroup, ApplicationGatewayName) + resp, err := conn.Get(ctx, resourceGroup, gatewayName) if err != nil { if utils.ResponseWasNotFound(resp.Response) { - return fmt.Errorf("Bad: App Gateway %q (resource group: %q) does not exist", ApplicationGatewayName, resourceGroup) + return fmt.Errorf("Bad: App Gateway %q (resource group: %q) does not exist", gatewayName, resourceGroup) } return fmt.Errorf("Bad: Get on ApplicationGatewayClient: %+v", err) @@ -315,6 +327,7 @@ func testCheckAzureRMApplicationGatewayAuthenticationCertificateAssigned(name st func testCheckAzureRMApplicationGatewayDestroy(s *terraform.State) error { conn := testAccProvider.Meta().(*ArmClient).applicationGatewayClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext for _, rs := range s.RootModule().Resources { if rs.Type != "azurerm_application_gateway" { @@ -324,7 +337,7 @@ func testCheckAzureRMApplicationGatewayDestroy(s *terraform.State) error { name := rs.Primary.Attributes["name"] resourceGroup := rs.Primary.Attributes["resource_group_name"] - resp, err := conn.Get(resourceGroup, name) + resp, err := conn.Get(ctx, resourceGroup, name) if err != nil { if utils.ResponseWasNotFound(resp.Response) { diff --git a/azurerm/resource_arm_express_route_circuit.go b/azurerm/resource_arm_express_route_circuit.go index 824217deeb69..12728164fad2 100644 --- a/azurerm/resource_arm_express_route_circuit.go +++ b/azurerm/resource_arm_express_route_circuit.go @@ -2,13 +2,11 @@ package azurerm import ( "bytes" + "fmt" "log" "strings" - "fmt" - - "github.com/Azure/azure-sdk-for-go/arm/network" - "github.com/hashicorp/errwrap" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/terraform/helper/hashcode" "github.com/hashicorp/terraform/helper/schema" "github.com/hashicorp/terraform/helper/validation" @@ -107,8 +105,8 @@ func resourceArmExpressRouteCircuit() *schema.Resource { } func resourceArmExpressRouteCircuitCreateOrUpdate(d *schema.ResourceData, meta interface{}) error { - client := meta.(*ArmClient) - ercClient := client.expressRouteCircuitClient + client := meta.(*ArmClient).expressRouteCircuitClient + ctx := meta.(*ArmClient).StopContext log.Printf("[INFO] preparing arguments for Azure ARM ExpressRouteCircuit creation.") @@ -138,18 +136,22 @@ func resourceArmExpressRouteCircuitCreateOrUpdate(d *schema.ResourceData, meta i Tags: expandedTags, } - _, error := ercClient.CreateOrUpdate(resGroup, name, erc, make(chan struct{})) - err := <-error + future, err := client.CreateOrUpdate(ctx, resGroup, name, erc) + if err != nil { + return fmt.Errorf("Error Creating/Updating ExpressRouteCircuit %q (Resource Group %q): %+v", name, resGroup, err) + } + + err = future.WaitForCompletion(ctx, client.Client) if err != nil { - return errwrap.Wrapf("Error Creating/Updating ExpressRouteCircuit {{err}}", err) + return fmt.Errorf("Error Creating/Updating ExpressRouteCircuit %q (Resource Group %q): %+v", name, resGroup, err) } - read, err := ercClient.Get(resGroup, name) + read, err := client.Get(ctx, resGroup, name) if err != nil { - return errwrap.Wrapf("Error Getting ExpressRouteCircuit {{err}}", err) + return fmt.Errorf("Error Retrieving ExpressRouteCircuit %q (Resource Group %q): %+v", name, resGroup, err) } if read.ID == nil { - return fmt.Errorf("Cannot read ExpressRouteCircuit %s (resource group %s) ID", name, resGroup) + return fmt.Errorf("Cannot read ExpressRouteCircuit %q (resource group %q) ID", name, resGroup) } d.SetId(*read.ID) @@ -193,16 +195,25 @@ func resourceArmExpressRouteCircuitRead(d *schema.ResourceData, meta interface{} } func resourceArmExpressRouteCircuitDelete(d *schema.ResourceData, meta interface{}) error { - ercClient := meta.(*ArmClient).expressRouteCircuitClient + client := meta.(*ArmClient).expressRouteCircuitClient + ctx := meta.(*ArmClient).StopContext - resGroup, name, err := extractResourceGroupAndErcName(d.Id()) + resourceGroup, name, err := extractResourceGroupAndErcName(d.Id()) if err != nil { - return errwrap.Wrapf("Error Parsing Azure Resource ID {{err}}", err) + return fmt.Errorf("Error Parsing Azure Resource ID: %+v", err) } - _, error := ercClient.Delete(resGroup, name, make(chan struct{})) - err = <-error - return err + future, err := client.Delete(ctx, resourceGroup, name) + if err != nil { + return err + } + + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return err + } + + return nil } func expandExpressRouteCircuitSku(d *schema.ResourceData) *network.ExpressRouteCircuitSku { diff --git a/azurerm/resource_arm_express_route_circuit_test.go b/azurerm/resource_arm_express_route_circuit_test.go index 67d588a5ae7a..87593f4ce19c 100644 --- a/azurerm/resource_arm_express_route_circuit_test.go +++ b/azurerm/resource_arm_express_route_circuit_test.go @@ -5,10 +5,11 @@ import ( "net/http" "testing" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "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 TestAccAzureRMExpressRouteCircuit_basic(t *testing.T) { @@ -43,11 +44,12 @@ func testCheckAzureRMExpressRouteCircuitExists(name string, erc *network.Express return fmt.Errorf("Bad: no resource group found in state for Express Route Circuit: %s", expressRouteCircuitName) } - conn := testAccProvider.Meta().(*ArmClient).expressRouteCircuitClient + client := testAccProvider.Meta().(*ArmClient).expressRouteCircuitClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext - resp, err := conn.Get(resourceGroup, expressRouteCircuitName) + resp, err := client.Get(ctx, resourceGroup, expressRouteCircuitName) if err != nil { - if resp.StatusCode == http.StatusNotFound { + if utils.ResponseWasNotFound(resp.Response) { return fmt.Errorf("Bad: Express Route Circuit %q (resource group: %q) does not exist", expressRouteCircuitName, resourceGroup) } @@ -61,7 +63,8 @@ func testCheckAzureRMExpressRouteCircuitExists(name string, erc *network.Express } func testCheckAzureRMExpressRouteCircuitDestroy(s *terraform.State) error { - conn := testAccProvider.Meta().(*ArmClient).expressRouteCircuitClient + client := testAccProvider.Meta().(*ArmClient).expressRouteCircuitClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext for _, rs := range s.RootModule().Resources { if rs.Type != "azurerm_express_route_circuit" { @@ -71,7 +74,7 @@ func testCheckAzureRMExpressRouteCircuitDestroy(s *terraform.State) error { name := rs.Primary.Attributes["name"] resourceGroup := rs.Primary.Attributes["resource_group_name"] - resp, err := conn.Get(resourceGroup, name) + resp, err := client.Get(ctx, resourceGroup, name) if err != nil { return nil diff --git a/azurerm/resource_arm_loadbalancer.go b/azurerm/resource_arm_loadbalancer.go index 5a7037c81b97..74e43829424a 100644 --- a/azurerm/resource_arm_loadbalancer.go +++ b/azurerm/resource_arm_loadbalancer.go @@ -5,7 +5,7 @@ import ( "log" "time" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/errwrap" "github.com/hashicorp/terraform/helper/resource" "github.com/hashicorp/terraform/helper/schema" @@ -106,8 +106,8 @@ func resourceArmLoadBalancer() *schema.Resource { } func resourceArmLoadBalancerCreate(d *schema.ResourceData, meta interface{}) error { - client := meta.(*ArmClient) - loadBalancerClient := client.loadBalancerClient + client := meta.(*ArmClient).loadBalancerClient + ctx := meta.(*ArmClient).StopContext log.Printf("[INFO] preparing arguments for Azure ARM LoadBalancer creation.") @@ -123,38 +123,43 @@ func resourceArmLoadBalancerCreate(d *schema.ResourceData, meta interface{}) err properties.FrontendIPConfigurations = expandAzureRmLoadBalancerFrontendIpConfigurations(d) } - loadbalancer := network.LoadBalancer{ + loadBalancer := network.LoadBalancer{ Name: utils.String(name), Location: utils.String(location), Tags: expandedTags, LoadBalancerPropertiesFormat: &properties, } - _, error := loadBalancerClient.CreateOrUpdate(resGroup, name, loadbalancer, make(chan struct{})) - err := <-error + future, err := client.CreateOrUpdate(ctx, resGroup, name, loadBalancer) if err != nil { - return errwrap.Wrapf("Error Creating/Updating LoadBalancer {{err}}", err) + return fmt.Errorf("Error Creating/Updating LoadBalancer %q (Resource Group %q): %+v", name, resGroup, err) } - read, err := loadBalancerClient.Get(resGroup, name, "") + err = future.WaitForCompletion(ctx, client.Client) if err != nil { - return errwrap.Wrapf("Error Getting LoadBalancer {{err}", err) + return fmt.Errorf("Error Creating/Updating LoadBalancer %q (Resource Group %q): %+v", name, resGroup, err) + } + + read, err := client.Get(ctx, resGroup, name, "") + if err != nil { + return fmt.Errorf("Error Retrieving LoadBalancer %q (Resource Group %q): %+v", name, resGroup, err) } if read.ID == nil { - return fmt.Errorf("Cannot read LoadBalancer %s (resource group %s) ID", name, resGroup) + return fmt.Errorf("Cannot read LoadBalancer %q (resource group %q) ID", name, resGroup) } d.SetId(*read.ID) - log.Printf("[DEBUG] Waiting for LoadBalancer (%s) to become available", name) + // TODO: is this still needed? + log.Printf("[DEBUG] Waiting for LoadBalancer (%q) to become available", name) stateConf := &resource.StateChangeConf{ Pending: []string{"Accepted", "Updating"}, Target: []string{"Succeeded"}, - Refresh: loadbalancerStateRefreshFunc(client, resGroup, name), + Refresh: loadbalancerStateRefreshFunc(ctx, client, resGroup, name), Timeout: 10 * time.Minute, } if _, err := stateConf.WaitForState(); err != nil { - return fmt.Errorf("Error waiting for LoadBalancer (%s) to become available: %s", name, err) + return fmt.Errorf("Error waiting for LoadBalancer (%q - Resource Group %q) to become available: %s", name, resGroup, err) } return resourecArmLoadBalancerRead(d, meta) @@ -168,36 +173,40 @@ func resourecArmLoadBalancerRead(d *schema.ResourceData, meta interface{}) error loadBalancer, exists, err := retrieveLoadBalancerById(d.Id(), meta) if err != nil { - return errwrap.Wrapf("Error Getting LoadBalancer By ID {{err}}", err) + return fmt.Errorf("Error retrieving Load Balancer by ID %q: %+v", d.Id(), err) } if !exists { d.SetId("") - log.Printf("[INFO] LoadBalancer %q not found. Removing from state", d.Get("name").(string)) + log.Printf("[INFO] LoadBalancer %q not found. Removing from state", d.Id()) return nil } d.Set("name", loadBalancer.Name) - d.Set("location", azureRMNormalizeLocation(*loadBalancer.Location)) d.Set("resource_group_name", id.ResourceGroup) - if loadBalancer.LoadBalancerPropertiesFormat != nil && loadBalancer.LoadBalancerPropertiesFormat.FrontendIPConfigurations != nil { - ipconfigs := loadBalancer.LoadBalancerPropertiesFormat.FrontendIPConfigurations - d.Set("frontend_ip_configuration", flattenLoadBalancerFrontendIpConfiguration(ipconfigs)) + if location := loadBalancer.Location; location != nil { + d.Set("location", azureRMNormalizeLocation(*location)) + } - privateIpAddress := "" - privateIpAddresses := make([]string, 0, len(*ipconfigs)) - for _, config := range *ipconfigs { - if config.FrontendIPConfigurationPropertiesFormat.PrivateIPAddress != nil { - if privateIpAddress == "" { - privateIpAddress = *config.FrontendIPConfigurationPropertiesFormat.PrivateIPAddress - } + if props := loadBalancer.LoadBalancerPropertiesFormat; props != nil { + if feipConfigs := props.FrontendIPConfigurations; feipConfigs != nil { + d.Set("frontend_ip_configuration", flattenLoadBalancerFrontendIpConfiguration(feipConfigs)) + + privateIpAddress := "" + privateIpAddresses := make([]string, 0, len(*feipConfigs)) + for _, config := range *feipConfigs { + if feipProps := config.FrontendIPConfigurationPropertiesFormat; feipProps != nil { + if privateIpAddress == "" { + privateIpAddress = *feipProps.PrivateIPAddress + } - privateIpAddresses = append(privateIpAddresses, *config.FrontendIPConfigurationPropertiesFormat.PrivateIPAddress) + privateIpAddresses = append(privateIpAddresses, *feipProps.PrivateIPAddress) + } } - } - d.Set("private_ip_address", privateIpAddress) - d.Set("private_ip_addresses", privateIpAddresses) + d.Set("private_ip_address", privateIpAddress) + d.Set("private_ip_addresses", privateIpAddresses) + } } flattenAndSetTags(d, loadBalancer.Tags) @@ -206,7 +215,8 @@ func resourecArmLoadBalancerRead(d *schema.ResourceData, meta interface{}) error } func resourceArmLoadBalancerDelete(d *schema.ResourceData, meta interface{}) error { - loadBalancerClient := meta.(*ArmClient).loadBalancerClient + client := meta.(*ArmClient).loadBalancerClient + ctx := meta.(*ArmClient).StopContext id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -215,13 +225,16 @@ func resourceArmLoadBalancerDelete(d *schema.ResourceData, meta interface{}) err resGroup := id.ResourceGroup name := id.Path["loadBalancers"] - _, error := loadBalancerClient.Delete(resGroup, name, make(chan struct{})) - err = <-error + future, err := client.Delete(ctx, resGroup, name) + if err != nil { + return fmt.Errorf("Error deleting Load Balancer %q (Resource Group %q): %+v", name, resGroup, err) + } + + err = future.WaitForCompletion(ctx, client.Client) if err != nil { - return errwrap.Wrapf("Error Deleting LoadBalancer {{err}}", err) + return fmt.Errorf("Error waiting for the deleting Load Balancer %q (Resource Group %q): %+v", name, resGroup, err) } - d.SetId("") return nil } @@ -232,9 +245,9 @@ func expandAzureRmLoadBalancerFrontendIpConfigurations(d *schema.ResourceData) * for _, configRaw := range configs { data := configRaw.(map[string]interface{}) - private_ip_allocation_method := data["private_ip_address_allocation"].(string) + privateIpAllocationMethod := data["private_ip_address_allocation"].(string) properties := network.FrontendIPConfigurationPropertiesFormat{ - PrivateIPAllocationMethod: network.IPAllocationMethod(private_ip_allocation_method), + PrivateIPAllocationMethod: network.IPAllocationMethod(privateIpAllocationMethod), } if v := data["private_ip_address"].(string); v != "" { @@ -270,38 +283,40 @@ func flattenLoadBalancerFrontendIpConfiguration(ipConfigs *[]network.FrontendIPC for _, config := range *ipConfigs { ipConfig := make(map[string]interface{}) ipConfig["name"] = *config.Name - ipConfig["private_ip_address_allocation"] = config.FrontendIPConfigurationPropertiesFormat.PrivateIPAllocationMethod - if config.FrontendIPConfigurationPropertiesFormat.Subnet != nil { - ipConfig["subnet_id"] = *config.FrontendIPConfigurationPropertiesFormat.Subnet.ID - } - - if config.FrontendIPConfigurationPropertiesFormat.PrivateIPAddress != nil { - ipConfig["private_ip_address"] = *config.FrontendIPConfigurationPropertiesFormat.PrivateIPAddress - } + if props := config.FrontendIPConfigurationPropertiesFormat; props != nil { + ipConfig["private_ip_address_allocation"] = props.PrivateIPAllocationMethod - if config.FrontendIPConfigurationPropertiesFormat.PublicIPAddress != nil { - ipConfig["public_ip_address_id"] = *config.FrontendIPConfigurationPropertiesFormat.PublicIPAddress.ID - } + if subnet := props.Subnet; subnet != nil { + ipConfig["subnet_id"] = *subnet.ID + } - if config.FrontendIPConfigurationPropertiesFormat.LoadBalancingRules != nil { - load_balancing_rules := make([]string, 0, len(*config.FrontendIPConfigurationPropertiesFormat.LoadBalancingRules)) - for _, rule := range *config.FrontendIPConfigurationPropertiesFormat.LoadBalancingRules { - load_balancing_rules = append(load_balancing_rules, *rule.ID) + if pip := props.PrivateIPAddress; pip != nil { + ipConfig["private_ip_address"] = *pip } - ipConfig["load_balancer_rules"] = load_balancing_rules + if pip := props.PublicIPAddress; pip != nil { + ipConfig["public_ip_address_id"] = *pip.ID + } - } + if rules := props.LoadBalancingRules; rules != nil { + loadBalancingRules := make([]string, 0, len(*rules)) + for _, rule := range *rules { + loadBalancingRules = append(loadBalancingRules, *rule.ID) + } - if config.FrontendIPConfigurationPropertiesFormat.InboundNatRules != nil { - inbound_nat_rules := make([]string, 0, len(*config.FrontendIPConfigurationPropertiesFormat.InboundNatRules)) - for _, rule := range *config.FrontendIPConfigurationPropertiesFormat.InboundNatRules { - inbound_nat_rules = append(inbound_nat_rules, *rule.ID) + ipConfig["load_balancer_rules"] = loadBalancingRules } - ipConfig["inbound_nat_rules"] = inbound_nat_rules + if rules := props.InboundNatRules; rules != nil { + inboundNatRules := make([]string, 0, len(*rules)) + for _, rule := range *rules { + inboundNatRules = append(inboundNatRules, *rule.ID) + } + ipConfig["inbound_nat_rules"] = inboundNatRules + + } } result = append(result, ipConfig) diff --git a/azurerm/resource_arm_loadbalancer_backend_address_pool.go b/azurerm/resource_arm_loadbalancer_backend_address_pool.go index 04f210c98308..0a66b608059f 100644 --- a/azurerm/resource_arm_loadbalancer_backend_address_pool.go +++ b/azurerm/resource_arm_loadbalancer_backend_address_pool.go @@ -5,7 +5,7 @@ import ( "log" "time" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/errwrap" "github.com/hashicorp/terraform/helper/resource" "github.com/hashicorp/terraform/helper/schema" @@ -56,8 +56,8 @@ func resourceArmLoadBalancerBackendAddressPool() *schema.Resource { } func resourceArmLoadBalancerBackendAddressPoolCreate(d *schema.ResourceData, meta interface{}) error { - client := meta.(*ArmClient) - lbClient := client.loadBalancerClient + client := meta.(*ArmClient).loadBalancerClient + ctx := meta.(*ArmClient).StopContext loadBalancerID := d.Get("loadbalancer_id").(string) armMutexKV.Lock(loadBalancerID) @@ -85,45 +85,50 @@ func resourceArmLoadBalancerBackendAddressPoolCreate(d *schema.ResourceData, met loadBalancer.LoadBalancerPropertiesFormat.BackendAddressPools = &backendAddressPools resGroup, loadBalancerName, err := resourceGroupAndLBNameFromId(d.Get("loadbalancer_id").(string)) if err != nil { - return errwrap.Wrapf("Error Getting LoadBalancer Name and Group: {{err}}", err) + return fmt.Errorf("Error parsing LoadBalancer Name and Group: %+v", err) + } + + future, err := client.CreateOrUpdate(ctx, resGroup, loadBalancerName, *loadBalancer) + if err != nil { + return fmt.Errorf("Error Creating/Updating LoadBalancer %q (Resource Group %q): %+v", loadBalancerName, resGroup, err) } - _, error := lbClient.CreateOrUpdate(resGroup, loadBalancerName, *loadBalancer, make(chan struct{})) - err = <-error + err = future.WaitForCompletion(ctx, client.Client) if err != nil { - return errwrap.Wrapf("Error Creating/Updating LoadBalancer {{err}}", err) + return fmt.Errorf("Error Creating/Updating LoadBalancer %q (Resource Group %q): %+v", loadBalancerName, resGroup, err) } - read, err := lbClient.Get(resGroup, loadBalancerName, "") + read, err := client.Get(ctx, resGroup, loadBalancerName, "") if err != nil { - return errwrap.Wrapf("Error Getting LoadBalancer {{err}}", err) + return fmt.Errorf("Error retrieving Load Balancer %q (Resource Group %q): %+v", loadBalancerName, resGroup, err) } if read.ID == nil { - return fmt.Errorf("Cannot read LoadBalancer %s (resource group %s) ID", loadBalancerName, resGroup) + return fmt.Errorf("Cannot read LoadBalancer %q (Resource Group %q) ID", loadBalancerName, resGroup) } - var pool_id string + var poolId string for _, BackendAddressPool := range *(*read.LoadBalancerPropertiesFormat).BackendAddressPools { if *BackendAddressPool.Name == d.Get("name").(string) { - pool_id = *BackendAddressPool.ID + poolId = *BackendAddressPool.ID } } - if pool_id != "" { - d.SetId(pool_id) - } else { - return fmt.Errorf("Cannot find created LoadBalancer Backend Address Pool ID %q", pool_id) + if poolId == "" { + return fmt.Errorf("Cannot find created LoadBalancer Backend Address Pool ID %q", poolId) } + d.SetId(poolId) + + // TODO: is this still needed? log.Printf("[DEBUG] Waiting for LoadBalancer (%s) to become available", loadBalancerName) stateConf := &resource.StateChangeConf{ Pending: []string{"Accepted", "Updating"}, Target: []string{"Succeeded"}, - Refresh: loadbalancerStateRefreshFunc(client, resGroup, loadBalancerName), + Refresh: loadbalancerStateRefreshFunc(ctx, client, resGroup, loadBalancerName), Timeout: 10 * time.Minute, } if _, err := stateConf.WaitForState(); err != nil { - return fmt.Errorf("Error waiting for LoadBalancer (%s) to become available: %s", loadBalancerName, err) + return fmt.Errorf("Error waiting for LoadBalancer (%q Resource Group %q) to become available: %+v", loadBalancerName, resGroup, err) } return resourceArmLoadBalancerBackendAddressPoolRead(d, meta) @@ -138,7 +143,7 @@ func resourceArmLoadBalancerBackendAddressPoolRead(d *schema.ResourceData, meta loadBalancer, exists, err := retrieveLoadBalancerById(d.Get("loadbalancer_id").(string), meta) if err != nil { - return errwrap.Wrapf("Error Getting LoadBalancer By ID {{err}}", err) + return fmt.Errorf("Error retrieving Load Balancer by ID: %+v", err) } if !exists { d.SetId("") @@ -156,29 +161,32 @@ func resourceArmLoadBalancerBackendAddressPoolRead(d *schema.ResourceData, meta d.Set("name", config.Name) d.Set("resource_group_name", id.ResourceGroup) - var backend_ip_configurations []string - if config.BackendAddressPoolPropertiesFormat.BackendIPConfigurations != nil { - for _, backendConfig := range *config.BackendAddressPoolPropertiesFormat.BackendIPConfigurations { - backend_ip_configurations = append(backend_ip_configurations, *backendConfig.ID) - } + var backendIpConfigurations []string + var loadBalancingRules []string - } - d.Set("backend_ip_configurations", backend_ip_configurations) + if props := config.BackendAddressPoolPropertiesFormat; props != nil { + if configs := props.BackendIPConfigurations; configs != nil { + for _, backendConfig := range *configs { + backendIpConfigurations = append(backendIpConfigurations, *backendConfig.ID) + } + } - var load_balancing_rules []string - if config.BackendAddressPoolPropertiesFormat.LoadBalancingRules != nil { - for _, rule := range *config.BackendAddressPoolPropertiesFormat.LoadBalancingRules { - load_balancing_rules = append(load_balancing_rules, *rule.ID) + if rules := props.LoadBalancingRules; rules != nil { + for _, rule := range *rules { + loadBalancingRules = append(loadBalancingRules, *rule.ID) + } } } - d.Set("load_balancing_rules", load_balancing_rules) + + d.Set("backend_ip_configurations", backendIpConfigurations) + d.Set("load_balancing_rules", loadBalancingRules) return nil } func resourceArmLoadBalancerBackendAddressPoolDelete(d *schema.ResourceData, meta interface{}) error { - client := meta.(*ArmClient) - lbClient := client.loadBalancerClient + client := meta.(*ArmClient).loadBalancerClient + ctx := meta.(*ArmClient).StopContext loadBalancerID := d.Get("loadbalancer_id").(string) armMutexKV.Lock(loadBalancerID) @@ -186,7 +194,7 @@ func resourceArmLoadBalancerBackendAddressPoolDelete(d *schema.ResourceData, met loadBalancer, exists, err := retrieveLoadBalancerById(loadBalancerID, meta) if err != nil { - return errwrap.Wrapf("Error Getting LoadBalancer By ID {{err}}", err) + return fmt.Errorf("Error retrieving Load Balancer by ID: %+v", err) } if !exists { d.SetId("") @@ -207,18 +215,22 @@ func resourceArmLoadBalancerBackendAddressPoolDelete(d *schema.ResourceData, met return errwrap.Wrapf("Error Getting LoadBalancer Name and Group: {{err}}", err) } - _, error := lbClient.CreateOrUpdate(resGroup, loadBalancerName, *loadBalancer, make(chan struct{})) - err = <-error + future, err := client.CreateOrUpdate(ctx, resGroup, loadBalancerName, *loadBalancer) + if err != nil { + return fmt.Errorf("Error Creating/Updating LoadBalancer: %+v", err) + } + + err = future.WaitForCompletion(ctx, client.Client) if err != nil { - return errwrap.Wrapf("Error Creating/Updating LoadBalancer {{err}}", err) + return fmt.Errorf("Error waiting for the completion for the LoadBalancer: %+v", err) } - read, err := lbClient.Get(resGroup, loadBalancerName, "") + read, err := client.Get(ctx, resGroup, loadBalancerName, "") if err != nil { - return errwrap.Wrapf("Error Getting LoadBalancer {{err}}", err) + return fmt.Errorf("Error retrieving the LoadBalancer %q (Resource Group %q): %+v", loadBalancerName, resGroup, err) } if read.ID == nil { - return fmt.Errorf("Cannot read LoadBalancer %s (resource group %s) ID", loadBalancerName, resGroup) + return fmt.Errorf("Cannot read LoadBalancer %q (resource group %q) ID", loadBalancerName, resGroup) } return nil diff --git a/azurerm/resource_arm_loadbalancer_backend_address_pool_test.go b/azurerm/resource_arm_loadbalancer_backend_address_pool_test.go index ede23643395f..a7cc68e65fba 100644 --- a/azurerm/resource_arm_loadbalancer_backend_address_pool_test.go +++ b/azurerm/resource_arm_loadbalancer_backend_address_pool_test.go @@ -5,7 +5,7 @@ import ( "os" "testing" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/terraform/helper/acctest" "github.com/hashicorp/terraform/helper/resource" "github.com/hashicorp/terraform/terraform" @@ -17,7 +17,7 @@ func TestAccAzureRMLoadBalancerBackEndAddressPool_basic(t *testing.T) { addressPoolName := fmt.Sprintf("%d-address-pool", ri) subscriptionID := os.Getenv("ARM_SUBSCRIPTION_ID") - backendAddressPool_id := fmt.Sprintf( + backendAddressPoolId := fmt.Sprintf( "/subscriptions/%s/resourceGroups/acctestrg-%d/providers/Microsoft.Network/loadBalancers/arm-test-loadbalancer-%d/backendAddressPools/%s", subscriptionID, ri, ri, addressPoolName) @@ -32,7 +32,7 @@ func TestAccAzureRMLoadBalancerBackEndAddressPool_basic(t *testing.T) { testCheckAzureRMLoadBalancerExists("azurerm_lb.test", &lb), testCheckAzureRMLoadBalancerBackEndAddressPoolExists(addressPoolName, &lb), resource.TestCheckResourceAttr( - "azurerm_lb_backend_address_pool.test", "id", backendAddressPool_id), + "azurerm_lb_backend_address_pool.test", "id", backendAddressPoolId), ), }, }, @@ -141,7 +141,8 @@ func testCheckAzureRMLoadBalancerBackEndAddressPoolNotExists(addressPoolName str func testCheckAzureRMLoadBalancerBackEndAddressPoolDisappears(addressPoolName string, lb *network.LoadBalancer) resource.TestCheckFunc { return func(s *terraform.State) error { - conn := testAccProvider.Meta().(*ArmClient).loadBalancerClient + client := testAccProvider.Meta().(*ArmClient).loadBalancerClient + ctx := testAccProvider.Meta().(ArmClient).StopContext _, i, exists := findLoadBalancerBackEndAddressPoolByName(lb, addressPoolName) if !exists { @@ -157,13 +158,17 @@ func testCheckAzureRMLoadBalancerBackEndAddressPoolDisappears(addressPoolName st return err } - _, error := conn.CreateOrUpdate(id.ResourceGroup, *lb.Name, *lb, make(chan struct{})) - err = <-error + future, err := client.CreateOrUpdate(ctx, id.ResourceGroup, *lb.Name, *lb) if err != nil { return fmt.Errorf("Error Creating/Updating LoadBalancer %+v", err) } - _, err = conn.Get(id.ResourceGroup, *lb.Name, "") + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error Creating/Updating LoadBalancer %+v", err) + } + + _, err = client.Get(ctx, id.ResourceGroup, *lb.Name, "") return err } } diff --git a/azurerm/resource_arm_loadbalancer_nat_pool.go b/azurerm/resource_arm_loadbalancer_nat_pool.go index 02762fb93cbb..aa07896044ce 100644 --- a/azurerm/resource_arm_loadbalancer_nat_pool.go +++ b/azurerm/resource_arm_loadbalancer_nat_pool.go @@ -5,7 +5,7 @@ import ( "log" "time" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/errwrap" "github.com/hashicorp/terraform/helper/resource" "github.com/hashicorp/terraform/helper/schema" @@ -75,8 +75,8 @@ func resourceArmLoadBalancerNatPool() *schema.Resource { } func resourceArmLoadBalancerNatPoolCreate(d *schema.ResourceData, meta interface{}) error { - client := meta.(*ArmClient) - lbClient := client.loadBalancerClient + client := meta.(*ArmClient).loadBalancerClient + ctx := meta.(*ArmClient).StopContext loadBalancerID := d.Get("loadbalancer_id").(string) armMutexKV.Lock(loadBalancerID) @@ -113,42 +113,47 @@ func resourceArmLoadBalancerNatPoolCreate(d *schema.ResourceData, meta interface return errwrap.Wrapf("Error Getting LoadBalancer Name and Group: {{err}}", err) } - _, error := lbClient.CreateOrUpdate(resGroup, loadBalancerName, *loadBalancer, make(chan struct{})) - err = <-error + future, err := client.CreateOrUpdate(ctx, resGroup, loadBalancerName, *loadBalancer) if err != nil { - return errwrap.Wrapf("Error Creating/Updating LoadBalancer {{err}}", err) + return fmt.Errorf("Error Creating/Updating Load Balancer %q (Resource Group %q): %+v", loadBalancerName, resGroup, err) } - read, err := lbClient.Get(resGroup, loadBalancerName, "") + err = future.WaitForCompletion(ctx, client.Client) if err != nil { - return errwrap.Wrapf("Error Getting LoadBalancer {{err}}", err) + return fmt.Errorf("Error waiting for the completion of Load Balancer %q (Resource Group %q): %+v", loadBalancerName, resGroup, err) + } + + read, err := client.Get(ctx, resGroup, loadBalancerName, "") + if err != nil { + return fmt.Errorf("Error retrieving Load Balancer %q (Resource Group %q): %+v", loadBalancerName, resGroup, err) } if read.ID == nil { - return fmt.Errorf("Cannot read LoadBalancer %s (resource group %s) ID", loadBalancerName, resGroup) + return fmt.Errorf("Cannot read LoadBalancer %q (Resource Group %q) ID", loadBalancerName, resGroup) } - var natPool_id string + var natPoolId string for _, InboundNatPool := range *(*read.LoadBalancerPropertiesFormat).InboundNatPools { if *InboundNatPool.Name == d.Get("name").(string) { - natPool_id = *InboundNatPool.ID + natPoolId = *InboundNatPool.ID } } - if natPool_id != "" { - d.SetId(natPool_id) - } else { - return fmt.Errorf("Cannot find created LoadBalancer NAT Pool ID %q", natPool_id) + if natPoolId == "" { + return fmt.Errorf("Cannot find created LoadBalancer NAT Pool ID %q", natPoolId) } - log.Printf("[DEBUG] Waiting for LoadBalancer (%s) to become available", loadBalancerName) + d.SetId(natPoolId) + + // TODO: is this needed? + log.Printf("[DEBUG] Waiting for LoadBalancer (%q) to become available", loadBalancerName) stateConf := &resource.StateChangeConf{ Pending: []string{"Accepted", "Updating"}, Target: []string{"Succeeded"}, - Refresh: loadbalancerStateRefreshFunc(client, resGroup, loadBalancerName), + Refresh: loadbalancerStateRefreshFunc(ctx, client, resGroup, loadBalancerName), Timeout: 10 * time.Minute, } if _, err := stateConf.WaitForState(); err != nil { - return fmt.Errorf("Error waiting for LoadBalancer (%s) to become available: %s", loadBalancerName, err) + return fmt.Errorf("Error waiting for LoadBalancer (%q - Resource Group %q) to become available: %+v", loadBalancerName, err) } return resourceArmLoadBalancerNatPoolRead(d, meta) @@ -163,7 +168,7 @@ func resourceArmLoadBalancerNatPoolRead(d *schema.ResourceData, meta interface{} loadBalancer, exists, err := retrieveLoadBalancerById(d.Get("loadbalancer_id").(string), meta) if err != nil { - return errwrap.Wrapf("Error Getting LoadBalancer By ID {{err}}", err) + return fmt.Errorf("Error retrieving Load Balancer by ID: %+v", err) } if !exists { d.SetId("") @@ -180,27 +185,30 @@ func resourceArmLoadBalancerNatPoolRead(d *schema.ResourceData, meta interface{} d.Set("name", config.Name) d.Set("resource_group_name", id.ResourceGroup) - d.Set("protocol", config.InboundNatPoolPropertiesFormat.Protocol) - d.Set("frontend_port_start", config.InboundNatPoolPropertiesFormat.FrontendPortRangeStart) - d.Set("frontend_port_end", config.InboundNatPoolPropertiesFormat.FrontendPortRangeEnd) - d.Set("backend_port", config.InboundNatPoolPropertiesFormat.BackendPort) - - if config.InboundNatPoolPropertiesFormat.FrontendIPConfiguration != nil { - fipID, err := parseAzureResourceID(*config.InboundNatPoolPropertiesFormat.FrontendIPConfiguration.ID) - if err != nil { - return err - } - d.Set("frontend_ip_configuration_name", fipID.Path["frontendIPConfigurations"]) - d.Set("frontend_ip_configuration_id", config.InboundNatPoolPropertiesFormat.FrontendIPConfiguration.ID) + if props := config.InboundNatPoolPropertiesFormat; props != nil { + d.Set("protocol", props.Protocol) + d.Set("frontend_port_start", props.FrontendPortRangeStart) + d.Set("frontend_port_end", props.FrontendPortRangeEnd) + d.Set("backend_port", props.BackendPort) + + if feipConfig := props.FrontendIPConfiguration; feipConfig != nil { + fipID, err := parseAzureResourceID(*feipConfig.ID) + if err != nil { + return err + } + + d.Set("frontend_ip_configuration_name", fipID.Path["frontendIPConfigurations"]) + d.Set("frontend_ip_configuration_id", feipConfig.ID) + } } return nil } func resourceArmLoadBalancerNatPoolDelete(d *schema.ResourceData, meta interface{}) error { - client := meta.(*ArmClient) - lbClient := client.loadBalancerClient + client := meta.(*ArmClient).loadBalancerClient + ctx := meta.(*ArmClient).StopContext loadBalancerID := d.Get("loadbalancer_id").(string) armMutexKV.Lock(loadBalancerID) @@ -208,7 +216,7 @@ func resourceArmLoadBalancerNatPoolDelete(d *schema.ResourceData, meta interface loadBalancer, exists, err := retrieveLoadBalancerById(loadBalancerID, meta) if err != nil { - return errwrap.Wrapf("Error Getting LoadBalancer By ID {{err}}", err) + return fmt.Errorf("Error retrieving LoadBalancer by ID: %+v", err) } if !exists { d.SetId("") @@ -229,18 +237,22 @@ func resourceArmLoadBalancerNatPoolDelete(d *schema.ResourceData, meta interface return errwrap.Wrapf("Error Getting LoadBalancer Name and Group: {{err}}", err) } - _, error := lbClient.CreateOrUpdate(resGroup, loadBalancerName, *loadBalancer, make(chan struct{})) - err = <-error + future, err := client.CreateOrUpdate(ctx, resGroup, loadBalancerName, *loadBalancer) + if err != nil { + return fmt.Errorf("Error creating/updating Load Balancer %q (Resource Group %q): %+v", loadBalancerName, resGroup, err) + } + + err = future.WaitForCompletion(ctx, client.Client) if err != nil { - return errwrap.Wrapf("Error Creating/Updating LoadBalancer {{err}}", err) + return fmt.Errorf("Error waiting for completion of the Load Balancer %q (Resource Group %q): %+v", loadBalancerName, resGroup, err) } - read, err := lbClient.Get(resGroup, loadBalancerName, "") + read, err := client.Get(ctx, resGroup, loadBalancerName, "") if err != nil { - return errwrap.Wrapf("Error Getting LoadBalancer {{err}}", err) + return fmt.Errorf("Error retrieving Load Balancer: %+v", err) } if read.ID == nil { - return fmt.Errorf("Cannot read LoadBalancer %s (resource group %s) ID", loadBalancerName, resGroup) + return fmt.Errorf("Cannot read LoadBalancer %q (Resource Group %q) ID", loadBalancerName, resGroup) } return nil diff --git a/azurerm/resource_arm_loadbalancer_nat_pool_test.go b/azurerm/resource_arm_loadbalancer_nat_pool_test.go index 2b29636c107b..2a4bd75d63e0 100644 --- a/azurerm/resource_arm_loadbalancer_nat_pool_test.go +++ b/azurerm/resource_arm_loadbalancer_nat_pool_test.go @@ -5,7 +5,7 @@ import ( "os" "testing" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/terraform/helper/acctest" "github.com/hashicorp/terraform/helper/resource" "github.com/hashicorp/terraform/terraform" @@ -17,7 +17,7 @@ func TestAccAzureRMLoadBalancerNatPool_basic(t *testing.T) { natPoolName := fmt.Sprintf("NatPool-%d", ri) subscriptionID := os.Getenv("ARM_SUBSCRIPTION_ID") - natPool_id := fmt.Sprintf( + natPoolId := fmt.Sprintf( "/subscriptions/%s/resourceGroups/acctestrg-%d/providers/Microsoft.Network/loadBalancers/arm-test-loadbalancer-%d/inboundNatPools/%s", subscriptionID, ri, ri, natPoolName) @@ -32,7 +32,7 @@ func TestAccAzureRMLoadBalancerNatPool_basic(t *testing.T) { testCheckAzureRMLoadBalancerExists("azurerm_lb.test", &lb), testCheckAzureRMLoadBalancerNatPoolExists(natPoolName, &lb), resource.TestCheckResourceAttr( - "azurerm_lb_nat_pool.test", "id", natPool_id), + "azurerm_lb_nat_pool.test", "id", natPoolId), ), }, }, @@ -181,7 +181,8 @@ func testCheckAzureRMLoadBalancerNatPoolNotExists(natPoolName string, lb *networ func testCheckAzureRMLoadBalancerNatPoolDisappears(natPoolName string, lb *network.LoadBalancer) resource.TestCheckFunc { return func(s *terraform.State) error { - conn := testAccProvider.Meta().(*ArmClient).loadBalancerClient + client := testAccProvider.Meta().(*ArmClient).loadBalancerClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext _, i, exists := findLoadBalancerNatPoolByName(lb, natPoolName) if !exists { @@ -197,13 +198,17 @@ func testCheckAzureRMLoadBalancerNatPoolDisappears(natPoolName string, lb *netwo return err } - _, error := conn.CreateOrUpdate(id.ResourceGroup, *lb.Name, *lb, make(chan struct{})) - err = <-error + future, err := client.CreateOrUpdate(ctx, id.ResourceGroup, *lb.Name, *lb) if err != nil { return fmt.Errorf("Error Creating/Updating LoadBalancer %+v", err) } - _, err = conn.Get(id.ResourceGroup, *lb.Name, "") + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for the completion of LoadBalancer %+v", err) + } + + _, err = client.Get(ctx, id.ResourceGroup, *lb.Name, "") return err } } diff --git a/azurerm/resource_arm_loadbalancer_nat_rule.go b/azurerm/resource_arm_loadbalancer_nat_rule.go index 748f99885a89..ebace2b765bd 100644 --- a/azurerm/resource_arm_loadbalancer_nat_rule.go +++ b/azurerm/resource_arm_loadbalancer_nat_rule.go @@ -5,7 +5,7 @@ import ( "log" "time" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/errwrap" "github.com/hashicorp/terraform/helper/resource" "github.com/hashicorp/terraform/helper/schema" @@ -81,8 +81,8 @@ func resourceArmLoadBalancerNatRule() *schema.Resource { } func resourceArmLoadBalancerNatRuleCreate(d *schema.ResourceData, meta interface{}) error { - client := meta.(*ArmClient) - lbClient := client.loadBalancerClient + client := meta.(*ArmClient).loadBalancerClient + ctx := meta.(*ArmClient).StopContext loadBalancerID := d.Get("loadbalancer_id").(string) armMutexKV.Lock(loadBalancerID) @@ -116,41 +116,47 @@ func resourceArmLoadBalancerNatRuleCreate(d *schema.ResourceData, meta interface loadBalancer.LoadBalancerPropertiesFormat.InboundNatRules = &natRules resGroup, loadBalancerName, err := resourceGroupAndLBNameFromId(d.Get("loadbalancer_id").(string)) if err != nil { - return errwrap.Wrapf("Error Getting LoadBalancer Name and Group: {{err}}", err) + return fmt.Errorf("Error Getting LoadBalancer Name and Group: %+v", err) } - _, createError := lbClient.CreateOrUpdate(resGroup, loadBalancerName, *loadBalancer, make(chan struct{})) - err = <-createError + future, err := client.CreateOrUpdate(ctx, resGroup, loadBalancerName, *loadBalancer) if err != nil { - return errwrap.Wrapf("Error Creating / Updating LoadBalancer {{err}}", err) + return fmt.Errorf("Error Creating / Updating LoadBalancer %q (Resource Group %q): %+v", loadBalancerName, resGroup, err) } - read, err := lbClient.Get(resGroup, loadBalancerName, "") + err = future.WaitForCompletion(ctx, client.Client) if err != nil { - return errwrap.Wrapf("Error Getting LoadBalancer {{err}}", err) + return fmt.Errorf("Error waiting for completion of Load Balancer %q (Resource Group %q): %+v", loadBalancerName, resGroup, err) } + + read, err := client.Get(ctx, resGroup, loadBalancerName, "") + if err != nil { + return fmt.Errorf("Error retrieving LoadBalancer %q (Resource Group %q): %+v", loadBalancerName, resGroup, err) + } + if read.ID == nil { - return fmt.Errorf("Cannot read LoadBalancer %s (resource group %s) ID", loadBalancerName, resGroup) + return fmt.Errorf("Cannot read LoadBalancer %q (Resource Group %q) ID", loadBalancerName, resGroup) } - var natRule_id string + var natRuleId string for _, InboundNatRule := range *(*read.LoadBalancerPropertiesFormat).InboundNatRules { if *InboundNatRule.Name == d.Get("name").(string) { - natRule_id = *InboundNatRule.ID + natRuleId = *InboundNatRule.ID } } - if natRule_id != "" { - d.SetId(natRule_id) + if natRuleId != "" { + d.SetId(natRuleId) } else { - return fmt.Errorf("Cannot find created LoadBalancer NAT Rule ID %q", natRule_id) + return fmt.Errorf("Cannot find created LoadBalancer NAT Rule ID %q", natRuleId) } + // TODO: is this still needed? log.Printf("[DEBUG] Waiting for LoadBalancer (%s) to become available", loadBalancerName) stateConf := &resource.StateChangeConf{ Pending: []string{"Accepted", "Updating"}, Target: []string{"Succeeded"}, - Refresh: loadbalancerStateRefreshFunc(client, resGroup, loadBalancerName), + Refresh: loadbalancerStateRefreshFunc(ctx, client, resGroup, loadBalancerName), Timeout: 10 * time.Minute, } if _, err := stateConf.WaitForState(); err != nil { @@ -169,7 +175,7 @@ func resourceArmLoadBalancerNatRuleRead(d *schema.ResourceData, meta interface{} loadBalancer, exists, err := retrieveLoadBalancerById(d.Get("loadbalancer_id").(string), meta) if err != nil { - return errwrap.Wrapf("Error Getting LoadBalancer By ID {{err}}", err) + return fmt.Errorf("Error Getting LoadBalancer By ID: %+v", err) } if !exists { d.SetId("") @@ -212,8 +218,8 @@ func resourceArmLoadBalancerNatRuleRead(d *schema.ResourceData, meta interface{} } func resourceArmLoadBalancerNatRuleDelete(d *schema.ResourceData, meta interface{}) error { - client := meta.(*ArmClient) - lbClient := client.loadBalancerClient + client := meta.(*ArmClient).loadBalancerClient + ctx := meta.(*ArmClient).StopContext loadBalancerID := d.Get("loadbalancer_id").(string) armMutexKV.Lock(loadBalancerID) @@ -221,7 +227,7 @@ func resourceArmLoadBalancerNatRuleDelete(d *schema.ResourceData, meta interface loadBalancer, exists, err := retrieveLoadBalancerById(loadBalancerID, meta) if err != nil { - return errwrap.Wrapf("Error Getting LoadBalancer By ID {{err}}", err) + return fmt.Errorf("Error Getting LoadBalancer By ID: %+v", err) } if !exists { d.SetId("") @@ -239,18 +245,22 @@ func resourceArmLoadBalancerNatRuleDelete(d *schema.ResourceData, meta interface resGroup, loadBalancerName, err := resourceGroupAndLBNameFromId(d.Get("loadbalancer_id").(string)) if err != nil { - return errwrap.Wrapf("Error Getting LoadBalancer Name and Group: {{err}}", err) + return fmt.Errorf("Error Getting LoadBalancer Name and Group: %+v", err) + } + + future, err := client.CreateOrUpdate(ctx, resGroup, loadBalancerName, *loadBalancer) + if err != nil { + return fmt.Errorf("Error Creating/Updating LoadBalancer %q (Resource Group %q) %+v", loadBalancerName, resGroup, err) } - _, error := lbClient.CreateOrUpdate(resGroup, loadBalancerName, *loadBalancer, make(chan struct{})) - err = <-error + err = future.WaitForCompletion(ctx, client.Client) if err != nil { - return errwrap.Wrapf("Error Creating/Updating LoadBalancer {{err}}", err) + return fmt.Errorf("Error waiting for the completion of LoadBalancer updates for %q (Resource Group %q) %+v", loadBalancerName, resGroup, err) } - read, err := lbClient.Get(resGroup, loadBalancerName, "") + read, err := client.Get(ctx, resGroup, loadBalancerName, "") if err != nil { - return errwrap.Wrapf("Error Getting LoadBalancer {{err}}", err) + return fmt.Errorf("Error retrieving LoadBalancer %q (Resource Group %q): %+v", loadBalancerName, resGroup, err) } if read.ID == nil { return fmt.Errorf("Cannot read LoadBalancer %q (resource group %q) ID", loadBalancerName, resGroup) diff --git a/azurerm/resource_arm_loadbalancer_nat_rule_test.go b/azurerm/resource_arm_loadbalancer_nat_rule_test.go index 03d6449559ff..782c1f2b2ac4 100644 --- a/azurerm/resource_arm_loadbalancer_nat_rule_test.go +++ b/azurerm/resource_arm_loadbalancer_nat_rule_test.go @@ -5,7 +5,7 @@ import ( "os" "testing" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/terraform/helper/acctest" "github.com/hashicorp/terraform/helper/resource" "github.com/hashicorp/terraform/terraform" @@ -17,7 +17,7 @@ func TestAccAzureRMLoadBalancerNatRule_basic(t *testing.T) { natRuleName := fmt.Sprintf("NatRule-%d", ri) subscriptionID := os.Getenv("ARM_SUBSCRIPTION_ID") - natRule_id := fmt.Sprintf( + natRuleId := fmt.Sprintf( "/subscriptions/%s/resourceGroups/acctestrg-%d/providers/Microsoft.Network/loadBalancers/arm-test-loadbalancer-%d/inboundNatRules/%s", subscriptionID, ri, ri, natRuleName) @@ -32,7 +32,7 @@ func TestAccAzureRMLoadBalancerNatRule_basic(t *testing.T) { testCheckAzureRMLoadBalancerExists("azurerm_lb.test", &lb), testCheckAzureRMLoadBalancerNatRuleExists(natRuleName, &lb), resource.TestCheckResourceAttr( - "azurerm_lb_nat_rule.test", "id", natRule_id), + "azurerm_lb_nat_rule.test", "id", natRuleId), ), }, }, @@ -241,7 +241,8 @@ func testCheckAzureRMLoadBalancerNatRuleNotExists(natRuleName string, lb *networ func testCheckAzureRMLoadBalancerNatRuleDisappears(natRuleName string, lb *network.LoadBalancer) resource.TestCheckFunc { return func(s *terraform.State) error { - conn := testAccProvider.Meta().(*ArmClient).loadBalancerClient + client := testAccProvider.Meta().(*ArmClient).loadBalancerClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext _, i, exists := findLoadBalancerNatRuleByName(lb, natRuleName) if !exists { @@ -257,13 +258,17 @@ func testCheckAzureRMLoadBalancerNatRuleDisappears(natRuleName string, lb *netwo return err } - _, error := conn.CreateOrUpdate(id.ResourceGroup, *lb.Name, *lb, make(chan struct{})) - err = <-error + future, err := client.CreateOrUpdate(ctx, id.ResourceGroup, *lb.Name, *lb) if err != nil { return fmt.Errorf("Error Creating/Updating LoadBalancer %+v", err) } - _, err = conn.Get(id.ResourceGroup, *lb.Name, "") + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for the completion of LoadBalancer %q (Resource Group %q): %+v", *lb.Name, id.ResourceGroup, err) + } + + _, err = client.Get(ctx, id.ResourceGroup, *lb.Name, "") return err } } diff --git a/azurerm/resource_arm_loadbalancer_probe.go b/azurerm/resource_arm_loadbalancer_probe.go index bafa3d61568d..8ce83be61aca 100644 --- a/azurerm/resource_arm_loadbalancer_probe.go +++ b/azurerm/resource_arm_loadbalancer_probe.go @@ -5,7 +5,7 @@ import ( "log" "time" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/errwrap" "github.com/hashicorp/terraform/helper/resource" "github.com/hashicorp/terraform/helper/schema" @@ -80,8 +80,8 @@ func resourceArmLoadBalancerProbe() *schema.Resource { } func resourceArmLoadBalancerProbeCreate(d *schema.ResourceData, meta interface{}) error { - client := meta.(*ArmClient) - lbClient := client.loadBalancerClient + client := meta.(*ArmClient).loadBalancerClient + ctx := meta.(*ArmClient).StopContext loadBalancerID := d.Get("loadbalancer_id").(string) armMutexKV.Lock(loadBalancerID) @@ -89,7 +89,7 @@ func resourceArmLoadBalancerProbeCreate(d *schema.ResourceData, meta interface{} loadBalancer, exists, err := retrieveLoadBalancerById(loadBalancerID, meta) if err != nil { - return errwrap.Wrapf("Error Getting LoadBalancer By ID {{err}}", err) + return fmt.Errorf("Error Getting LoadBalancer By ID: %+v", err) } if !exists { d.SetId("") @@ -99,7 +99,7 @@ func resourceArmLoadBalancerProbeCreate(d *schema.ResourceData, meta interface{} newProbe, err := expandAzureRmLoadBalancerProbe(d, loadBalancer) if err != nil { - return errwrap.Wrapf("Error Expanding Probe {{err}}", err) + return fmt.Errorf("Error Expanding Probe: %+v", err) } probes := append(*loadBalancer.LoadBalancerPropertiesFormat.Probes, *newProbe) @@ -115,45 +115,49 @@ func resourceArmLoadBalancerProbeCreate(d *schema.ResourceData, meta interface{} loadBalancer.LoadBalancerPropertiesFormat.Probes = &probes resGroup, loadBalancerName, err := resourceGroupAndLBNameFromId(d.Get("loadbalancer_id").(string)) if err != nil { - return errwrap.Wrapf("Error Getting LoadBalancer Name and Group: {{err}}", err) + return fmt.Errorf("Error Getting LoadBalancer Name and Group: %+v", err) } - _, error := lbClient.CreateOrUpdate(resGroup, loadBalancerName, *loadBalancer, make(chan struct{})) - err = <-error + future, err := client.CreateOrUpdate(ctx, resGroup, loadBalancerName, *loadBalancer) if err != nil { - return errwrap.Wrapf("Error Creating/Updating LoadBalancer {{err}}", err) + return fmt.Errorf("Error Creating/Updating Load Balancer %q (Resource Group %q): %+v", loadBalancerName, resGroup, err) } - read, err := lbClient.Get(resGroup, loadBalancerName, "") + err = future.WaitForCompletion(ctx, client.Client) if err != nil { - return errwrap.Wrapf("Error Getting LoadBalancer {{err}}", err) + return fmt.Errorf("Error waiting for completion of Load Balancer %q (Resource Group %q): %+v", loadBalancerName, resGroup, err) + } + + read, err := client.Get(ctx, resGroup, loadBalancerName, "") + if err != nil { + return fmt.Errorf("Error retrieving Load Balancer %q (Resource Group %q): %+v", loadBalancerName, resGroup, err) } if read.ID == nil { - return fmt.Errorf("Cannot read LoadBalancer %s (resource group %s) ID", loadBalancerName, resGroup) + return fmt.Errorf("Cannot read LoadBalancer %q (resource group %q) ID", loadBalancerName, resGroup) } - var createdProbe_id string + var createdProbeId string for _, Probe := range *(*read.LoadBalancerPropertiesFormat).Probes { if *Probe.Name == d.Get("name").(string) { - createdProbe_id = *Probe.ID + createdProbeId = *Probe.ID } } - if createdProbe_id != "" { - d.SetId(createdProbe_id) - } else { - return fmt.Errorf("Cannot find created LoadBalancer Probe ID %q", createdProbe_id) + if createdProbeId == "" { + return fmt.Errorf("Cannot find created LoadBalancer Probe ID %q", createdProbeId) } + d.SetId(createdProbeId) + log.Printf("[DEBUG] Waiting for LoadBalancer (%s) to become available", loadBalancerName) stateConf := &resource.StateChangeConf{ Pending: []string{"Accepted", "Updating"}, Target: []string{"Succeeded"}, - Refresh: loadbalancerStateRefreshFunc(client, resGroup, loadBalancerName), + Refresh: loadbalancerStateRefreshFunc(ctx, client, resGroup, loadBalancerName), Timeout: 10 * time.Minute, } if _, err := stateConf.WaitForState(); err != nil { - return fmt.Errorf("Error waiting for LoadBalancer (%s) to become available: %s", loadBalancerName, err) + return fmt.Errorf("Error waiting for LoadBalancer (%q - Resource Group %q) to become available: %+v", loadBalancerName, resGroup, err) } return resourceArmLoadBalancerProbeRead(d, meta) @@ -203,8 +207,8 @@ func resourceArmLoadBalancerProbeRead(d *schema.ResourceData, meta interface{}) } func resourceArmLoadBalancerProbeDelete(d *schema.ResourceData, meta interface{}) error { - client := meta.(*ArmClient) - lbClient := client.loadBalancerClient + client := meta.(*ArmClient).loadBalancerClient + ctx := meta.(*ArmClient).StopContext loadBalancerID := d.Get("loadbalancer_id").(string) armMutexKV.Lock(loadBalancerID) @@ -212,7 +216,7 @@ func resourceArmLoadBalancerProbeDelete(d *schema.ResourceData, meta interface{} loadBalancer, exists, err := retrieveLoadBalancerById(loadBalancerID, meta) if err != nil { - return errwrap.Wrapf("Error Getting LoadBalancer By ID {{err}}", err) + return fmt.Errorf("Error Getting LoadBalancer By ID: %+v", err) } if !exists { d.SetId("") @@ -233,13 +237,17 @@ func resourceArmLoadBalancerProbeDelete(d *schema.ResourceData, meta interface{} return errwrap.Wrapf("Error Getting LoadBalancer Name and Group: {{err}}", err) } - _, error := lbClient.CreateOrUpdate(resGroup, loadBalancerName, *loadBalancer, make(chan struct{})) - err = <-error + future, err := client.CreateOrUpdate(ctx, resGroup, loadBalancerName, *loadBalancer) + if err != nil { + return fmt.Errorf("Error Creating/Updating LoadBalancer %q (Resource Group %q): %+v", loadBalancerName, resGroup, err) + } + + err = future.WaitForCompletion(ctx, client.Client) if err != nil { - return errwrap.Wrapf("Error Creating/Updating LoadBalancer {{err}}", err) + return fmt.Errorf("Error waiting for completion of LoadBalancer %q (Resource Group %q): %+v", loadBalancerName, resGroup, err) } - read, err := lbClient.Get(resGroup, loadBalancerName, "") + read, err := client.Get(ctx, resGroup, loadBalancerName, "") if err != nil { return errwrap.Wrapf("Error Getting LoadBalancer {{err}}", err) } diff --git a/azurerm/resource_arm_loadbalancer_probe_test.go b/azurerm/resource_arm_loadbalancer_probe_test.go index 6ebdea5d3baf..92f13bc96e93 100644 --- a/azurerm/resource_arm_loadbalancer_probe_test.go +++ b/azurerm/resource_arm_loadbalancer_probe_test.go @@ -5,7 +5,7 @@ import ( "os" "testing" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/terraform/helper/acctest" "github.com/hashicorp/terraform/helper/resource" "github.com/hashicorp/terraform/terraform" @@ -212,7 +212,8 @@ func testCheckAzureRMLoadBalancerProbeNotExists(natRuleName string, lb *network. func testCheckAzureRMLoadBalancerProbeDisappears(addressPoolName string, lb *network.LoadBalancer) resource.TestCheckFunc { return func(s *terraform.State) error { - conn := testAccProvider.Meta().(*ArmClient).loadBalancerClient + client := testAccProvider.Meta().(*ArmClient).loadBalancerClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext _, i, exists := findLoadBalancerProbeByName(lb, addressPoolName) if !exists { @@ -228,13 +229,17 @@ func testCheckAzureRMLoadBalancerProbeDisappears(addressPoolName string, lb *net return err } - _, error := conn.CreateOrUpdate(id.ResourceGroup, *lb.Name, *lb, make(chan struct{})) - err = <-error + future, err := client.CreateOrUpdate(ctx, id.ResourceGroup, *lb.Name, *lb) if err != nil { - return fmt.Errorf("Error Creating/Updating LoadBalancer %s", err) + return fmt.Errorf("Error Creating/Updating LoadBalancer: %+v", err) } - _, err = conn.Get(id.ResourceGroup, *lb.Name, "") + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for completion for LoadBalancer: %+v", err) + } + + _, err = client.Get(ctx, id.ResourceGroup, *lb.Name, "") return err } } diff --git a/azurerm/resource_arm_loadbalancer_rule.go b/azurerm/resource_arm_loadbalancer_rule.go index 4c2bda5aa7f6..3f1df0f361d0 100644 --- a/azurerm/resource_arm_loadbalancer_rule.go +++ b/azurerm/resource_arm_loadbalancer_rule.go @@ -6,7 +6,7 @@ import ( "regexp" "time" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/errwrap" "github.com/hashicorp/terraform/helper/resource" "github.com/hashicorp/terraform/helper/schema" @@ -102,8 +102,8 @@ func resourceArmLoadBalancerRule() *schema.Resource { } func resourceArmLoadBalancerRuleCreate(d *schema.ResourceData, meta interface{}) error { - client := meta.(*ArmClient) - lbClient := client.loadBalancerClient + client := meta.(*ArmClient).loadBalancerClient + ctx := meta.(*ArmClient).StopContext loadBalancerID := d.Get("loadbalancer_id").(string) armMutexKV.Lock(loadBalancerID) @@ -140,13 +140,17 @@ func resourceArmLoadBalancerRuleCreate(d *schema.ResourceData, meta interface{}) return errwrap.Wrapf("Error Getting LoadBalancer Name and Group: {{err}}", err) } - _, error := lbClient.CreateOrUpdate(resGroup, loadBalancerName, *loadBalancer, make(chan struct{})) - err = <-error + future, err := client.CreateOrUpdate(ctx, resGroup, loadBalancerName, *loadBalancer) if err != nil { return errwrap.Wrapf("Error Creating/Updating LoadBalancer {{err}}", err) } - read, err := lbClient.Get(resGroup, loadBalancerName, "") + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for completion for LoadBalancer updates: %+v", err) + } + + read, err := client.Get(ctx, resGroup, loadBalancerName, "") if err != nil { return errwrap.Wrapf("Error Getting LoadBalancer {{err}}", err) } @@ -154,24 +158,24 @@ func resourceArmLoadBalancerRuleCreate(d *schema.ResourceData, meta interface{}) return fmt.Errorf("Cannot read LoadBalancer %s (resource group %s) ID", loadBalancerName, resGroup) } - var rule_id string + var ruleId string for _, LoadBalancingRule := range *(*read.LoadBalancerPropertiesFormat).LoadBalancingRules { if *LoadBalancingRule.Name == d.Get("name").(string) { - rule_id = *LoadBalancingRule.ID + ruleId = *LoadBalancingRule.ID } } - if rule_id != "" { - d.SetId(rule_id) - } else { - return fmt.Errorf("Cannot find created LoadBalancer Rule ID %q", rule_id) + if ruleId == "" { + return fmt.Errorf("Cannot find created LoadBalancer Rule ID %q", ruleId) } + d.SetId(ruleId) + log.Printf("[DEBUG] Waiting for LoadBalancer (%s) to become available", loadBalancerName) stateConf := &resource.StateChangeConf{ Pending: []string{"Accepted", "Updating"}, Target: []string{"Succeeded"}, - Refresh: loadbalancerStateRefreshFunc(client, resGroup, loadBalancerName), + Refresh: loadbalancerStateRefreshFunc(ctx, client, resGroup, loadBalancerName), Timeout: 10 * time.Minute, } if _, err := stateConf.WaitForState(); err != nil { @@ -246,8 +250,8 @@ func resourceArmLoadBalancerRuleRead(d *schema.ResourceData, meta interface{}) e } func resourceArmLoadBalancerRuleDelete(d *schema.ResourceData, meta interface{}) error { - client := meta.(*ArmClient) - lbClient := client.loadBalancerClient + client := meta.(*ArmClient).loadBalancerClient + ctx := meta.(*ArmClient).StopContext loadBalancerID := d.Get("loadbalancer_id").(string) armMutexKV.Lock(loadBalancerID) @@ -276,18 +280,22 @@ func resourceArmLoadBalancerRuleDelete(d *schema.ResourceData, meta interface{}) return errwrap.Wrapf("Error Getting LoadBalancer Name and Group: {{err}}", err) } - _, error := lbClient.CreateOrUpdate(resGroup, loadBalancerName, *loadBalancer, make(chan struct{})) - err = <-error + future, err := client.CreateOrUpdate(ctx, resGroup, loadBalancerName, *loadBalancer) if err != nil { - return errwrap.Wrapf("Error Creating/Updating LoadBalancer {{err}}", err) + return fmt.Errorf("Error Creating/Updating LoadBalancer %q (Resource Group %q): %+v", loadBalancerName, resGroup, err) } - read, err := lbClient.Get(resGroup, loadBalancerName, "") + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for completion of LoadBalancer %q (Resource Group %q): %+v", loadBalancerName, resGroup, err) + } + + read, err := client.Get(ctx, resGroup, loadBalancerName, "") if err != nil { return errwrap.Wrapf("Error Getting LoadBalancer {{err}}", err) } if read.ID == nil { - return fmt.Errorf("Cannot read LoadBalancer %s (resource group %s) ID", loadBalancerName, resGroup) + return fmt.Errorf("Cannot read ID of LoadBalancer %q (resource group %s)", loadBalancerName, resGroup) } return nil diff --git a/azurerm/resource_arm_loadbalancer_rule_test.go b/azurerm/resource_arm_loadbalancer_rule_test.go index 7c2e0cac21de..4e567f5eeaee 100644 --- a/azurerm/resource_arm_loadbalancer_rule_test.go +++ b/azurerm/resource_arm_loadbalancer_rule_test.go @@ -5,7 +5,7 @@ import ( "os" "testing" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/terraform/helper/acctest" "github.com/hashicorp/terraform/helper/resource" "github.com/hashicorp/terraform/terraform" @@ -278,7 +278,8 @@ func testCheckAzureRMLoadBalancerRuleNotExists(lbRuleName string, lb *network.Lo func testCheckAzureRMLoadBalancerRuleDisappears(ruleName string, lb *network.LoadBalancer) resource.TestCheckFunc { return func(s *terraform.State) error { - conn := testAccProvider.Meta().(*ArmClient).loadBalancerClient + client := testAccProvider.Meta().(*ArmClient).loadBalancerClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext _, i, exists := findLoadBalancerRuleByName(lb, ruleName) if !exists { @@ -294,13 +295,17 @@ func testCheckAzureRMLoadBalancerRuleDisappears(ruleName string, lb *network.Loa return err } - _, error := conn.CreateOrUpdate(id.ResourceGroup, *lb.Name, *lb, make(chan struct{})) - err = <-error + future, err := client.CreateOrUpdate(ctx, id.ResourceGroup, *lb.Name, *lb) if err != nil { - return fmt.Errorf("Error Creating/Updating LoadBalancer %+v", err) + return fmt.Errorf("Error Creating/Updating LoadBalancer %q (Resource Group %q): %+v", lb.Name, id.ResourceGroup, err) } - _, err = conn.Get(id.ResourceGroup, *lb.Name, "") + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for completion of LoadBalancer %q (Resource Group %q): %+v", lb.Name, id.ResourceGroup, err) + } + + _, err = client.Get(ctx, id.ResourceGroup, *lb.Name, "") return err } } diff --git a/azurerm/resource_arm_loadbalancer_test.go b/azurerm/resource_arm_loadbalancer_test.go index ba92b102beb6..a1ca7e8b168d 100644 --- a/azurerm/resource_arm_loadbalancer_test.go +++ b/azurerm/resource_arm_loadbalancer_test.go @@ -5,7 +5,7 @@ import ( "net/http" "testing" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/terraform/helper/acctest" "github.com/hashicorp/terraform/helper/resource" "github.com/hashicorp/terraform/terraform" @@ -141,18 +141,19 @@ func testCheckAzureRMLoadBalancerExists(name string, lb *network.LoadBalancer) r return fmt.Errorf("Not found: %s", name) } - loadbalancerName := rs.Primary.Attributes["name"] + loadBalancerName := 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 loadbalancer: %s", loadbalancerName) + return fmt.Errorf("Bad: no resource group found in state for loadbalancer: %s", loadBalancerName) } - conn := testAccProvider.Meta().(*ArmClient).loadBalancerClient + client := testAccProvider.Meta().(*ArmClient).loadBalancerClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext - resp, err := conn.Get(resourceGroup, loadbalancerName, "") + resp, err := client.Get(ctx, resourceGroup, loadBalancerName, "") if err != nil { if resp.StatusCode == http.StatusNotFound { - return fmt.Errorf("Bad: LoadBalancer %q (resource group: %q) does not exist", loadbalancerName, resourceGroup) + return fmt.Errorf("Bad: LoadBalancer %q (resource group: %q) does not exist", loadBalancerName, resourceGroup) } return fmt.Errorf("Bad: Get on loadBalancerClient: %+v", err) @@ -165,7 +166,8 @@ func testCheckAzureRMLoadBalancerExists(name string, lb *network.LoadBalancer) r } func testCheckAzureRMLoadBalancerDestroy(s *terraform.State) error { - conn := testAccProvider.Meta().(*ArmClient).loadBalancerClient + client := testAccProvider.Meta().(*ArmClient).loadBalancerClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext for _, rs := range s.RootModule().Resources { if rs.Type != "azurerm_lb" { @@ -175,7 +177,7 @@ func testCheckAzureRMLoadBalancerDestroy(s *terraform.State) error { name := rs.Primary.Attributes["name"] resourceGroup := rs.Primary.Attributes["resource_group_name"] - resp, err := conn.Get(resourceGroup, name, "") + resp, err := client.Get(ctx, resourceGroup, name, "") if err != nil { return nil diff --git a/azurerm/resource_arm_local_network_gateway.go b/azurerm/resource_arm_local_network_gateway.go index c690134dc6a1..81472cc24608 100644 --- a/azurerm/resource_arm_local_network_gateway.go +++ b/azurerm/resource_arm_local_network_gateway.go @@ -3,8 +3,9 @@ package azurerm import ( "fmt" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/terraform/helper/schema" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/response" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" ) @@ -74,6 +75,7 @@ func resourceArmLocalNetworkGateway() *schema.Resource { func resourceArmLocalNetworkGatewayCreate(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).localNetConnClient + ctx := meta.(*ArmClient).StopContext name := d.Get("name").(string) location := d.Get("location").(string) @@ -102,13 +104,17 @@ func resourceArmLocalNetworkGatewayCreate(d *schema.ResourceData, meta interface Tags: expandTags(tags), } - _, createError := client.CreateOrUpdate(resGroup, name, gateway, make(chan struct{})) - err = <-createError + future, err := client.CreateOrUpdate(ctx, resGroup, name, gateway) if err != nil { - return fmt.Errorf("Error creating Local Network Gateway %q: %+v", name, err) + return fmt.Errorf("Error creating Local Network Gateway %q (Resource Group %q): %+v", name, resGroup, err) } - read, err := client.Get(resGroup, name) + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for completion of Local Network Gateway %q (Resource Group %q): %+v", name, resGroup, err) + } + + read, err := client.Get(ctx, resGroup, name) if err != nil { return err } @@ -123,6 +129,7 @@ func resourceArmLocalNetworkGatewayCreate(d *schema.ResourceData, meta interface func resourceArmLocalNetworkGatewayRead(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).localNetConnClient + ctx := meta.(*ArmClient).StopContext id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -131,7 +138,7 @@ func resourceArmLocalNetworkGatewayRead(d *schema.ResourceData, meta interface{} name := id.Path["localNetworkGateways"] resGroup := id.ResourceGroup - resp, err := client.Get(resGroup, name) + resp, err := client.Get(ctx, resGroup, name) if err != nil { if utils.ResponseWasNotFound(resp.Response) { d.SetId("") @@ -166,6 +173,7 @@ func resourceArmLocalNetworkGatewayRead(d *schema.ResourceData, meta interface{} func resourceArmLocalNetworkGatewayDelete(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).localNetConnClient + ctx := meta.(*ArmClient).StopContext id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -174,16 +182,22 @@ func resourceArmLocalNetworkGatewayDelete(d *schema.ResourceData, meta interface name := id.Path["localNetworkGateways"] resGroup := id.ResourceGroup - deleteResp, error := client.Delete(resGroup, name, make(chan struct{})) - resp := <-deleteResp - err = <-error + future, err := client.Delete(ctx, resGroup, name) + if err != nil { + if response.WasNotFound(future.Response()) { + return nil + } + + return fmt.Errorf("Error issuing delete request for local network gateway % (Resource Group %q): %+v", name, resGroup, err) + } + err = future.WaitForCompletion(ctx, client.Client) if err != nil { - if utils.ResponseWasNotFound(resp) { + if response.WasNotFound(future.Response()) { return nil } - return fmt.Errorf("Error issuing delete request for local network gateway %q: %+v", name, err) + return fmt.Errorf("Error waiting for completion of local network gateway %q (Resource Group %q): %+v", name, resGroup, err) } return nil diff --git a/azurerm/resource_arm_local_network_gateway_test.go b/azurerm/resource_arm_local_network_gateway_test.go index 81af87e0d7f9..f35f93ea3e0b 100644 --- a/azurerm/resource_arm_local_network_gateway_test.go +++ b/azurerm/resource_arm_local_network_gateway_test.go @@ -7,6 +7,7 @@ import ( "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/helpers/response" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" ) @@ -213,8 +214,9 @@ func testCheckAzureRMLocalNetworkGatewayExists(name string) resource.TestCheckFu // and finally, check that it exists on Azure: client := testAccProvider.Meta().(*ArmClient).localNetConnClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext - resp, err := client.Get(resGrp, localNetName) + resp, err := client.Get(ctx, resGrp, localNetName) if err != nil { if utils.ResponseWasNotFound(resp.Response) { return fmt.Errorf("Local network gateway %q (resource group %q) does not exist on Azure.", localNetName, resGrp) @@ -241,21 +243,25 @@ func testCheckAzureRMLocalNetworkGatewayDisappears(name string) resource.TestChe return err } localNetName := id.Path["localNetworkGateways"] - resGrp := id.ResourceGroup + resourceGroup := id.ResourceGroup // and finally, check that it exists on Azure: client := testAccProvider.Meta().(*ArmClient).localNetConnClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext - deleteResp, error := client.Delete(resGrp, localNetName, make(chan struct{})) - resp := <-deleteResp - err = <-error + future, err := client.Delete(ctx, resourceGroup, localNetName) if err != nil { - if utils.ResponseWasNotFound(resp) { - return fmt.Errorf("Local network gateway %q (resource group %q) does not exist on Azure.", localNetName, resGrp) + if response.WasNotFound(future.Response()) { + return fmt.Errorf("Local network gateway %q (resource group %q) does not exist on Azure.", localNetName, resourceGroup) } return fmt.Errorf("Error deleting the state of local network gateway %q: %+v", localNetName, err) } + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for deletion of the local network gateway %q to complete: %+v", localNetName, err) + } + return nil } } @@ -271,10 +277,11 @@ func testCheckAzureRMLocalNetworkGatewayDestroy(s *terraform.State) error { return err } localNetName := id.Path["localNetworkGateways"] - resGrp := id.ResourceGroup + resourceGroup := id.ResourceGroup client := testAccProvider.Meta().(*ArmClient).localNetConnClient - resp, err := client.Get(resGrp, localNetName) + ctx := testAccProvider.Meta().(*ArmClient).StopContext + resp, err := client.Get(ctx, resourceGroup, localNetName) if err != nil { if utils.ResponseWasNotFound(resp.Response) { diff --git a/azurerm/resource_arm_network_interface.go b/azurerm/resource_arm_network_interface.go index 2306cb32035f..5d4c0420b3e6 100644 --- a/azurerm/resource_arm_network_interface.go +++ b/azurerm/resource_arm_network_interface.go @@ -5,7 +5,7 @@ import ( "log" "strings" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/terraform/helper/schema" "github.com/hashicorp/terraform/helper/validation" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" @@ -180,6 +180,7 @@ func resourceArmNetworkInterface() *schema.Resource { func resourceArmNetworkInterfaceCreateUpdate(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).ifaceClient + ctx := meta.(*ArmClient).StopContext log.Printf("[INFO] preparing arguments for AzureRM Network Interface creation.") @@ -255,13 +256,17 @@ func resourceArmNetworkInterfaceCreateUpdate(d *schema.ResourceData, meta interf Tags: expandTags(tags), } - _, createErr := client.CreateOrUpdate(resGroup, name, iface, make(chan struct{})) - err := <-createErr + future, err := client.CreateOrUpdate(ctx, resGroup, name, iface) if err != nil { return err } - read, err := client.Get(resGroup, name, "") + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return err + } + + read, err := client.Get(ctx, resGroup, name, "") if err != nil { return err } @@ -276,6 +281,7 @@ func resourceArmNetworkInterfaceCreateUpdate(d *schema.ResourceData, meta interf func resourceArmNetworkInterfaceRead(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).ifaceClient + ctx := meta.(*ArmClient).StopContext id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -284,13 +290,13 @@ func resourceArmNetworkInterfaceRead(d *schema.ResourceData, meta interface{}) e resGroup := id.ResourceGroup name := id.Path["networkInterfaces"] - resp, err := client.Get(resGroup, name, "") + resp, err := client.Get(ctx, resGroup, name, "") if err != nil { if utils.ResponseWasNotFound(resp.Response) { d.SetId("") return nil } - return fmt.Errorf("Error making Read request on Azure Network Interface %s: %+v", name, err) + return fmt.Errorf("Error making Read request on Azure Network Interface %q (Resource Group %q): %+v", name, resGroup, err) } iface := *resp.InterfacePropertiesFormat @@ -372,6 +378,7 @@ func resourceArmNetworkInterfaceRead(d *schema.ResourceData, meta interface{}) e func resourceArmNetworkInterfaceDelete(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).ifaceClient + ctx := meta.(*ArmClient).StopContext id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -420,8 +427,15 @@ func resourceArmNetworkInterfaceDelete(d *schema.ResourceData, meta interface{}) azureRMLockMultipleByName(&virtualNetworkNamesToLock, virtualNetworkResourceName) defer azureRMUnlockMultipleByName(&virtualNetworkNamesToLock, virtualNetworkResourceName) - _, deleteErr := client.Delete(resGroup, name, make(chan struct{})) - err = <-deleteErr + future, err := client.Delete(ctx, resGroup, name) + if err != nil { + return fmt.Errorf("Error deleting Network Interface %q (Resource Group %q): %+v", name, resGroup, err) + } + + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for the deletion of Network Interface %q (Resource Group %q): %+v", name, resGroup, err) + } return err } diff --git a/azurerm/resource_arm_network_interface_test.go b/azurerm/resource_arm_network_interface_test.go index b72f2df95849..1caea1568e23 100644 --- a/azurerm/resource_arm_network_interface_test.go +++ b/azurerm/resource_arm_network_interface_test.go @@ -9,6 +9,7 @@ import ( "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/helpers/response" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" ) @@ -30,14 +31,15 @@ func testSweepNetworkInterfaces(region string) error { } client := (*armClient).ifaceClient + ctx := (*armClient).StopContext log.Printf("Retrieving the Network Interfaces..") - results, err := client.ListAll() + results, err := client.ListAll(ctx) if err != nil { return fmt.Errorf("Error Listing on Network Interfaces: %+v", err) } - for _, network := range *results.Value { + for _, network := range results.Values() { id, err := parseAzureResourceID(*network.ID) if err != nil { return fmt.Errorf("Error parsing Azure Resource ID %q", id) @@ -52,11 +54,18 @@ func testSweepNetworkInterfaces(region string) error { } log.Printf("Deleting Network Interfaces %q", name) - deleteResponse, deleteErr := client.Delete(resourceGroupName, name, make(chan struct{})) - resp := <-deleteResponse - err = <-deleteErr + future, err := client.Delete(ctx, resourceGroupName, name) if err != nil { - if utils.ResponseWasNotFound(resp) { + if response.WasNotFound(future.Response()) { + continue + } + + return err + } + + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + if response.WasNotFound(future.Response()) { continue } @@ -338,7 +347,9 @@ func testCheckAzureRMNetworkInterfaceExists(name string) resource.TestCheckFunc } client := testAccProvider.Meta().(*ArmClient).ifaceClient - resp, err := client.Get(resourceGroup, name, "") + ctx := testAccProvider.Meta().(*ArmClient).StopContext + + resp, err := client.Get(ctx, resourceGroup, name, "") if err != nil { if utils.ResponseWasNotFound(resp.Response) { return fmt.Errorf("Bad: Network Interface %q (resource group: %q) does not exist", name, resourceGroup) @@ -365,12 +376,17 @@ func testCheckAzureRMNetworkInterfaceDisappears(name string) resource.TestCheckF return fmt.Errorf("Bad: no resource group found in state for availability set: %q", name) } - conn := testAccProvider.Meta().(*ArmClient).ifaceClient + client := testAccProvider.Meta().(*ArmClient).ifaceClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext + + future, err := client.Delete(ctx, resourceGroup, name) + if err != nil { + return fmt.Errorf("Error deleting Network Interface %q (Resource Group %q): %+v", name, resourceGroup, err) + } - _, deleteErr := conn.Delete(resourceGroup, name, make(chan struct{})) - err := <-deleteErr + err = future.WaitForCompletion(ctx, client.Client) if err != nil { - return fmt.Errorf("Bad: Delete on ifaceClient: %+v", err) + return fmt.Errorf("Error waiting for the deletion of Network Interface %q (Resource Group %q): %+v", name, resourceGroup, err) } return nil @@ -379,6 +395,7 @@ func testCheckAzureRMNetworkInterfaceDisappears(name string) resource.TestCheckF func testCheckAzureRMNetworkInterfaceDestroy(s *terraform.State) error { client := testAccProvider.Meta().(*ArmClient).ifaceClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext for _, rs := range s.RootModule().Resources { if rs.Type != "azurerm_network_interface" { @@ -388,7 +405,7 @@ func testCheckAzureRMNetworkInterfaceDestroy(s *terraform.State) error { name := rs.Primary.Attributes["name"] resourceGroup := rs.Primary.Attributes["resource_group_name"] - resp, err := client.Get(resourceGroup, name, "") + resp, err := client.Get(ctx, resourceGroup, name, "") if err != nil { if utils.ResponseWasNotFound(resp.Response) { return nil diff --git a/azurerm/resource_arm_network_security_group.go b/azurerm/resource_arm_network_security_group.go index 3e8d3d2f98e5..6bbdc6a5d809 100644 --- a/azurerm/resource_arm_network_security_group.go +++ b/azurerm/resource_arm_network_security_group.go @@ -2,11 +2,8 @@ package azurerm import ( "fmt" - "log" - "time" - "github.com/Azure/azure-sdk-for-go/arm/network" - "github.com/hashicorp/terraform/helper/resource" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/terraform/helper/schema" "github.com/hashicorp/terraform/helper/validation" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" @@ -115,6 +112,7 @@ func resourceArmNetworkSecurityGroup() *schema.Resource { func resourceArmNetworkSecurityGroupCreate(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).secGroupClient + ctx := meta.(*ArmClient).StopContext name := d.Get("name").(string) location := d.Get("location").(string) @@ -138,30 +136,22 @@ func resourceArmNetworkSecurityGroupCreate(d *schema.ResourceData, meta interfac Tags: expandTags(tags), } - _, createErr := client.CreateOrUpdate(resGroup, name, sg, make(chan struct{})) - err := <-createErr + future, err := client.CreateOrUpdate(ctx, resGroup, name, sg) if err != nil { - return err + return fmt.Errorf("Error creating/updating NSG %q (Resource Group %q): %+v", name, resGroup, err) } - read, err := client.Get(resGroup, name, "") + err = future.WaitForCompletion(ctx, client.Client) if err != nil { - return err - } - if read.ID == nil { - return fmt.Errorf("Cannot read Virtual Network %q (resource group %q) ID", name, resGroup) + return fmt.Errorf("Error waiting for the completion of NSG %q (Resource Group %q): %+v", name, resGroup, err) } - log.Printf("[DEBUG] Waiting for NSG (%q) to become available", name) - stateConf := &resource.StateChangeConf{ - Pending: []string{"Updating", "Creating"}, - Target: []string{"Succeeded"}, - Refresh: networkSecurityGroupStateRefreshFunc(client, resGroup, name), - Timeout: 30 * time.Minute, - MinTimeout: 15 * time.Second, + read, err := client.Get(ctx, resGroup, name, "") + if err != nil { + return err } - if _, err := stateConf.WaitForState(); err != nil { - return fmt.Errorf("Error waiting for NSG (%q) to become available: %+v", name, err) + if read.ID == nil { + return fmt.Errorf("Cannot read NSG %q (resource group %q) ID", name, resGroup) } d.SetId(*read.ID) @@ -171,6 +161,7 @@ func resourceArmNetworkSecurityGroupCreate(d *schema.ResourceData, meta interfac func resourceArmNetworkSecurityGroupRead(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).secGroupClient + ctx := meta.(*ArmClient).StopContext id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -179,13 +170,13 @@ func resourceArmNetworkSecurityGroupRead(d *schema.ResourceData, meta interface{ resGroup := id.ResourceGroup name := id.Path["networkSecurityGroups"] - resp, err := client.Get(resGroup, name, "") + resp, err := client.Get(ctx, resGroup, name, "") if err != nil { if utils.ResponseWasNotFound(resp.Response) { d.SetId("") return nil } - return fmt.Errorf("Error making Read request on Azure Network Security Group %q: %+v", name, err) + return fmt.Errorf("Error making Read request on Network Security Group %q (Resource Group %q): %+v", name, resGroup, err) } d.Set("name", resp.Name) @@ -203,6 +194,7 @@ func resourceArmNetworkSecurityGroupRead(d *schema.ResourceData, meta interface{ func resourceArmNetworkSecurityGroupDelete(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).secGroupClient + ctx := meta.(*ArmClient).StopContext id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -211,8 +203,15 @@ func resourceArmNetworkSecurityGroupDelete(d *schema.ResourceData, meta interfac resGroup := id.ResourceGroup name := id.Path["networkSecurityGroups"] - _, deleteErr := client.Delete(resGroup, name, make(chan struct{})) - err = <-deleteErr + future, err := client.Delete(ctx, resGroup, name) + if err != nil { + return fmt.Errorf("Error deleting Network Security Group %q (Resource Group %q): %+v", name, resGroup, err) + } + + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error deleting Network Security Group %q (Resource Group %q): %+v", name, resGroup, err) + } return err } @@ -297,14 +296,3 @@ func expandAzureRmSecurityRules(d *schema.ResourceData) ([]network.SecurityRule, return rules, nil } - -func networkSecurityGroupStateRefreshFunc(client network.SecurityGroupsClient, resourceGroupName string, sgName string) resource.StateRefreshFunc { - return func() (interface{}, string, error) { - res, err := client.Get(resourceGroupName, sgName, "") - if err != nil { - return nil, "", fmt.Errorf("Error issuing read request in networkSecurityGroupStateRefreshFunc for NSG '%s' (RG: '%s'): %+v", sgName, resourceGroupName, err) - } - - return res, *res.SecurityGroupPropertiesFormat.ProvisioningState, nil - } -} diff --git a/azurerm/resource_arm_network_security_group_test.go b/azurerm/resource_arm_network_security_group_test.go index eda9861ae21d..4d40b31990c0 100644 --- a/azurerm/resource_arm_network_security_group_test.go +++ b/azurerm/resource_arm_network_security_group_test.go @@ -7,6 +7,7 @@ import ( "github.com/hashicorp/terraform/helper/acctest" "github.com/hashicorp/terraform/helper/resource" "github.com/hashicorp/terraform/terraform" + response "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/response" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" ) @@ -163,7 +164,8 @@ func testCheckAzureRMNetworkSecurityGroupExists(name string) resource.TestCheckF } client := testAccProvider.Meta().(*ArmClient).secGroupClient - resp, err := client.Get(resourceGroup, sgName, "") + ctx := testAccProvider.Meta().(*ArmClient).StopContext + resp, err := client.Get(ctx, resourceGroup, sgName, "") if err != nil { if utils.ResponseWasNotFound(resp.Response) { return fmt.Errorf("Bad: Network Security Group %q (resource group: %q) does not exist", name, resourceGroup) @@ -191,12 +193,11 @@ func testCheckAzureRMNetworkSecurityGroupDisappears(name string) resource.TestCh } client := testAccProvider.Meta().(*ArmClient).secGroupClient - deleteResp, deleteErr := client.Delete(resourceGroup, sgName, make(chan struct{})) - resp := <-deleteResp - err := <-deleteErr + ctx := testAccProvider.Meta().(*ArmClient).StopContext + future, err := client.Delete(ctx, resourceGroup, sgName) if err != nil { - if !utils.ResponseWasNotFound(resp) { - return fmt.Errorf("Bad: Delete on secGroupClient: %+v", err) + if !response.WasNotFound(future.Response()) { + return fmt.Errorf("Error deleting NSG %q (Resource Group %q): %+v", sgName, resourceGroup, err) } } @@ -206,6 +207,7 @@ func testCheckAzureRMNetworkSecurityGroupDisappears(name string) resource.TestCh func testCheckAzureRMNetworkSecurityGroupDestroy(s *terraform.State) error { client := testAccProvider.Meta().(*ArmClient).secGroupClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext for _, rs := range s.RootModule().Resources { if rs.Type != "azurerm_network_security_group" { @@ -215,7 +217,7 @@ func testCheckAzureRMNetworkSecurityGroupDestroy(s *terraform.State) error { name := rs.Primary.Attributes["name"] resourceGroup := rs.Primary.Attributes["resource_group_name"] - resp, err := client.Get(resourceGroup, name, "") + resp, err := client.Get(ctx, resourceGroup, name, "") if err != nil { if utils.ResponseWasNotFound(resp.Response) { diff --git a/azurerm/resource_arm_network_security_rule.go b/azurerm/resource_arm_network_security_rule.go index 5dbbc075a732..df4f42fe49b4 100644 --- a/azurerm/resource_arm_network_security_rule.go +++ b/azurerm/resource_arm_network_security_rule.go @@ -3,7 +3,7 @@ package azurerm import ( "fmt" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/terraform/helper/schema" "github.com/hashicorp/terraform/helper/validation" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" @@ -138,15 +138,16 @@ func resourceArmNetworkSecurityRule() *schema.Resource { func resourceArmNetworkSecurityRuleCreate(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).secRuleClient + ctx := meta.(*ArmClient).StopContext name := d.Get("name").(string) nsgName := d.Get("network_security_group_name").(string) resGroup := d.Get("resource_group_name").(string) - source_port_range := d.Get("source_port_range").(string) - destination_port_range := d.Get("destination_port_range").(string) - source_address_prefix := d.Get("source_address_prefix").(string) - destination_address_prefix := d.Get("destination_address_prefix").(string) + sourcePortRange := d.Get("source_port_range").(string) + destinationPortRange := d.Get("destination_port_range").(string) + sourceAddressPrefix := d.Get("source_address_prefix").(string) + destinationAddressPrefix := d.Get("destination_address_prefix").(string) priority := int32(d.Get("priority").(int)) access := d.Get("access").(string) direction := d.Get("direction").(string) @@ -158,10 +159,10 @@ func resourceArmNetworkSecurityRuleCreate(d *schema.ResourceData, meta interface rule := network.SecurityRule{ Name: &name, SecurityRulePropertiesFormat: &network.SecurityRulePropertiesFormat{ - SourcePortRange: &source_port_range, - DestinationPortRange: &destination_port_range, - SourceAddressPrefix: &source_address_prefix, - DestinationAddressPrefix: &destination_address_prefix, + SourcePortRange: &sourcePortRange, + DestinationPortRange: &destinationPortRange, + SourceAddressPrefix: &sourceAddressPrefix, + DestinationAddressPrefix: &destinationAddressPrefix, Priority: &priority, Access: network.SecurityRuleAccess(access), Direction: network.SecurityRuleDirection(direction), @@ -214,13 +215,17 @@ func resourceArmNetworkSecurityRuleCreate(d *schema.ResourceData, meta interface rule.SecurityRulePropertiesFormat.DestinationAddressPrefixes = &destinationAddressPrefixes } - _, createErr := client.CreateOrUpdate(resGroup, nsgName, name, rule, make(chan struct{})) - err := <-createErr + future, err := client.CreateOrUpdate(ctx, resGroup, nsgName, name, rule) if err != nil { - return err + return fmt.Errorf("Error Creating/Updating Network Security Rule %q (NSG %q / Resource Group %q): %+v", name, nsgName, resGroup, err) } - read, err := client.Get(resGroup, nsgName, name) + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for completion of Network Security Rule %q (NSG %q / Resource Group %q): %+v", name, nsgName, resGroup, err) + } + + read, err := client.Get(ctx, resGroup, nsgName, name) if err != nil { return err } @@ -235,6 +240,7 @@ func resourceArmNetworkSecurityRuleCreate(d *schema.ResourceData, meta interface func resourceArmNetworkSecurityRuleRead(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).secRuleClient + ctx := meta.(*ArmClient).StopContext id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -244,7 +250,7 @@ func resourceArmNetworkSecurityRuleRead(d *schema.ResourceData, meta interface{} networkSGName := id.Path["networkSecurityGroups"] sgRuleName := id.Path["securityRules"] - resp, err := client.Get(resGroup, networkSGName, sgRuleName) + resp, err := client.Get(ctx, resGroup, networkSGName, sgRuleName) if err != nil { if utils.ResponseWasNotFound(resp.Response) { d.SetId("") @@ -277,6 +283,7 @@ func resourceArmNetworkSecurityRuleRead(d *schema.ResourceData, meta interface{} func resourceArmNetworkSecurityRuleDelete(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).secRuleClient + ctx := meta.(*ArmClient).StopContext id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -289,8 +296,15 @@ func resourceArmNetworkSecurityRuleDelete(d *schema.ResourceData, meta interface azureRMLockByName(nsgName, networkSecurityGroupResourceName) defer azureRMUnlockByName(nsgName, networkSecurityGroupResourceName) - _, deleteErr := client.Delete(resGroup, nsgName, sgRuleName, make(chan struct{})) - err = <-deleteErr + future, err := client.Delete(ctx, resGroup, nsgName, sgRuleName) + if err != nil { + return fmt.Errorf("Error Deleting Network Security Rule %q (NSG %q / Resource Group %q): %+v", sgRuleName, nsgName, resGroup, err) + } + + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for the deletion of Network Security Rule %q (NSG %q / Resource Group %q): %+v", sgRuleName, nsgName, resGroup, err) + } return err } diff --git a/azurerm/resource_arm_network_security_rule_test.go b/azurerm/resource_arm_network_security_rule_test.go index 9e590d8ba48c..fc4a581ed372 100644 --- a/azurerm/resource_arm_network_security_rule_test.go +++ b/azurerm/resource_arm_network_security_rule_test.go @@ -8,6 +8,7 @@ import ( "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/helpers/response" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" ) @@ -106,14 +107,15 @@ func testCheckAzureRMNetworkSecurityRuleExists(name string) resource.TestCheckFu return fmt.Errorf("Bad: no resource group found in state for network security rule: %q", sgName) } - conn := testAccProvider.Meta().(*ArmClient).secRuleClient + client := testAccProvider.Meta().(*ArmClient).secRuleClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext - resp, err := conn.Get(resourceGroup, sgName, sgrName) + resp, err := client.Get(ctx, resourceGroup, sgName, sgrName) if err != nil { if utils.ResponseWasNotFound(resp.Response) { return fmt.Errorf("Bad: Network Security Rule %q (resource group: %q) (network security group: %q) does not exist", sgrName, sgName, resourceGroup) } - return fmt.Errorf("Bad: Get on secRuleClient: %+v", err) + return fmt.Errorf("Error retrieving Network Security Rule %q (NSG %q / Resource Group %q): %+v", sgrName, sgName, resourceGroup, err) } return nil @@ -136,12 +138,11 @@ func testCheckAzureRMNetworkSecurityRuleDisappears(name string) resource.TestChe } client := testAccProvider.Meta().(*ArmClient).secRuleClient - deleteResp, deleteErr := client.Delete(resourceGroup, sgName, sgrName, make(chan struct{})) - resp := <-deleteResp - err := <-deleteErr + ctx := testAccProvider.Meta().(*ArmClient).StopContext + future, err := client.Delete(ctx, resourceGroup, sgName, sgrName) if err != nil { - if !utils.ResponseWasNotFound(resp) { - return fmt.Errorf("Bad: Delete on secRuleClient: %+v", err) + if !response.WasNotFound(future.Response()) { + return fmt.Errorf("Error deleting Network Security Rule %q (NSG %q / Resource Group %q): %+v", sgrName, sgName, resourceGroup, err) } } @@ -150,7 +151,8 @@ func testCheckAzureRMNetworkSecurityRuleDisappears(name string) resource.TestChe } func testCheckAzureRMNetworkSecurityRuleDestroy(s *terraform.State) error { - conn := testAccProvider.Meta().(*ArmClient).secRuleClient + client := testAccProvider.Meta().(*ArmClient).secRuleClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext for _, rs := range s.RootModule().Resources { @@ -162,7 +164,7 @@ func testCheckAzureRMNetworkSecurityRuleDestroy(s *terraform.State) error { sgrName := rs.Primary.Attributes["name"] resourceGroup := rs.Primary.Attributes["resource_group_name"] - resp, err := conn.Get(resourceGroup, sgName, sgrName) + resp, err := client.Get(ctx, resourceGroup, sgName, sgrName) if err != nil { return nil diff --git a/azurerm/resource_arm_network_watcher.go b/azurerm/resource_arm_network_watcher.go index e81f49b1ae6f..363a13c71339 100644 --- a/azurerm/resource_arm_network_watcher.go +++ b/azurerm/resource_arm_network_watcher.go @@ -3,8 +3,9 @@ package azurerm import ( "fmt" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/terraform/helper/schema" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/response" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" ) @@ -36,6 +37,7 @@ func resourceArmNetworkWatcher() *schema.Resource { func resourceArmNetworkWatcherCreateUpdate(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).watcherClient + ctx := meta.(*ArmClient).StopContext name := d.Get("name").(string) resourceGroup := d.Get("resource_group_name").(string) @@ -46,12 +48,12 @@ func resourceArmNetworkWatcherCreateUpdate(d *schema.ResourceData, meta interfac Location: utils.String(location), Tags: expandTags(tags), } - _, err := client.CreateOrUpdate(resourceGroup, name, watcher) + _, err := client.CreateOrUpdate(ctx, resourceGroup, name, watcher) if err != nil { return err } - read, err := client.Get(resourceGroup, name) + read, err := client.Get(ctx, resourceGroup, name) if err != nil { return err } @@ -66,6 +68,7 @@ func resourceArmNetworkWatcherCreateUpdate(d *schema.ResourceData, meta interfac func resourceArmNetworkWatcherRead(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).watcherClient + ctx := meta.(*ArmClient).StopContext id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -74,7 +77,7 @@ func resourceArmNetworkWatcherRead(d *schema.ResourceData, meta interface{}) err resourceGroup := id.ResourceGroup name := id.Path["networkWatchers"] - resp, err := client.Get(resourceGroup, name) + resp, err := client.Get(ctx, resourceGroup, name) if err != nil { if utils.ResponseWasNotFound(resp.Response) { d.SetId("") @@ -94,6 +97,7 @@ func resourceArmNetworkWatcherRead(d *schema.ResourceData, meta interface{}) err func resourceArmNetworkWatcherDelete(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).watcherClient + ctx := meta.(*ArmClient).StopContext id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -102,15 +106,17 @@ func resourceArmNetworkWatcherDelete(d *schema.ResourceData, meta interface{}) e resourceGroup := id.ResourceGroup name := id.Path["networkWatchers"] - deleteResp, deleteErr := client.Delete(resourceGroup, name, make(chan struct{})) - resp := <-deleteResp - err = <-deleteErr - + future, err := client.Delete(ctx, resourceGroup, name) if err != nil { - if !utils.ResponseWasNotFound(resp) { + if !response.WasNotFound(future.Response()) { return fmt.Errorf("Error deleting Network Watcher %q (Resource Group %q): %+v", name, resourceGroup, err) } } + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for the deletion of 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 index 73d963550f65..69c1c1b004b8 100644 --- a/azurerm/resource_arm_network_watcher_test.go +++ b/azurerm/resource_arm_network_watcher_test.go @@ -7,6 +7,7 @@ import ( "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/helpers/response" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" ) @@ -105,9 +106,10 @@ func testCheckAzureRMNetworkWatcherExists(name string) resource.TestCheckFunc { return fmt.Errorf("Bad: no resource group found in state for Network Watcher: %q", name) } - conn := testAccProvider.Meta().(*ArmClient).watcherClient + client := testAccProvider.Meta().(*ArmClient).watcherClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext - resp, err := conn.Get(resourceGroup, name) + resp, err := client.Get(ctx, 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) @@ -134,15 +136,19 @@ func testCheckAzureRMNetworkWatcherDisappears(name string) resource.TestCheckFun } client := testAccProvider.Meta().(*ArmClient).watcherClient - deleteResp, deleteErr := client.Delete(resourceGroup, name, make(chan struct{})) - resp := <-deleteResp - err := <-deleteErr + ctx := testAccProvider.Meta().(*ArmClient).StopContext + future, err := client.Delete(ctx, resourceGroup, name) if err != nil { - if !utils.ResponseWasNotFound(resp) { + if !response.WasNotFound(future.Response()) { return fmt.Errorf("Bad: Delete on watcherClient: %+v", err) } } + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Bad: Delete on watcherClient: %+v", err) + } + return nil } } @@ -158,7 +164,8 @@ func testCheckAzureRMNetworkWatcherDestroy(s *terraform.State) error { resourceGroup := rs.Primary.Attributes["resource_group_name"] client := testAccProvider.Meta().(*ArmClient).watcherClient - resp, err := client.Get(resourceGroup, name) + ctx := testAccProvider.Meta().(*ArmClient).StopContext + resp, err := client.Get(ctx, resourceGroup, name) if err != nil { if !utils.ResponseWasNotFound(resp.Response) { diff --git a/azurerm/resource_arm_public_ip.go b/azurerm/resource_arm_public_ip.go index 1be0ea19997f..e5ebb311028b 100644 --- a/azurerm/resource_arm_public_ip.go +++ b/azurerm/resource_arm_public_ip.go @@ -6,7 +6,7 @@ import ( "regexp" "strings" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/terraform/helper/schema" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" ) @@ -90,10 +90,10 @@ func resourceArmPublicIp() *schema.Resource { } func resourceArmPublicIpCreate(d *schema.ResourceData, meta interface{}) error { - client := meta.(*ArmClient) - publicIPClient := client.publicIPClient + client := meta.(*ArmClient).publicIPClient + ctx := meta.(*ArmClient).StopContext - log.Printf("[INFO] preparing arguments for Azure ARM Public IP creation.") + log.Printf("[INFO] preparing arguments for AzureRM Public IP creation.") name := d.Get("name").(string) location := d.Get("location").(string) @@ -111,22 +111,21 @@ func resourceArmPublicIpCreate(d *schema.ResourceData, meta interface{}) error { dnsSettings := network.PublicIPAddressDNSSettings{} if hasRfqdn { - reverse_fqdn := rfqdn.(string) - dnsSettings.ReverseFqdn = &reverse_fqdn + reverseFqdn := rfqdn.(string) + dnsSettings.ReverseFqdn = &reverseFqdn } if hasDnl { - domain_name_label := dnl.(string) - dnsSettings.DomainNameLabel = &domain_name_label - + domainNameLabel := dnl.(string) + dnsSettings.DomainNameLabel = &domainNameLabel } properties.DNSSettings = &dnsSettings } if v, ok := d.GetOk("idle_timeout_in_minutes"); ok { - idle_timeout := int32(v.(int)) - properties.IdleTimeoutInMinutes = &idle_timeout + idleTimeout := int32(v.(int)) + properties.IdleTimeoutInMinutes = &idleTimeout } publicIp := network.PublicIPAddress{ @@ -136,18 +135,22 @@ func resourceArmPublicIpCreate(d *schema.ResourceData, meta interface{}) error { Tags: expandTags(tags), } - _, error := publicIPClient.CreateOrUpdate(resGroup, name, publicIp, make(chan struct{})) - err := <-error + future, err := client.CreateOrUpdate(ctx, resGroup, name, publicIp) if err != nil { - return err + return fmt.Errorf("Error Creating/Updating Public IP %q (Resource Group %q): %+v", name, resGroup, err) + } + + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for completion of Public IP %q (Resource Group %q): %+v", name, resGroup, err) } - read, err := publicIPClient.Get(resGroup, name, "") + read, err := client.Get(ctx, resGroup, name, "") if err != nil { return err } if read.ID == nil { - return fmt.Errorf("Cannot read Public IP %s (resource group %s) ID", name, resGroup) + return fmt.Errorf("Cannot read Public IP %q (resource group %q) ID", name, resGroup) } d.SetId(*read.ID) @@ -156,7 +159,8 @@ func resourceArmPublicIpCreate(d *schema.ResourceData, meta interface{}) error { } func resourceArmPublicIpRead(d *schema.ResourceData, meta interface{}) error { - publicIPClient := meta.(*ArmClient).publicIPClient + client := meta.(*ArmClient).publicIPClient + ctx := meta.(*ArmClient).StopContext id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -165,26 +169,34 @@ func resourceArmPublicIpRead(d *schema.ResourceData, meta interface{}) error { resGroup := id.ResourceGroup name := id.Path["publicIPAddresses"] - resp, err := publicIPClient.Get(resGroup, name, "") + resp, err := client.Get(ctx, resGroup, name, "") if err != nil { if utils.ResponseWasNotFound(resp.Response) { d.SetId("") return nil } - return fmt.Errorf("Error making Read request on Azure public ip %s: %s", name, err) + + return fmt.Errorf("Error making Read request on Public IP %q (Resource Group %q): %+v", name, resGroup, err) } - d.Set("resource_group_name", resGroup) - d.Set("location", azureRMNormalizeLocation(*resp.Location)) d.Set("name", resp.Name) - d.Set("public_ip_address_allocation", strings.ToLower(string(resp.PublicIPAddressPropertiesFormat.PublicIPAllocationMethod))) - - if resp.PublicIPAddressPropertiesFormat.DNSSettings != nil && resp.PublicIPAddressPropertiesFormat.DNSSettings.Fqdn != nil && *resp.PublicIPAddressPropertiesFormat.DNSSettings.Fqdn != "" { - d.Set("fqdn", resp.PublicIPAddressPropertiesFormat.DNSSettings.Fqdn) + d.Set("resource_group_name", resGroup) + if location := resp.Location; location != nil { + d.Set("location", azureRMNormalizeLocation(*location)) } - if resp.PublicIPAddressPropertiesFormat.IPAddress != nil && *resp.PublicIPAddressPropertiesFormat.IPAddress != "" { - d.Set("ip_address", resp.PublicIPAddressPropertiesFormat.IPAddress) + if props := resp.PublicIPAddressPropertiesFormat; props != nil { + d.Set("public_ip_address_allocation", strings.ToLower(string(props.PublicIPAllocationMethod))) + + if settings := props.DNSSettings; settings != nil { + if fqdn := settings.Fqdn; fqdn != nil { + d.Set("fqdn", fqdn) + } + + if ip := props.IPAddress; ip != nil { + d.Set("ip_address", ip) + } + } } flattenAndSetTags(d, resp.Tags) @@ -193,7 +205,8 @@ func resourceArmPublicIpRead(d *schema.ResourceData, meta interface{}) error { } func resourceArmPublicIpDelete(d *schema.ResourceData, meta interface{}) error { - publicIPClient := meta.(*ArmClient).publicIPClient + client := meta.(*ArmClient).publicIPClient + ctx := meta.(*ArmClient).StopContext id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -202,10 +215,17 @@ func resourceArmPublicIpDelete(d *schema.ResourceData, meta interface{}) error { resGroup := id.ResourceGroup name := id.Path["publicIPAddresses"] - _, error := publicIPClient.Delete(resGroup, name, make(chan struct{})) - err = <-error + future, err := client.Delete(ctx, resGroup, name) + if err != nil { + return fmt.Errorf("Error deleting Public IP %q (Resource Group %q): %+v", name, resGroup, err) + } - return err + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for deletion of Public IP %q (Resource Group %q): %+v", name, resGroup, err) + } + + return nil } func validatePublicIpAllocation(v interface{}, k string) (ws []string, errors []error) { diff --git a/azurerm/resource_arm_public_ip_test.go b/azurerm/resource_arm_public_ip_test.go index 64a3d1b15271..259b7056ba9a 100644 --- a/azurerm/resource_arm_public_ip_test.go +++ b/azurerm/resource_arm_public_ip_test.go @@ -230,15 +230,16 @@ func testCheckAzureRMPublicIpExists(name string) resource.TestCheckFunc { return fmt.Errorf("Not found: %s", name) } - availSetName := rs.Primary.Attributes["name"] + publicIPName := 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 public ip: %s", availSetName) + return fmt.Errorf("Bad: no resource group found in state for public ip: %s", publicIPName) } - conn := testAccProvider.Meta().(*ArmClient).publicIPClient + client := testAccProvider.Meta().(*ArmClient).publicIPClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext - resp, err := conn.Get(resourceGroup, availSetName, "") + resp, err := client.Get(ctx, resourceGroup, publicIPName, "") if err != nil { return fmt.Errorf("Bad: Get on publicIPClient: %+v", err) } @@ -265,12 +266,16 @@ func testCheckAzureRMPublicIpDisappears(name string) resource.TestCheckFunc { return fmt.Errorf("Bad: no resource group found in state for public ip: %s", publicIpName) } - conn := testAccProvider.Meta().(*ArmClient).publicIPClient + client := testAccProvider.Meta().(*ArmClient).publicIPClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext + future, err := client.Delete(ctx, resourceGroup, publicIpName) + if err != nil { + return fmt.Errorf("Error deleting Public IP %q (Resource Group %q): %+v", publicIpName, resourceGroup, err) + } - _, error := conn.Delete(resourceGroup, publicIpName, make(chan struct{})) - err := <-error + err = future.WaitForCompletion(ctx, client.Client) if err != nil { - return fmt.Errorf("Bad: Delete on publicIPClient: %+v", err) + return fmt.Errorf("Error waiting for deletion of Public IP %q (Resource Group %q): %+v", publicIpName, resourceGroup, err) } return nil @@ -278,7 +283,8 @@ func testCheckAzureRMPublicIpDisappears(name string) resource.TestCheckFunc { } func testCheckAzureRMPublicIpDestroy(s *terraform.State) error { - conn := testAccProvider.Meta().(*ArmClient).publicIPClient + client := testAccProvider.Meta().(*ArmClient).publicIPClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext for _, rs := range s.RootModule().Resources { if rs.Type != "azurerm_public_ip" { @@ -288,7 +294,7 @@ func testCheckAzureRMPublicIpDestroy(s *terraform.State) error { name := rs.Primary.Attributes["name"] resourceGroup := rs.Primary.Attributes["resource_group_name"] - resp, err := conn.Get(resourceGroup, name, "") + resp, err := client.Get(ctx, resourceGroup, name, "") if err != nil { return nil diff --git a/azurerm/resource_arm_route.go b/azurerm/resource_arm_route.go index bd6d9417abef..8e67fe15d544 100644 --- a/azurerm/resource_arm_route.go +++ b/azurerm/resource_arm_route.go @@ -3,7 +3,7 @@ package azurerm import ( "fmt" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/terraform/helper/schema" "github.com/hashicorp/terraform/helper/validation" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" @@ -63,6 +63,7 @@ func resourceArmRoute() *schema.Resource { func resourceArmRouteCreateUpdate(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).routesClient + ctx := meta.(*ArmClient).StopContext name := d.Get("name").(string) rtName := d.Get("route_table_name").(string) @@ -89,13 +90,17 @@ func resourceArmRouteCreateUpdate(d *schema.ResourceData, meta interface{}) erro RoutePropertiesFormat: &properties, } - _, createErr := client.CreateOrUpdate(resGroup, rtName, name, route, make(chan struct{})) - err := <-createErr + future, err := client.CreateOrUpdate(ctx, resGroup, rtName, name, route) if err != nil { - return err + return fmt.Errorf("Error Creating/Updating Route %q (Route Table %q / Resource Group %q): %+v", name, rtName, resGroup, err) } - read, err := client.Get(resGroup, rtName, name) + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for completion for Route %q (Route Table %q / Resource Group %q): %+v", name, rtName, resGroup, err) + } + + read, err := client.Get(ctx, resGroup, rtName, name) if err != nil { return err } @@ -109,6 +114,7 @@ func resourceArmRouteCreateUpdate(d *schema.ResourceData, meta interface{}) erro func resourceArmRouteRead(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).routesClient + ctx := meta.(*ArmClient).StopContext id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -118,7 +124,7 @@ func resourceArmRouteRead(d *schema.ResourceData, meta interface{}) error { rtName := id.Path["routeTables"] routeName := id.Path["routes"] - resp, err := client.Get(resGroup, rtName, routeName) + resp, err := client.Get(ctx, resGroup, rtName, routeName) if err != nil { if utils.ResponseWasNotFound(resp.Response) { d.SetId("") @@ -145,6 +151,7 @@ func resourceArmRouteRead(d *schema.ResourceData, meta interface{}) error { func resourceArmRouteDelete(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).routesClient + ctx := meta.(*ArmClient).StopContext id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -157,8 +164,15 @@ func resourceArmRouteDelete(d *schema.ResourceData, meta interface{}) error { azureRMLockByName(rtName, routeTableResourceName) defer azureRMUnlockByName(rtName, routeTableResourceName) - _, deleteErr := client.Delete(resGroup, rtName, routeName, make(chan struct{})) - err = <-deleteErr + future, err := client.Delete(ctx, resGroup, rtName, routeName) + if err != nil { + return fmt.Errorf("Error deleting Route %q (Route Table %q / Resource Group %q): %+v", routeName, rtName, resGroup, err) + } + + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for deletion of Route %q (Route Table %q / Resource Group %q): %+v", routeName, rtName, resGroup, err) + } - return err + return nil } diff --git a/azurerm/resource_arm_route_table.go b/azurerm/resource_arm_route_table.go index bc80781cc22c..e4ee781fe92d 100644 --- a/azurerm/resource_arm_route_table.go +++ b/azurerm/resource_arm_route_table.go @@ -4,9 +4,10 @@ import ( "fmt" "log" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/terraform/helper/schema" "github.com/hashicorp/terraform/helper/validation" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/response" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" ) @@ -85,6 +86,7 @@ func resourceArmRouteTable() *schema.Resource { func resourceArmRouteTableCreate(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).routeTablesClient + ctx := meta.(*ArmClient).StopContext log.Printf("[INFO] preparing arguments for AzureRM Route Table creation.") @@ -107,13 +109,17 @@ func resourceArmRouteTableCreate(d *schema.ResourceData, meta interface{}) error Tags: expandTags(tags), } - _, createErr := client.CreateOrUpdate(resGroup, name, routeSet, make(chan struct{})) - err = <-createErr + future, err := client.CreateOrUpdate(ctx, resGroup, name, routeSet) if err != nil { - return err + return fmt.Errorf("Error Creating/Updating Route Table %q (Resource Group %q): %+v", name, resGroup, err) } - read, err := client.Get(resGroup, name, "") + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for completion of Route Table %q (Resource Group %q): %+v", name, resGroup, err) + } + + read, err := client.Get(ctx, resGroup, name, "") if err != nil { return err } @@ -128,6 +134,7 @@ func resourceArmRouteTableCreate(d *schema.ResourceData, meta interface{}) error func resourceArmRouteTableRead(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).routeTablesClient + ctx := meta.(*ArmClient).StopContext id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -136,7 +143,7 @@ func resourceArmRouteTableRead(d *schema.ResourceData, meta interface{}) error { resGroup := id.ResourceGroup name := id.Path["routeTables"] - resp, err := client.Get(resGroup, name, "") + resp, err := client.Get(ctx, resGroup, name, "") if err != nil { if utils.ResponseWasNotFound(resp.Response) { d.SetId("") @@ -165,7 +172,8 @@ func resourceArmRouteTableRead(d *schema.ResourceData, meta interface{}) error { } func resourceArmRouteTableDelete(d *schema.ResourceData, meta interface{}) error { - routeTablesClient := meta.(*ArmClient).routeTablesClient + client := meta.(*ArmClient).routeTablesClient + ctx := meta.(*ArmClient).StopContext id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -174,16 +182,18 @@ func resourceArmRouteTableDelete(d *schema.ResourceData, meta interface{}) error resGroup := id.ResourceGroup name := id.Path["routeTables"] - deleteResp, deleteErr := routeTablesClient.Delete(resGroup, name, make(chan struct{})) - resp := <-deleteResp - err = <-deleteErr - + future, err := client.Delete(ctx, resGroup, name) if err != nil { - if !utils.ResponseWasNotFound(resp) { - return err + if !response.WasNotFound(future.Response()) { + return fmt.Errorf("Error deleting Route Table %q (Resource Group %q): %+v", name, resGroup, err) } } + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for deletion of Route Table %q (Resource Group %q): %+v", name, resGroup, err) + } + return nil } diff --git a/azurerm/resource_arm_route_table_test.go b/azurerm/resource_arm_route_table_test.go index 09d9e106f636..c21e4a22c59f 100644 --- a/azurerm/resource_arm_route_table_test.go +++ b/azurerm/resource_arm_route_table_test.go @@ -7,6 +7,7 @@ import ( "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/helpers/response" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" ) @@ -213,9 +214,10 @@ func testCheckAzureRMRouteTableExists(name string) resource.TestCheckFunc { return fmt.Errorf("Bad: no resource group found in state for route table: %q", name) } - conn := testAccProvider.Meta().(*ArmClient).routeTablesClient + client := testAccProvider.Meta().(*ArmClient).routeTablesClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext - resp, err := conn.Get(resourceGroup, name, "") + resp, err := client.Get(ctx, resourceGroup, name, "") if err != nil { if utils.ResponseWasNotFound(resp.Response) { return fmt.Errorf("Bad: Route Table %q (resource group: %q) does not exist", name, resourceGroup) @@ -242,21 +244,27 @@ func testCheckAzureRMRouteTableDisappears(name string) resource.TestCheckFunc { } client := testAccProvider.Meta().(*ArmClient).routeTablesClient - deleteResp, deleteErr := client.Delete(resourceGroup, name, make(chan struct{})) - resp := <-deleteResp - err := <-deleteErr + ctx := testAccProvider.Meta().(*ArmClient).StopContext + + future, err := client.Delete(ctx, resourceGroup, name) if err != nil { - if !utils.ResponseWasNotFound(resp) { - return fmt.Errorf("Bad: Delete on routeTablesClient: %+v", err) + if !response.WasNotFound(future.Response()) { + return fmt.Errorf("Error deleting Route Table %q (Resource Group %q): %+v", name, resourceGroup, err) } } + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for deletion of Route Table %q (Resource Group %q): %+v", name, resourceGroup, err) + } + return nil } } func testCheckAzureRMRouteTableDestroy(s *terraform.State) error { client := testAccProvider.Meta().(*ArmClient).routeTablesClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext for _, rs := range s.RootModule().Resources { if rs.Type != "azurerm_route_table" { @@ -266,7 +274,7 @@ func testCheckAzureRMRouteTableDestroy(s *terraform.State) error { name := rs.Primary.Attributes["name"] resourceGroup := rs.Primary.Attributes["resource_group_name"] - resp, err := client.Get(resourceGroup, name, "") + resp, err := client.Get(ctx, resourceGroup, name, "") if err != nil { if utils.ResponseWasNotFound(resp.Response) { return nil diff --git a/azurerm/resource_arm_route_test.go b/azurerm/resource_arm_route_test.go index e7e23bbc11c2..d5639878ded9 100644 --- a/azurerm/resource_arm_route_test.go +++ b/azurerm/resource_arm_route_test.go @@ -94,9 +94,10 @@ func testCheckAzureRMRouteExists(name string) resource.TestCheckFunc { return fmt.Errorf("Bad: no resource group found in state for route: %q", name) } - conn := testAccProvider.Meta().(*ArmClient).routesClient + client := testAccProvider.Meta().(*ArmClient).routesClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext - resp, err := conn.Get(resourceGroup, rtName, name) + resp, err := client.Get(ctx, resourceGroup, rtName, name) if err != nil { if utils.ResponseWasNotFound(resp.Response) { return fmt.Errorf("Bad: Route %q (resource group: %q) does not exist", name, resourceGroup) @@ -123,12 +124,17 @@ func testCheckAzureRMRouteDisappears(name string) resource.TestCheckFunc { return fmt.Errorf("Bad: no resource group found in state for route: %s", name) } - conn := testAccProvider.Meta().(*ArmClient).routesClient + client := testAccProvider.Meta().(*ArmClient).routesClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext - _, error := conn.Delete(resourceGroup, rtName, name, make(chan struct{})) - err := <-error + future, err := client.Delete(ctx, resourceGroup, rtName, name) if err != nil { - return fmt.Errorf("Bad: Delete on routesClient: %+v", err) + return fmt.Errorf("Error deleting Route %q (Route Table %q / Resource Group %q): %+v", name, rtName, resourceGroup, err) + } + + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for deletion of Route %q (Route Table %q / Resource Group %q): %+v", name, rtName, resourceGroup, err) } return nil @@ -136,7 +142,8 @@ func testCheckAzureRMRouteDisappears(name string) resource.TestCheckFunc { } func testCheckAzureRMRouteDestroy(s *terraform.State) error { - conn := testAccProvider.Meta().(*ArmClient).routesClient + client := testAccProvider.Meta().(*ArmClient).routesClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext for _, rs := range s.RootModule().Resources { if rs.Type != "azurerm_route" { @@ -147,7 +154,7 @@ func testCheckAzureRMRouteDestroy(s *terraform.State) error { rtName := rs.Primary.Attributes["route_table_name"] resourceGroup := rs.Primary.Attributes["resource_group_name"] - resp, err := conn.Get(resourceGroup, rtName, name) + resp, err := client.Get(ctx, resourceGroup, rtName, name) if err != nil { return nil diff --git a/azurerm/resource_arm_subnet.go b/azurerm/resource_arm_subnet.go index 6d73fffe4aba..ec5b3b73d6de 100644 --- a/azurerm/resource_arm_subnet.go +++ b/azurerm/resource_arm_subnet.go @@ -4,7 +4,7 @@ import ( "fmt" "log" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/terraform/helper/schema" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" ) @@ -64,6 +64,7 @@ func resourceArmSubnet() *schema.Resource { func resourceArmSubnetCreate(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).subnetClient + ctx := meta.(*ArmClient).StopContext log.Printf("[INFO] preparing arguments for Azure ARM Subnet creation.") @@ -114,18 +115,22 @@ func resourceArmSubnetCreate(d *schema.ResourceData, meta interface{}) error { SubnetPropertiesFormat: &properties, } - _, createErr := client.CreateOrUpdate(resGroup, vnetName, name, subnet, make(chan struct{})) - err := <-createErr + future, err := client.CreateOrUpdate(ctx, resGroup, vnetName, name, subnet) if err != nil { - return err + return fmt.Errorf("Error Creating/Updating Subnet %q (VN %q / Resource Group %q): %+v", name, vnetName, resGroup, err) } - read, err := client.Get(resGroup, vnetName, name, "") + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for completion of Subnet %q (VN %q / Resource Group %q): %+v", name, vnetName, resGroup, err) + } + + read, err := client.Get(ctx, resGroup, vnetName, name, "") if err != nil { return err } if read.ID == nil { - return fmt.Errorf("Cannot read Subnet %s/%s (resource group %s) ID", vnetName, name, resGroup) + return fmt.Errorf("Cannot read ID of Subnet %q (VN %q / Resource Group %q)", vnetName, name, resGroup) } d.SetId(*read.ID) @@ -135,6 +140,7 @@ func resourceArmSubnetCreate(d *schema.ResourceData, meta interface{}) error { func resourceArmSubnetRead(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).subnetClient + ctx := meta.(*ArmClient).StopContext id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -144,7 +150,7 @@ func resourceArmSubnetRead(d *schema.ResourceData, meta interface{}) error { vnetName := id.Path["virtualNetworks"] name := id.Path["subnets"] - resp, err := client.Get(resGroup, vnetName, name, "") + resp, err := client.Get(ctx, resGroup, vnetName, name, "") if err != nil { if utils.ResponseWasNotFound(resp.Response) { @@ -180,6 +186,7 @@ func resourceArmSubnetRead(d *schema.ResourceData, meta interface{}) error { func resourceArmSubnetDelete(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).subnetClient + ctx := meta.(*ArmClient).StopContext id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -217,10 +224,17 @@ func resourceArmSubnetDelete(d *schema.ResourceData, meta interface{}) error { azureRMLockByName(name, subnetResourceName) defer azureRMUnlockByName(name, subnetResourceName) - _, deleteErr := client.Delete(resGroup, vnetName, name, make(chan struct{})) - err = <-deleteErr + future, err := client.Delete(ctx, resGroup, vnetName, name) + if err != nil { + return fmt.Errorf("Error deleting Subnet %q (VN %q / Resource Group %q): %+v", name, vnetName, resGroup, err) + } + + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for completion for Subnet %q (VN %q / Resource Group %q): %+v", name, vnetName, resGroup, err) + } - return err + return nil } func flattenSubnetIPConfigurations(ipConfigurations *[]network.IPConfiguration) []string { diff --git a/azurerm/resource_arm_subnet_test.go b/azurerm/resource_arm_subnet_test.go index b93ed0df12e7..86c0f546ba7a 100644 --- a/azurerm/resource_arm_subnet_test.go +++ b/azurerm/resource_arm_subnet_test.go @@ -9,6 +9,7 @@ import ( "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/helpers/response" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" ) @@ -199,9 +200,10 @@ func testCheckAzureRMSubnetExists(name string) resource.TestCheckFunc { return fmt.Errorf("Bad: no resource group found in state for subnet: %s", name) } - conn := testAccProvider.Meta().(*ArmClient).subnetClient + client := testAccProvider.Meta().(*ArmClient).subnetClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext - resp, err := conn.Get(resourceGroup, vnetName, name, "") + resp, err := client.Get(ctx, resourceGroup, vnetName, name, "") if err != nil { if utils.ResponseWasNotFound(resp.Response) { return fmt.Errorf("Bad: Subnet %q (resource group: %q) does not exist", name, resourceGroup) @@ -231,8 +233,11 @@ func testCheckAzureRMSubnetRouteTableExists(subnetName string, routeTableId stri return fmt.Errorf("Bad: no resource group found in state for subnet: %s", name) } - vnetConn := testAccProvider.Meta().(*ArmClient).vnetClient - vnetResp, vnetErr := vnetConn.Get(resourceGroup, vnetName, "") + networksClient := testAccProvider.Meta().(*ArmClient).vnetClient + subnetsClient := testAccProvider.Meta().(*ArmClient).subnetClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext + + vnetResp, vnetErr := networksClient.Get(ctx, resourceGroup, vnetName, "") if vnetErr != nil { return fmt.Errorf("Bad: Get on vnetClient: %+v", vnetErr) } @@ -241,9 +246,7 @@ func testCheckAzureRMSubnetRouteTableExists(subnetName string, routeTableId stri return fmt.Errorf("Bad: Vnet %q (resource group: %q) does not have subnets after update", vnetName, resourceGroup) } - conn := testAccProvider.Meta().(*ArmClient).subnetClient - - resp, err := conn.Get(resourceGroup, vnetName, name, "") + resp, err := subnetsClient.Get(ctx, resourceGroup, vnetName, name, "") if err != nil { if utils.ResponseWasNotFound(resp.Response) { return fmt.Errorf("Bad: Subnet %q (resource group: %q) does not exist", subnetName, resourceGroup) @@ -280,21 +283,26 @@ func testCheckAzureRMSubnetDisappears(name string) resource.TestCheckFunc { } client := testAccProvider.Meta().(*ArmClient).subnetClient - deleteResp, deleteErr := client.Delete(resourceGroup, vnetName, name, make(chan struct{})) - resp := <-deleteResp - err := <-deleteErr + ctx := testAccProvider.Meta().(*ArmClient).StopContext + future, err := client.Delete(ctx, resourceGroup, vnetName, name) if err != nil { - if !utils.ResponseWasNotFound(resp) { - return fmt.Errorf("Bad: Delete on subnetClient: %+v", err) + if !response.WasNotFound(future.Response()) { + return fmt.Errorf("Error deleting Subnet %q (Network %q / Resource Group %q): %+v", name, vnetName, resourceGroup, err) } } + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for completion of Subnet %q (Network %q / Resource Group %q): %+v", name, vnetName, resourceGroup, err) + } + return nil } } func testCheckAzureRMSubnetDestroy(s *terraform.State) error { client := testAccProvider.Meta().(*ArmClient).subnetClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext for _, rs := range s.RootModule().Resources { if rs.Type != "azurerm_subnet" { @@ -305,7 +313,7 @@ func testCheckAzureRMSubnetDestroy(s *terraform.State) error { vnetName := rs.Primary.Attributes["virtual_network_name"] resourceGroup := rs.Primary.Attributes["resource_group_name"] - resp, err := client.Get(resourceGroup, vnetName, name, "") + resp, err := client.Get(ctx, resourceGroup, vnetName, name, "") if err != nil { if !utils.ResponseWasNotFound(resp.Response) { return fmt.Errorf("Subnet still exists:\n%#v", resp.SubnetPropertiesFormat) diff --git a/azurerm/resource_arm_virtual_network.go b/azurerm/resource_arm_virtual_network.go index b128c51ff891..73ba85337403 100644 --- a/azurerm/resource_arm_virtual_network.go +++ b/azurerm/resource_arm_virtual_network.go @@ -2,11 +2,12 @@ package azurerm import ( "bytes" + "context" "fmt" "log" "net/http" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/terraform/helper/hashcode" "github.com/hashicorp/terraform/helper/schema" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" @@ -80,8 +81,8 @@ func resourceArmVirtualNetwork() *schema.Resource { } func resourceArmVirtualNetworkCreate(d *schema.ResourceData, meta interface{}) error { - client := meta.(*ArmClient) - vnetClient := client.vnetClient + client := meta.(*ArmClient).vnetClient + ctx := meta.(*ArmClient).StopContext log.Printf("[INFO] preparing arguments for Azure ARM virtual network creation.") @@ -89,7 +90,7 @@ func resourceArmVirtualNetworkCreate(d *schema.ResourceData, meta interface{}) e location := d.Get("location").(string) resGroup := d.Get("resource_group_name").(string) tags := d.Get("tags").(map[string]interface{}) - vnetProperties, vnetPropsErr := getVirtualNetworkProperties(d, meta) + vnetProperties, vnetPropsErr := getVirtualNetworkProperties(ctx, d, meta) if vnetPropsErr != nil { return vnetPropsErr } @@ -118,18 +119,22 @@ func resourceArmVirtualNetworkCreate(d *schema.ResourceData, meta interface{}) e azureRMLockMultipleByName(&networkSecurityGroupNames, networkSecurityGroupResourceName) defer azureRMUnlockMultipleByName(&networkSecurityGroupNames, networkSecurityGroupResourceName) - _, error := vnetClient.CreateOrUpdate(resGroup, name, vnet, make(chan struct{})) - err := <-error + future, err := client.CreateOrUpdate(ctx, resGroup, name, vnet) if err != nil { - return err + return fmt.Errorf("Error Creating/Updating Virtual Network %q (Resource Group %q): %+v", name, resGroup, err) + } + + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for completion of Virtual Network %q (Resource Group %q): %+v", name, resGroup, err) } - read, err := vnetClient.Get(resGroup, name, "") + read, err := client.Get(ctx, 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 Virtual Network %q (resource group %q) ID", name, resGroup) } d.SetId(*read.ID) @@ -138,7 +143,8 @@ func resourceArmVirtualNetworkCreate(d *schema.ResourceData, meta interface{}) e } func resourceArmVirtualNetworkRead(d *schema.ResourceData, meta interface{}) error { - vnetClient := meta.(*ArmClient).vnetClient + client := meta.(*ArmClient).vnetClient + ctx := meta.(*ArmClient).StopContext id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -147,13 +153,13 @@ func resourceArmVirtualNetworkRead(d *schema.ResourceData, meta interface{}) err resGroup := id.ResourceGroup name := id.Path["virtualNetworks"] - resp, err := vnetClient.Get(resGroup, name, "") + resp, err := client.Get(ctx, resGroup, name, "") if err != nil { if utils.ResponseWasNotFound(resp.Response) { d.SetId("") return nil } - return fmt.Errorf("Error making Read request on Azure virtual network %s: %s", name, err) + return fmt.Errorf("Error making Read request on Virtual Network %q (Resource Group %q): %+v", name, resGroup, err) } vnet := *resp.VirtualNetworkPropertiesFormat @@ -161,9 +167,12 @@ func resourceArmVirtualNetworkRead(d *schema.ResourceData, meta interface{}) err // update appropriate values d.Set("resource_group_name", resGroup) d.Set("name", resp.Name) - d.Set("location", azureRMNormalizeLocation(*resp.Location)) d.Set("address_space", vnet.AddressSpace.AddressPrefixes) + if location := resp.Location; location != nil { + d.Set("location", azureRMNormalizeLocation(*location)) + } + subnets := &schema.Set{ F: resourceAzureSubnetHash, } @@ -195,7 +204,8 @@ func resourceArmVirtualNetworkRead(d *schema.ResourceData, meta interface{}) err } func resourceArmVirtualNetworkDelete(d *schema.ResourceData, meta interface{}) error { - vnetClient := meta.(*ArmClient).vnetClient + client := meta.(*ArmClient).vnetClient + ctx := meta.(*ArmClient).StopContext id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -212,13 +222,20 @@ func resourceArmVirtualNetworkDelete(d *schema.ResourceData, meta interface{}) e azureRMLockMultipleByName(&nsgNames, virtualNetworkResourceName) defer azureRMUnlockMultipleByName(&nsgNames, virtualNetworkResourceName) - _, error := vnetClient.Delete(resGroup, name, make(chan struct{})) - err = <-error + future, err := client.Delete(ctx, resGroup, name) + if err != nil { + return fmt.Errorf("Error deleting Virtual Network %q (Resource Group %q): %+v", name, resGroup, err) + } + + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for deletion of Virtual Network %q (Resource Group %q): %+v", name, resGroup, err) + } - return err + return nil } -func getVirtualNetworkProperties(d *schema.ResourceData, meta interface{}) (*network.VirtualNetworkPropertiesFormat, error) { +func getVirtualNetworkProperties(ctx context.Context, d *schema.ResourceData, meta interface{}) (*network.VirtualNetworkPropertiesFormat, error) { // first; get address space prefixes: prefixes := []string{} for _, prefix := range d.Get("address_space").([]interface{}) { @@ -243,7 +260,7 @@ func getVirtualNetworkProperties(d *schema.ResourceData, meta interface{}) (*net // do a GET on subnet properties from the server before setting them resGroup := d.Get("resource_group_name").(string) vnetName := d.Get("name").(string) - subnetObj, err := getExistingSubnet(resGroup, vnetName, name, meta) + subnetObj, err := getExistingSubnet(ctx, resGroup, vnetName, name, meta) if err != nil { return nil, err } @@ -296,11 +313,11 @@ func resourceAzureSubnetHash(v interface{}) int { return hashcode.String(buf.String()) } -func getExistingSubnet(resGroup string, vnetName string, subnetName string, meta interface{}) (*network.Subnet, error) { +func getExistingSubnet(ctx context.Context, resGroup string, vnetName string, subnetName string, meta interface{}) (*network.Subnet, error) { //attempt to retrieve existing subnet from the server existingSubnet := network.Subnet{} subnetClient := meta.(*ArmClient).subnetClient - resp, err := subnetClient.Get(resGroup, vnetName, subnetName, "") + resp, err := subnetClient.Get(ctx, resGroup, vnetName, subnetName, "") if err != nil { if resp.StatusCode == http.StatusNotFound { diff --git a/azurerm/resource_arm_virtual_network_peering.go b/azurerm/resource_arm_virtual_network_peering.go index 81bb3818b7d9..a24fb5441835 100644 --- a/azurerm/resource_arm_virtual_network_peering.go +++ b/azurerm/resource_arm_virtual_network_peering.go @@ -5,7 +5,7 @@ import ( "log" "sync" - "github.com/Azure/azure-sdk-for-go/arm/network" + "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-09-01/network" "github.com/hashicorp/terraform/helper/schema" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" ) @@ -74,6 +74,7 @@ func resourceArmVirtualNetworkPeering() *schema.Resource { func resourceArmVirtualNetworkPeeringCreate(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).vnetPeeringsClient + ctx := meta.(*ArmClient).StopContext log.Printf("[INFO] preparing arguments for Azure ARM virtual network peering creation.") @@ -89,18 +90,22 @@ func resourceArmVirtualNetworkPeeringCreate(d *schema.ResourceData, meta interfa peerMutex.Lock() defer peerMutex.Unlock() - _, error := client.CreateOrUpdate(resGroup, vnetName, name, peer, make(chan struct{})) - err := <-error + future, err := client.CreateOrUpdate(ctx, resGroup, vnetName, name, peer) if err != nil { - return err + return fmt.Errorf("Error Creating/Updating Virtual Network Peering %q (Network %q / Resource Group %q): %+v", name, vnetName, resGroup, err) } - read, err := client.Get(resGroup, vnetName, name) + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for completion of Virtual Network Peering %q (Network %q / Resource Group %q): %+v", name, vnetName, resGroup, err) + } + + read, err := client.Get(ctx, resGroup, vnetName, name) if err != nil { return err } if read.ID == nil { - return fmt.Errorf("Cannot read Virtual Network Peering %s (resource group %s) ID", name, resGroup) + return fmt.Errorf("Cannot read ID of Virtual Network Peering %q (resource group %q)", name, resGroup) } d.SetId(*read.ID) @@ -110,6 +115,7 @@ func resourceArmVirtualNetworkPeeringCreate(d *schema.ResourceData, meta interfa func resourceArmVirtualNetworkPeeringRead(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).vnetPeeringsClient + ctx := meta.(*ArmClient).StopContext id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -119,13 +125,13 @@ func resourceArmVirtualNetworkPeeringRead(d *schema.ResourceData, meta interface vnetName := id.Path["virtualNetworks"] name := id.Path["virtualNetworkPeerings"] - resp, err := client.Get(resGroup, vnetName, name) + resp, err := client.Get(ctx, resGroup, vnetName, name) if err != nil { if utils.ResponseWasNotFound(resp.Response) { d.SetId("") return nil } - return fmt.Errorf("Error making Read request on Azure virtual network peering %s: %s", name, err) + return fmt.Errorf("Error making Read request on Azure virtual network peering %q: %+v", name, err) } peer := *resp.VirtualNetworkPeeringPropertiesFormat @@ -145,6 +151,7 @@ func resourceArmVirtualNetworkPeeringRead(d *schema.ResourceData, meta interface func resourceArmVirtualNetworkPeeringDelete(d *schema.ResourceData, meta interface{}) error { client := meta.(*ArmClient).vnetPeeringsClient + ctx := meta.(*ArmClient).StopContext id, err := parseAzureResourceID(d.Id()) if err != nil { @@ -157,8 +164,15 @@ func resourceArmVirtualNetworkPeeringDelete(d *schema.ResourceData, meta interfa peerMutex.Lock() defer peerMutex.Unlock() - _, error := client.Delete(resGroup, vnetName, name, make(chan struct{})) - err = <-error + future, err := client.Delete(ctx, resGroup, vnetName, name) + if err != nil { + return fmt.Errorf("Error deleting Virtual Network Peering %q (Network %q / RG %q): %+v", name, vnetName, resGroup, err) + } + + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for deletion of Virtual Network Peering %q (Network %q / RG %q): %+v", name, vnetName, resGroup, err) + } return err } diff --git a/azurerm/resource_arm_virtual_network_peering_test.go b/azurerm/resource_arm_virtual_network_peering_test.go index dbd219223b58..1d210ce0af24 100644 --- a/azurerm/resource_arm_virtual_network_peering_test.go +++ b/azurerm/resource_arm_virtual_network_peering_test.go @@ -118,9 +118,10 @@ func testCheckAzureRMVirtualNetworkPeeringExists(name string) resource.TestCheck } // Ensure resource group/virtual network peering combination exists in API - conn := testAccProvider.Meta().(*ArmClient).vnetPeeringsClient + client := testAccProvider.Meta().(*ArmClient).vnetPeeringsClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext - resp, err := conn.Get(resourceGroup, vnetName, name) + resp, err := client.Get(ctx, resourceGroup, vnetName, name) if err != nil { return fmt.Errorf("Bad: Get on vnetPeeringsClient: %s", err) } @@ -149,12 +150,17 @@ func testCheckAzureRMVirtualNetworkPeeringDisappears(name string) resource.TestC } // Ensure resource group/virtual network peering combination exists in API - conn := testAccProvider.Meta().(*ArmClient).vnetPeeringsClient + client := testAccProvider.Meta().(*ArmClient).vnetPeeringsClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext - _, error := conn.Delete(resourceGroup, vnetName, name, make(chan struct{})) - err := <-error + future, err := client.Delete(ctx, resourceGroup, vnetName, name) if err != nil { - return fmt.Errorf("Bad: Delete on vnetPeeringsClient: %s", err) + return fmt.Errorf("Error deleting Peering %q (NW %q / RG %q): %+v", name, vnetName, resourceGroup, err) + } + + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + return fmt.Errorf("Error waiting for deletion of Peering %q (NW %q / RG %q): %+v", name, vnetName, resourceGroup, err) } return nil @@ -162,7 +168,8 @@ func testCheckAzureRMVirtualNetworkPeeringDisappears(name string) resource.TestC } func testCheckAzureRMVirtualNetworkPeeringDestroy(s *terraform.State) error { - conn := testAccProvider.Meta().(*ArmClient).vnetPeeringsClient + client := testAccProvider.Meta().(*ArmClient).vnetPeeringsClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext for _, rs := range s.RootModule().Resources { if rs.Type != "azurerm_virtual_network_peering" { @@ -173,7 +180,7 @@ func testCheckAzureRMVirtualNetworkPeeringDestroy(s *terraform.State) error { vnetName := rs.Primary.Attributes["virtual_network_name"] resourceGroup := rs.Primary.Attributes["resource_group_name"] - resp, err := conn.Get(resourceGroup, vnetName, name) + resp, err := client.Get(ctx, resourceGroup, vnetName, name) if err != nil { return nil } diff --git a/azurerm/resource_arm_virtual_network_test.go b/azurerm/resource_arm_virtual_network_test.go index 667f7c62e2a6..72c4d685022d 100644 --- a/azurerm/resource_arm_virtual_network_test.go +++ b/azurerm/resource_arm_virtual_network_test.go @@ -10,7 +10,7 @@ import ( "github.com/hashicorp/terraform/helper/acctest" "github.com/hashicorp/terraform/helper/resource" "github.com/hashicorp/terraform/terraform" - utils "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/response" ) func init() { @@ -33,14 +33,15 @@ func testSweepVirtualNetworks(region string) error { } client := (*armClient).vnetClient + ctx := (*armClient).StopContext log.Printf("Retrieving the Virtual Networks..") - results, err := client.ListAll() + results, err := client.ListAll(ctx) if err != nil { return fmt.Errorf("Error Listing on Virtual Networks: %+v", err) } - for _, network := range *results.Value { + for _, network := range results.Values() { id, err := parseAzureResourceID(*network.ID) if err != nil { return fmt.Errorf("Error parsing Azure Resource ID %q", id) @@ -55,11 +56,18 @@ func testSweepVirtualNetworks(region string) error { } log.Printf("Deleting Virtual Network %q", name) - deleteResponse, deleteErr := client.Delete(resourceGroupName, name, make(chan struct{})) - resp := <-deleteResponse - err = <-deleteErr + future, err := client.Delete(ctx, resourceGroupName, name) if err != nil { - if utils.ResponseWasNotFound(resp) { + if response.WasNotFound(future.Response()) { + continue + } + + return err + } + + err = future.WaitForCompletion(ctx, client.Client) + if err != nil { + if response.WasNotFound(future.Response()) { continue } @@ -184,9 +192,10 @@ func testCheckAzureRMVirtualNetworkExists(name string) resource.TestCheckFunc { } // Ensure resource group/virtual network combination exists in API - conn := testAccProvider.Meta().(*ArmClient).vnetClient + client := testAccProvider.Meta().(*ArmClient).vnetClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext - resp, err := conn.Get(resourceGroup, virtualNetworkName, "") + resp, err := client.Get(ctx, resourceGroup, virtualNetworkName, "") if err != nil { return fmt.Errorf("Bad: Get on vnetClient: %s", err) } @@ -214,12 +223,17 @@ func testCheckAzureRMVirtualNetworkDisappears(name string) resource.TestCheckFun } // Ensure resource group/virtual network combination exists in API - conn := testAccProvider.Meta().(*ArmClient).vnetClient + client := testAccProvider.Meta().(*ArmClient).vnetClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext + + future, err := client.Delete(ctx, resourceGroup, virtualNetworkName) + if err != nil { + return fmt.Errorf("Error deleting Virtual Network %q (RG %q): %+v", virtualNetworkName, resourceGroup, err) + } - _, error := conn.Delete(resourceGroup, virtualNetworkName, make(chan struct{})) - err := <-error + err = future.WaitForCompletion(ctx, client.Client) if err != nil { - return fmt.Errorf("Bad: Delete on vnetClient: %s", err) + return fmt.Errorf("Error waiting for deletion of Virtual Network %q (RG %q): %+v", virtualNetworkName, resourceGroup, err) } return nil @@ -227,7 +241,8 @@ func testCheckAzureRMVirtualNetworkDisappears(name string) resource.TestCheckFun } func testCheckAzureRMVirtualNetworkDestroy(s *terraform.State) error { - conn := testAccProvider.Meta().(*ArmClient).vnetClient + client := testAccProvider.Meta().(*ArmClient).vnetClient + ctx := testAccProvider.Meta().(*ArmClient).StopContext for _, rs := range s.RootModule().Resources { if rs.Type != "azurerm_virtual_network" { @@ -237,14 +252,14 @@ func testCheckAzureRMVirtualNetworkDestroy(s *terraform.State) error { name := rs.Primary.Attributes["name"] resourceGroup := rs.Primary.Attributes["resource_group_name"] - resp, err := conn.Get(resourceGroup, name, "") + resp, err := client.Get(ctx, resourceGroup, name, "") if err != nil { return nil } if resp.StatusCode != http.StatusNotFound { - return fmt.Errorf("Virtual Network sitll exists:\n%#v", resp.VirtualNetworkPropertiesFormat) + return fmt.Errorf("Virtual Network still exists:\n%#v", resp.VirtualNetworkPropertiesFormat) } }