merge upstream into my fork

CHANGELOG.md

@@ -1,8 +1,26 @@
 ## 1.0.0 (Unreleased)
 
+FEATURES:
+
+* **New Data Source:** `azurerm_virtual_network` [GH-533]
+* **New Resource:** `azurerm_management_lock` [GH-575]
+* **New Resource:** `azurerm_network_watcher` [GH-571]
+
 IMPROVEMENTS:
 
-* `azurerm_eventhub_namespace`: capacity can now be configured up to 20 [GH-556]
+* authentication - add support for the latest Azure CLI configuration [GH-573]
+* authentication - conditional loading of the Subscription ID / Tenant ID / Environment [GH-574]
+* core - appending additions to the User Agent, so we don't overwrite the Go SDK User Agent info [GH-587]
+* core: Upgrading to v11.2.2-beta of the Azure SDK for Go [GH-594]
+* `azurerm_app_service` - exposing the Default Hostname as a Computed field [GH-612]
+* `azurerm_eventhub_namespace` - capacity can now be configured up to 20 [GH-556]
+* `azurerm_eventhub_namespace` - support for AutoInflating/MaximumThroughputCapacity [GH-569]
+* `azurerm_image` - fixing an out of index error when flattening image data disks [GH-589]
+* `azurerm_local_network_gateway` - support for BGP Settings [GH-611]
+* `azurerm_virtual_machine` - removing the deprecated `diagnostics_profile` field [GH-593]
+* `azurerm_virtual_machine` - support for managed service identity [GH-482]
+* `azurerm_virtual_machine_scale_set` - Support for updating the customData field [GH-559]
+* `azurerm_virtual_machine_scale_set` - ensuring changes to the `settings` object are detected [GH-609]
 
 ## 0.3.3 (November 14, 2017)
 

