[NEW RESOURCE] SQL ElasticPool using 2017-10-01-preview API

azurerm/config.go

@@ -47,6 +47,7 @@ import (
 	"github.com/Azure/azure-sdk-for-go/services/preview/resources/mgmt/2018-03-01-preview/management"
 	"github.com/Azure/azure-sdk-for-go/services/preview/security/mgmt/2017-08-01-preview/security"
 	"github.com/Azure/azure-sdk-for-go/services/preview/sql/mgmt/2015-05-01-preview/sql"
+	MsSql "github.com/Azure/azure-sdk-for-go/services/preview/sql/mgmt/2017-10-01-preview/sql"
 	"github.com/Azure/azure-sdk-for-go/services/recoveryservices/mgmt/2016-06-01/backup"
 	"github.com/Azure/azure-sdk-for-go/services/recoveryservices/mgmt/2016-06-01/recoveryservices"
 	"github.com/Azure/azure-sdk-for-go/services/redis/mgmt/2018-03-01/redis"
@@ -181,10 +182,12 @@ type ArmClient struct {
 	sqlDatabasesClient                       sql.DatabasesClient
 	sqlDatabaseThreatDetectionPoliciesClient sql.DatabaseThreatDetectionPoliciesClient
 	sqlElasticPoolsClient                    sql.ElasticPoolsClient
-	sqlFirewallRulesClient                   sql.FirewallRulesClient
-	sqlServersClient                         sql.ServersClient
-	sqlServerAzureADAdministratorsClient     sql.ServerAzureADAdministratorsClient
-	sqlVirtualNetworkRulesClient             sql.VirtualNetworkRulesClient
+	// Client for the new 2017-10-01-preview SQL API which implements vCore, DTU, and Azure data standards
+	msSqlElasticPoolsClient              MsSql.ElasticPoolsClient
+	sqlFirewallRulesClient               sql.FirewallRulesClient
+	sqlServersClient                     sql.ServersClient
+	sqlServerAzureADAdministratorsClient sql.ServerAzureADAdministratorsClient
+	sqlVirtualNetworkRulesClient         sql.VirtualNetworkRulesClient
 
 	// Data Lake Store
 	dataLakeStoreAccountClient       storeAccount.AccountsClient
@@ -790,6 +793,10 @@ func (c *ArmClient) registerDatabases(endpoint, subscriptionId string, auth auto
 	c.configureClient(&sqlEPClient.Client, auth)
 	c.sqlElasticPoolsClient = sqlEPClient
 
+	MsSqlEPClient := MsSql.NewElasticPoolsClientWithBaseURI(endpoint, subscriptionId)
+	c.configureClient(&MsSqlEPClient.Client, auth)
+	c.msSqlElasticPoolsClient = MsSqlEPClient
+
 	sqlSrvClient := sql.NewServersClientWithBaseURI(endpoint, subscriptionId)
 	c.configureClient(&sqlSrvClient.Client, auth)
 	c.sqlServersClient = sqlSrvClient

azurerm/helpers/azure/validate.go

@@ -2,6 +2,9 @@ package azure
 
 import (
 	"fmt"
+	"regexp"
+
+	"github.com/hashicorp/terraform/helper/schema"
 )
 
 func ValidateResourceID(i interface{}, k string) (_ []string, errors []error) {
@@ -32,3 +35,47 @@ func ValidateResourceIDOrEmpty(i interface{}, k string) (_ []string, errors []er
 
 	return ValidateResourceID(i, k)
 }
+
+//true for a resource ID or an empty string
+func ValidateMsSqlServiceName(i interface{}, k string) (_ []string, errors []error) {
+	v, ok := i.(string)
+	if !ok {
+		errors = append(errors, fmt.Errorf("expected type of %q to be string", k))
+		return nil, errors
+	}
+
+	//First, second, and last characters must be a letter or number with a total length between 3 to 50 lowercase characters.
+	r := regexp.MustCompile("^[a-z0-9]{2}[-a-z0-9]{0,47}[a-z0-9]{1}$")
+	if !r.MatchString(v) {
+		errors = append(errors, fmt.Errorf("%q must be 3 - 50 characters in length", k))
+		errors = append(errors, fmt.Errorf("%q first, second, and last characters must be a lowercase letter or number", k))
+		errors = append(errors, fmt.Errorf("%q can only contain lowercase letters, numbers and hyphens", k))
+	}
+
+	//No consecutive dashes.
+	r = regexp.MustCompile("(--)")
+	if r.MatchString(v) {
+		errors = append(errors, fmt.Errorf("%q must not contain any consecutive hyphens", k))
+	}
+
+	return nil, errors
+}
+
+// FloatAtLeast returns a SchemaValidateFunc which tests if the provided value
+// is of type float64 and is at least min (inclusive)
+func FloatAtLeast(min float64) schema.SchemaValidateFunc {
+	return func(i interface{}, k string) (_ []string, errors []error) {
+		v, ok := i.(float64)
+		if !ok {
+			errors = append(errors, fmt.Errorf("expected type of %s to be float64", k))
+			return nil, errors
+		}
+
+		if v < min {
+			errors = append(errors, fmt.Errorf("expected %s to be at least (%f), got %f", k, min, v))
+			return nil, errors
+		}
+
+		return nil, errors
+	}
+}

azurerm/helpers/azure/validate_test.go

@@ -90,3 +90,142 @@ func TestAzureResourceIDOrEmpty(t *testing.T) {
 		})
 	}
 }
+
+func TestAzureValidateMsSqlServiceName(t *testing.T) {
+	cases := []struct {
+		ServiceName string
+		Errors      int
+	}{
+		{
+			ServiceName: "as",
+			Errors:      3,
+		},
+		{
+			ServiceName: "Asd",
+			Errors:      3,
+		},
+		{
+			ServiceName: "asd",
+			Errors:      0,
+		},
+		{
+			ServiceName: "-asd",
+			Errors:      3,
+		},
+		{
+			ServiceName: "asd-",
+			Errors:      3,
+		},
+		{
+			ServiceName: "asd-1",
+			Errors:      0,
+		},
+		{
+			ServiceName: "asd--1",
+			Errors:      1,
+		},
+		{
+			ServiceName: "asd--1-",
+			Errors:      4,
+		},
+		{
+			ServiceName: "asdfghjklzasdfghjklzasdfghjklzasdfghjklzasdfghjklz",
+			Errors:      0,
+		},
+		{
+			ServiceName: "asdfghjklzasdfghjklzasdfghjklzasdfghjklzasdfghjklz1",
+			Errors:      3,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.ServiceName, func(t *testing.T) {
+			_, errors := ValidateMsSqlServiceName(tc.ServiceName, "name")
+
+			if len(errors) < tc.Errors {
+				t.Fatalf("Expected TestAzureValidateMsSqlServiceName to have %d not %d errors for %q", tc.Errors, len(errors), tc.ServiceName)
+			}
+		})
+	}
+}
+
+func TestAzureFloatAtLeast(t *testing.T) {
+	cases := []struct {
+		Name        string
+		MinValue    float64
+		ActualValue float64
+		Errors      int
+	}{
+		{
+			Name:        "Min_Full_Stop_Zero_Greater",
+			MinValue:    0.0,
+			ActualValue: 1.0,
+			Errors:      0,
+		},
+		{
+			Name:        "Min_One_Full_Stop_Zero_Lesser",
+			MinValue:    1.0,
+			ActualValue: 0.0,
+			Errors:      1,
+		},
+		{
+			Name:        "Min_Full_Stop_Two_Five_Greater",
+			MinValue:    0.25,
+			ActualValue: 0.26,
+			Errors:      0,
+		},
+		{
+			Name:        "Min_Full_Stop_Two_Five_Equal",
+			MinValue:    0.25,
+			ActualValue: 0.25,
+			Errors:      0,
+		},
+		{
+			Name:        "Min_Full_Stop_Two_Five_Lesser",
+			MinValue:    0.25,
+			ActualValue: 0.24,
+			Errors:      1,
+		},
+		{
+			Name:        "Min_Full_Stop_Long_Zero_Lesser",
+			MinValue:    0.0000000000000000000000000000000000000001,
+			ActualValue: 0,
+			Errors:      1,
+		},
+		{
+			Name:        "Min_Full_Stop_Long_Greater",
+			MinValue:    0.0000000000000000000000000000000000000001,
+			ActualValue: -0,
+			Errors:      1,
+		},
+		{
+			Name:        "Min_Negative_Full_Stop_Two_Five_Greater",
+			MinValue:    -0.25,
+			ActualValue: 1,
+			Errors:      0,
+		},
+		{
+			Name:        "Min_Zero_No_Full_Stop_Equal",
+			MinValue:    0,
+			ActualValue: -0,
+			Errors:      0,
+		},
+		{
+			Name:        "Min_Negative_Full_Stop_Two_Five_Lesser",
+			MinValue:    -0.25,
+			ActualValue: -0.26,
+			Errors:      1,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.Name, func(t *testing.T) {
+			validateFunc := FloatAtLeast(tc.MinValue)
+			_, errors := validateFunc(tc.ActualValue, "floatValue")
+
+			if len(errors) < tc.Errors {
+				t.Fatalf("Expected FloatAtLeast to have %d not %d errors for %q", tc.Errors, len(errors), tc.Name)
+			}
+		})
+	}
+}

azurerm/provider.go

@@ -280,6 +280,7 @@ func Provider() terraform.ResourceProvider {
 			"azurerm_scheduler_job_collection":                                               resourceArmSchedulerJobCollection(),
 			"azurerm_sql_database":                                                           resourceArmSqlDatabase(),
 			"azurerm_sql_elasticpool":                                                        resourceArmSqlElasticPool(),
+			"azurerm_mssql_elasticpool":                                                      resourceArmMsSqlElasticPool(),
 			"azurerm_sql_firewall_rule":                                                      resourceArmSqlFirewallRule(),
 			"azurerm_sql_active_directory_administrator":                                     resourceArmSqlAdministrator(),
 			"azurerm_sql_server":                                                             resourceArmSqlServer(),