azurerm_redis_cache - support replicas_per_primary, redis_version, tenant_settings

azurerm/internal/services/redis/client/client.go

@@ -1,7 +1,7 @@
 package client
 
 import (
-	"github.com/Azure/azure-sdk-for-go/services/redis/mgmt/2020-06-01/redis"
+	"github.com/Azure/azure-sdk-for-go/services/redis/mgmt/2020-12-01/redis"
 	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/common"
 )
 

azurerm/internal/services/redis/redis_cache_resource.go

@@ -8,7 +8,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/Azure/azure-sdk-for-go/services/redis/mgmt/2020-06-01/redis"
+	"github.com/Azure/azure-sdk-for-go/services/redis/mgmt/2020-12-01/redis"
 	"github.com/hashicorp/go-azure-helpers/response"
 	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure"
 	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/tf"
@@ -81,21 +81,21 @@ func resourceRedisCache() *pluginsdk.Resource {
 				Type:     pluginsdk.TypeString,
 				Required: true,
 				ValidateFunc: validation.StringInSlice([]string{
-					string(redis.Basic),
-					string(redis.Standard),
-					string(redis.Premium),
+					string(redis.SkuNameBasic),
+					string(redis.SkuNameStandard),
+					string(redis.SkuNamePremium),
 				}, true),
 				DiffSuppressFunc: suppress.CaseDifference,
 			},
 
 			"minimum_tls_version": {
 				Type:     pluginsdk.TypeString,
 				Optional: true,
-				Default:  redis.OneFullStopZero,
+				Default:  redis.TLSVersionOneFullStopZero,
 				ValidateFunc: validation.StringInSlice([]string{
-					string(redis.OneFullStopZero),
-					string(redis.OneFullStopOne),
-					string(redis.OneFullStopTwo),
+					string(redis.TLSVersionOneFullStopZero),
+					string(redis.TLSVersionOneFullStopOne),
+					string(redis.TLSVersionOneFullStopTwo),
 				}, false),
 			},
 
@@ -289,10 +289,41 @@ func resourceRedisCache() *pluginsdk.Resource {
 			"replicas_per_master": {
 				Type:     pluginsdk.TypeInt,
 				Optional: true,
+				Computed: true,
 				// Can't make more than 3 replicas in portal, assuming it's a limitation
 				ValidateFunc: validation.IntBetween(1, 3),
 			},
 
+			"replicas_per_primary": {
+				Type:         pluginsdk.TypeInt,
+				Optional:     true,
+				Computed:     true,
+				ValidateFunc: validation.IntBetween(1, 3),
+			},
+
+			"tenant_settings": {
+				Type:     pluginsdk.TypeMap,
+				Optional: true,
+				Elem: &pluginsdk.Schema{
+					Type: pluginsdk.TypeString,
+				},
+			},
+
+			"redis_version": {
+				Type:         pluginsdk.TypeString,
+				Optional:     true,
+				Computed:     true,
+				ValidateFunc: validation.StringInSlice([]string{"4", "6"}, false),
+				DiffSuppressFunc: func(_, old, new string, _ *pluginsdk.ResourceData) bool {
+					n := strings.Split(old, ".")
+					if len(n) >= 1 {
+						newMajor := n[0]
+						return new == newMajor
+					}
+					return false
+				},
+			},
+
 			"tags": tags.Schema(),
 		},
 	}
@@ -333,9 +364,9 @@ func resourceRedisCacheCreate(d *pluginsdk.ResourceData, meta interface{}) error
 		return fmt.Errorf("parsing Redis Configuration: %+v", err)
 	}
 
-	publicNetworkAccess := redis.Enabled
+	publicNetworkAccess := redis.PublicNetworkAccessEnabled
 	if !d.Get("public_network_access_enabled").(bool) {
-		publicNetworkAccess = redis.Disabled
+		publicNetworkAccess = redis.PublicNetworkAccessDisabled
 	}
 
 	parameters := redis.CreateParameters{
@@ -363,6 +394,18 @@ func resourceRedisCacheCreate(d *pluginsdk.ResourceData, meta interface{}) error
 		parameters.ReplicasPerMaster = utils.Int32(int32(v.(int)))
 	}
 
+	if v, ok := d.GetOk("replicas_per_primary"); ok {
+		parameters.ReplicasPerPrimary = utils.Int32(int32(v.(int)))
+	}
+
+	if v, ok := d.GetOk("redis_version"); ok {
+		parameters.RedisVersion = utils.String(v.(string))
+	}
+
+	if v, ok := d.GetOk("tenant_settings"); ok {
+		parameters.TenantSettings = expandTenantSettings(v.(map[string]interface{}))
+	}
+
 	if v, ok := d.GetOk("private_static_ip_address"); ok {
 		parameters.StaticIP = utils.String(v.(string))
 	}