azurerm/azurerm_sweeper_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/authentication"
 )
 
 func TestMain(m *testing.M) {
@@ -29,7 +30,7 @@ func buildConfigForSweepers() (*ArmClient, error) {
 		return nil, fmt.Errorf("ARM_SUBSCRIPTION_ID, ARM_CLIENT_ID, ARM_CLIENT_SECRET and ARM_TENANT_ID must be set for acceptance tests")
 	}
 
-	config := &Config{
+	config := &authentication.Config{
 		SubscriptionID:           subscriptionID,
 		ClientID:                 clientID,
 		ClientSecret:             clientSecret,
@@ -38,7 +39,7 @@ func buildConfigForSweepers() (*ArmClient, error) {
 		SkipProviderRegistration: false,
 	}
 
-	return config.getArmClient()
+	return getArmClient(config)
 }
 
 func shouldSweepAcceptanceTestResource(name string, resourceLocation string, region string) bool {

azurerm/config.go

@@ -28,6 +28,7 @@ import (
 	"github.com/Azure/azure-sdk-for-go/arm/operationalinsights"
 	"github.com/Azure/azure-sdk-for-go/arm/postgresql"
 	"github.com/Azure/azure-sdk-for-go/arm/redis"
+	"github.com/Azure/azure-sdk-for-go/arm/resources/locks"
 	"github.com/Azure/azure-sdk-for-go/arm/resources/resources"
 	"github.com/Azure/azure-sdk-for-go/arm/resources/subscriptions"
 	"github.com/Azure/azure-sdk-for-go/arm/scheduler"
@@ -43,6 +44,7 @@ import (
 	"github.com/Azure/go-autorest/autorest/adal"
 	"github.com/Azure/go-autorest/autorest/azure"
 	"github.com/hashicorp/terraform/terraform"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/authentication"
 )
 
 // ArmClient contains the handles to all the specific Azure Resource Manager
@@ -160,6 +162,12 @@ type ArmClient struct {
 	sqlElasticPoolsClient          sql.ElasticPoolsClient
 	sqlFirewallRulesClient         sql.FirewallRulesClient
 	sqlServersClient               sql.ServersClient
+
+	// Networking
+	watcherClient network.WatchersClient
+
+	// Resources
+	managementLocksClient locks.ManagementLocksClient
 }
 
 func withRequestLogging() autorest.SendDecorator {
@@ -191,16 +199,22 @@ func withRequestLogging() autorest.SendDecorator {
 }
 
 func setUserAgent(client *autorest.Client) {
-	version := terraform.VersionString()
-	client.UserAgent = fmt.Sprintf("HashiCorp-Terraform-v%s", version)
+	tfVersion := fmt.Sprintf("HashiCorp-Terraform-v%s", terraform.VersionString())
+
+	// if the user agent already has a value append the Terraform user agent string
+	if curUserAgent := client.UserAgent; curUserAgent != "" {
+		client.UserAgent = fmt.Sprintf("%s;%s", curUserAgent, tfVersion)
+	} else {
+		client.UserAgent = tfVersion
+	}
 
-	// append the CloudShell version to the user agent
+	// append the CloudShell version to the user agent if it exists
 	if azureAgent := os.Getenv("AZURE_HTTP_USER_AGENT"); azureAgent != "" {
 		client.UserAgent = fmt.Sprintf("%s;%s", client.UserAgent, azureAgent)
 	}
 }
 
-func (c *Config) getAuthorizationToken(oauthConfig *adal.OAuthConfig, endpoint string) (*autorest.BearerAuthorizer, error) {
+func getAuthorizationToken(c *authentication.Config, oauthConfig *adal.OAuthConfig, endpoint string) (*autorest.BearerAuthorizer, error) {
 	useServicePrincipal := c.ClientSecret != ""
 
 	if useServicePrincipal {
@@ -232,7 +246,7 @@ func (c *Config) getAuthorizationToken(oauthConfig *adal.OAuthConfig, endpoint s
 
 // getArmClient is a helper method which returns a fully instantiated
 // *ArmClient based on the Config's current settings.
-func (c *Config) getArmClient() (*ArmClient, error) {
+func getArmClient(c *authentication.Config) (*ArmClient, error) {
 	// detect cloud from environment
 	env, envErr := azure.EnvironmentFromName(c.Environment)
 	if envErr != nil {
@@ -267,21 +281,21 @@ func (c *Config) getArmClient() (*ArmClient, error) {
 
 	// Resource Manager endpoints
 	endpoint := env.ResourceManagerEndpoint
-	auth, err := c.getAuthorizationToken(oauthConfig, endpoint)
+	auth, err := getAuthorizationToken(c, oauthConfig, endpoint)
 	if err != nil {
 		return nil, err
 	}
 
 	// Graph Endpoints
 	graphEndpoint := env.GraphEndpoint
-	graphAuth, err := c.getAuthorizationToken(oauthConfig, graphEndpoint)
+	graphAuth, err := getAuthorizationToken(c, oauthConfig, graphEndpoint)
 	if err != nil {
 		return nil, err
 	}
 
 	// Key Vault Endpoints
 	keyVaultAuth := autorest.NewBearerAuthorizerCallback(sender, func(tenantID, resource string) (*autorest.BearerAuthorizer, error) {
-		keyVaultSpt, err := c.getAuthorizationToken(oauthConfig, resource)
+		keyVaultSpt, err := getAuthorizationToken(c, oauthConfig, resource)
 		if err != nil {
 			return nil, err
 		}
@@ -655,11 +669,22 @@ func (c *Config) getArmClient() (*ArmClient, error) {
 	client.registerDatabases(endpoint, c.SubscriptionID, auth, sender)
 	client.registerDisks(endpoint, c.SubscriptionID, auth, sender)
 	client.registerKeyVaultClients(endpoint, c.SubscriptionID, auth, keyVaultAuth, sender)
+	client.registerNetworkingClients(endpoint, c.SubscriptionID, auth, sender)
 	client.registerRedisClients(endpoint, c.SubscriptionID, auth, sender)
+	client.registerResourcesClients(endpoint, c.SubscriptionID, auth, sender)
 
 	return &client, nil
 }
 
+func (c *ArmClient) registerNetworkingClients(endpoint, subscriptionId string, auth autorest.Authorizer, sender autorest.Sender) {
+	// TODO: move the other networking stuff in here, gradually
+	watchersClient := network.NewWatchersClientWithBaseURI(endpoint, subscriptionId)
+	setUserAgent(&watchersClient.Client)
+	watchersClient.Authorizer = auth
+	watchersClient.Sender = sender
+	c.watcherClient = watchersClient
+}
+
 func (c *ArmClient) registerAuthentication(endpoint, graphEndpoint, subscriptionId, tenantId string, auth, graphAuth autorest.Authorizer, sender autorest.Sender) {
 	spc := graphrbac.NewServicePrincipalsClientWithBaseURI(graphEndpoint, tenantId)
 	setUserAgent(&spc.Client)
@@ -805,6 +830,14 @@ func (c *ArmClient) registerRedisClients(endpoint, subscriptionId string, auth a
 	c.redisPatchSchedulesClient = patchSchedulesClient
 }
 
+func (c *ArmClient) registerResourcesClients(endpoint, subscriptionId string, auth autorest.Authorizer, sender autorest.Sender) {
+	locksClient := locks.NewManagementLocksClientWithBaseURI(endpoint, subscriptionId)
+	setUserAgent(&locksClient.Client)
+	locksClient.Authorizer = auth
+	locksClient.Sender = sender
+	c.managementLocksClient = locksClient
+}
+
 func (armClient *ArmClient) getKeyForStorageAccount(resourceGroupName, storageAccountName string) (string, bool, error) {
 	accountKeys, err := armClient.storageServiceClient.ListKeys(resourceGroupName, storageAccountName)
 	if accountKeys.StatusCode == http.StatusNotFound {

azurerm/data_source_virtual_network.go

@@ -0,0 +1,132 @@
+package azurerm
+
+import (
+	"fmt"
+
+	"github.com/Azure/azure-sdk-for-go/arm/network"
+	"github.com/hashicorp/terraform/helper/schema"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils"
+)
+
+func dataSourceArmVirtualNetwork() *schema.Resource {
+	return &schema.Resource{
+		Read: dataSourceArmVnetRead,
+		Schema: map[string]*schema.Schema{
+			"name": {
+				Type:     schema.TypeString,
+				Required: true,
+			},
+
+			"resource_group_name": {
+				Type:     schema.TypeString,
+				Required: true,
+			},
+
+			"address_spaces": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem: &schema.Schema{
+					Type: schema.TypeString,
+				},
+			},
+
+			"dns_servers": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem: &schema.Schema{
+					Type: schema.TypeString,
+				},
+			},
+
+			"subnets": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem: &schema.Schema{
+					Type: schema.TypeString,
+				},
+			},
+
+			"vnet_peerings": {
+				Type:     schema.TypeMap,
+				Computed: true,
+			},
+		},
+	}
+}
+
+func dataSourceArmVnetRead(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*ArmClient).vnetClient
+
+	resGroup := d.Get("resource_group_name").(string)
+	name := d.Get("name").(string)
+
+	resp, err := client.Get(resGroup, name, "")
+	if err != nil {
+		if utils.ResponseWasNotFound(resp.Response) {
+			return fmt.Errorf("Error making Read request on Azure virtual network %q (resource group %q): %+v", name, resGroup, err)
+		}
+		return err
+	}
+
+	d.SetId(*resp.ID)
+
+	if props := resp.VirtualNetworkPropertiesFormat; props != nil {
+		addressSpaces := flattenVnetAddressPrefixes(props.AddressSpace.AddressPrefixes)
+		if err := d.Set("address_spaces", addressSpaces); err != nil {
+			return err
+		}
+
+		dnsServers := flattenVnetAddressPrefixes(props.DhcpOptions.DNSServers)
+		if err := d.Set("dns_servers", dnsServers); err != nil {
+			return err
+		}
+
+		subnets := flattenVnetSubnetsNames(props.Subnets)
+		if err := d.Set("subnets", subnets); err != nil {
+			return err
+		}
+
+		vnetPeerings := flattenVnetPeerings(props.VirtualNetworkPeerings)
+		if err := d.Set("vnet_peerings", vnetPeerings); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func flattenVnetAddressPrefixes(input *[]string) []interface{} {
+	prefixes := make([]interface{}, 0)
+
+	if myprefixes := input; myprefixes != nil {
+		for _, prefix := range *myprefixes {
+			prefixes = append(prefixes, prefix)
+		}
+	}
+	return prefixes
+}
+
+func flattenVnetSubnetsNames(input *[]network.Subnet) []interface{} {
+	subnets := make([]interface{}, 0)
+
+	if mysubnets := input; mysubnets != nil {
+		for _, subnet := range *mysubnets {
+			subnets = append(subnets, *subnet.Name)
+		}
+	}
+	return subnets
+}
+
+func flattenVnetPeerings(input *[]network.VirtualNetworkPeering) map[string]interface{} {
+	output := make(map[string]interface{}, 0)
+
+	if peerings := input; peerings != nil {
+		for _, vnetpeering := range *peerings {
+			key := *vnetpeering.Name
+			value := *vnetpeering.RemoteVirtualNetwork.ID
+
+			output[key] = value
+
+		}
+	}
+	return output
+}