@@ -466,10 +509,28 @@ func resourceRedisCacheUpdate(d *pluginsdk.ResourceData, meta interface{}) error
 		}
 	}
 
+	if v, ok := d.GetOk("replicas_per_primary"); ok {
+		if d.HasChange("replicas_per_primary") {
+			parameters.ReplicasPerPrimary = utils.Int32(int32(v.(int)))
+		}
+	}
+
+	if v, ok := d.GetOk("redis_version"); ok {
+		if d.HasChange("redis_version") {
+			parameters.RedisVersion = utils.String(v.(string))
+		}
+	}
+
+	if v, ok := d.GetOk("tenant_settings"); ok {
+		if d.HasChange("tenant_settings") {
+			parameters.TenantSettings = expandTenantSettings(v.(map[string]interface{}))
+		}
+	}
+
 	if d.HasChange("public_network_access_enabled") {
-		publicNetworkAccess := redis.Enabled
+		publicNetworkAccess := redis.PublicNetworkAccessEnabled
 		if !d.Get("public_network_access_enabled").(bool) {
-			publicNetworkAccess = redis.Disabled
+			publicNetworkAccess = redis.PublicNetworkAccessDisabled
 		}
 		parameters.PublicNetworkAccess = publicNetworkAccess
 	}
@@ -585,8 +646,11 @@ func resourceRedisCacheRead(d *pluginsdk.ResourceData, meta interface{}) error {
 		}
 		d.Set("subnet_id", subnetId)
 
-		d.Set("public_network_access_enabled", props.PublicNetworkAccess == redis.Enabled)
+		d.Set("public_network_access_enabled", props.PublicNetworkAccess == redis.PublicNetworkAccessEnabled)
 		d.Set("replicas_per_master", props.ReplicasPerMaster)
+		d.Set("replicas_per_primary", props.ReplicasPerPrimary)
+		d.Set("redis_version", props.RedisVersion)
+		d.Set("tenant_settings", flattenTenantSettings(props.TenantSettings))
 	}
 
 	redisConfiguration, err := flattenRedisConfiguration(resp.RedisConfiguration)
@@ -774,6 +838,26 @@ func expandRedisPatchSchedule(d *pluginsdk.ResourceData) *redis.PatchSchedule {
 	return &schedule
 }
 
+func expandTenantSettings(input map[string]interface{}) map[string]*string {
+	output := make(map[string]*string, len(input))
+
+	for i, v := range input {
+		output[i] = utils.String(v.(string))
+	}
+	return output
+}
+
+func flattenTenantSettings(input map[string]*string) map[string]*string {
+	output := make(map[string]*string, len(input))
+
+	for i, v := range input {
+		if v == nil {
+			continue
+		}
+		output[i] = v
+	}
+	return output
+}
 func flattenRedisConfiguration(input map[string]*string) ([]interface{}, error) {
 	outputs := make(map[string]interface{}, len(input))
 

azurerm/internal/services/redis/redis_cache_resource_test.go

@@ -410,6 +410,48 @@ func TestAccRedisCache_ReplicasPerMaster(t *testing.T) {
 	})
 }
 
+func TestAccRedisCache_ReplicasPerPrimary(t *testing.T) {
+	data := acceptance.BuildTestData(t, "azurerm_redis_cache", "test")
+	r := RedisCacheResource{}
+
+	data.ResourceTest(t, r, []acceptance.TestStep{
+		{
+			Config: r.replicasPerPrimary(data),
+			Check: acceptance.ComposeTestCheckFunc(
+				check.That(data.ResourceName).ExistsInAzure(r),
+			),
+		},
+	})
+}
+
+func TestAccRedisCache_RedisVersion(t *testing.T) {
+	data := acceptance.BuildTestData(t, "azurerm_redis_cache", "test")
+	r := RedisCacheResource{}
+
+	data.ResourceTest(t, r, []acceptance.TestStep{
+		{
+			Config: r.redisVersion(data),
+			Check: acceptance.ComposeTestCheckFunc(
+				check.That(data.ResourceName).ExistsInAzure(r),
+			),
+		},
+	})
+}
+
+func TestAccRedisCache_TenantSettings(t *testing.T) {
+	data := acceptance.BuildTestData(t, "azurerm_redis_cache", "test")
+	r := RedisCacheResource{}
+
+	data.ResourceTest(t, r, []acceptance.TestStep{
+		{
+			Config: r.tenantSettings(data),
+			Check: acceptance.ComposeTestCheckFunc(
+				check.That(data.ResourceName).ExistsInAzure(r),
+			),
+		},
+	})
+}
+
 func (t RedisCacheResource) Exists(ctx context.Context, clients *clients.Client, state *pluginsdk.InstanceState) (*bool, error) {
 	id, err := parse.CacheID(state.ID)
 	if err != nil {
@@ -1040,6 +1082,80 @@ resource "azurerm_redis_cache" "test" {
 `, data.RandomInteger, data.Locations.Primary, data.RandomInteger)
 }
 
+func (RedisCacheResource) replicasPerPrimary(data acceptance.TestData) string {
+	return fmt.Sprintf(`
+provider "azurerm" {
+  features {}
+}
+
+resource "azurerm_resource_group" "test" {
+  name     = "acctestRG-redis-%d"
+  location = "%s"
+}
+
+resource "azurerm_redis_cache" "test" {
+  name                 = "acctestRedis-%d"
+  location             = azurerm_resource_group.test.location
+  resource_group_name  = azurerm_resource_group.test.name
+  capacity             = 3
+  family               = "P"
+  sku_name             = "Premium"
+  enable_non_ssl_port  = false
+  replicas_per_primary = 3
+}
+`, data.RandomInteger, data.Locations.Primary, data.RandomInteger)
+}
+
+func (RedisCacheResource) redisVersion(data acceptance.TestData) string {
+	return fmt.Sprintf(`
+provider "azurerm" {
+  features {}
+}
+
+resource "azurerm_resource_group" "test" {
+  name     = "acctestRG-redis-%d"
+  location = "%s"
+}
+
+resource "azurerm_redis_cache" "test" {
+  name                = "acctestRedis-%d"
+  location            = azurerm_resource_group.test.location
+  resource_group_name = azurerm_resource_group.test.name
+  capacity            = 3
+  family              = "P"
+  sku_name            = "Premium"
+  enable_non_ssl_port = false
+  redis_version       = "4"
+}
+`, data.RandomInteger, data.Locations.Primary, data.RandomInteger)
+}
+
+func (RedisCacheResource) tenantSettings(data acceptance.TestData) string {
+	return fmt.Sprintf(`
+provider "azurerm" {
+  features {}
+}
+
+resource "azurerm_resource_group" "test" {
+  name     = "acctestRG-redis-%d"
+  location = "%s"
+}
+
+resource "azurerm_redis_cache" "test" {
+  name                = "acctestRedis-%d"
+  location            = azurerm_resource_group.test.location
+  resource_group_name = azurerm_resource_group.test.name
+  capacity            = 3
+  family              = "P"
+  sku_name            = "Premium"
+  enable_non_ssl_port = false
+  tenant_settings = {
+    config = "config"
+  }
+}
+`, data.RandomInteger, data.Locations.Primary, data.RandomInteger)
+}
+
 func testCheckSSLInConnectionString(resourceName string, propertyName string, requireSSL bool) acceptance.TestCheckFunc {
 	return func(s *acceptance.State) error {
 		// Ensure we have enough information in state to look up in API

azurerm/internal/services/redis/redis_firewall_rule_resource.go

@@ -5,7 +5,7 @@ import (
 	"log"
 	"time"
 
-	"github.com/Azure/azure-sdk-for-go/services/redis/mgmt/2020-06-01/redis"
+	"github.com/Azure/azure-sdk-for-go/services/redis/mgmt/2020-12-01/redis"
 	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure"
 	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/tf"
 	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients"
@@ -95,7 +95,7 @@ func resourceRedisFirewallRuleCreateUpdate(d *pluginsdk.ResourceData, meta inter
 		}
 	}
 
-	parameters := redis.FirewallRuleCreateParameters{
+	parameters := redis.FirewallRule{
 		FirewallRuleProperties: &redis.FirewallRuleProperties{
 			StartIP: utils.String(startIP),
 			EndIP:   utils.String(endIP),

azurerm/internal/services/redis/redis_linked_server_resource.go

@@ -6,7 +6,7 @@ import (
 	"log"
 	"time"
 
-	"github.com/Azure/azure-sdk-for-go/services/redis/mgmt/2020-06-01/redis"
+	"github.com/Azure/azure-sdk-for-go/services/redis/mgmt/2020-12-01/redis"
 	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure"
 	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/tf"
 	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients"
@@ -30,10 +30,10 @@ func resourceRedisLinkedServer() *pluginsdk.Resource {
 		}),
 
 		Timeouts: &pluginsdk.ResourceTimeout{
-			Create: pluginsdk.DefaultTimeout(30 * time.Minute),
+			Create: pluginsdk.DefaultTimeout(60 * time.Minute),
 			Read:   pluginsdk.DefaultTimeout(5 * time.Minute),
-			Update: pluginsdk.DefaultTimeout(30 * time.Minute),
-			Delete: pluginsdk.DefaultTimeout(30 * time.Minute),
+			Update: pluginsdk.DefaultTimeout(60 * time.Minute),
+			Delete: pluginsdk.DefaultTimeout(60 * time.Minute),
 		},
 
 		Schema: map[string]*pluginsdk.Schema{