Add Valkey engine support for ElastiCache resources

Fixes #39641

Signed-off-by: Aurel Canciu <[email protected]>

.changelog/39745.txt

@@ -0,0 +1,15 @@
+```release-note:enhancement
+resource/aws_elasticache_global_replication_group: Add `valkey` as valid engine option.
+```
+
+```release-note:enhancement
+resource/aws_elasticache_replication_group: Add `valkey` as valid engine option.
+```
+
+```release-note:enhancement
+resource/aws_elasticache_serverless_cache: Add `valkey` as valid engine option.
+```
+
+```release-note:enhancement
+data-source/aws_elasticache_reserved_cache_node_offering: Allow `valkey` as valid `product_description` value.
+```

internal/service/elasticache/cluster.go

@@ -627,6 +627,11 @@ func resourceClusterUpdate(ctx context.Context, d *schema.ResourceData, meta int
  requestUpdate = true
  }
 
+ if d.HasChange(names.AttrEngine) {
+ input.Engine = aws.String(d.Get(names.AttrEngine).(string))
+ requestUpdate = true
+ }
+
  if d.HasChange(names.AttrEngineVersion) {
  input.EngineVersion = aws.String(d.Get(names.AttrEngineVersion).(string))
  requestUpdate = true
@@ -974,11 +979,16 @@ func setFromCacheCluster(d *schema.ResourceData, c *awstypes.CacheCluster) error
  d.Set("node_type", c.CacheNodeType)
 
  d.Set(names.AttrEngine, c.Engine)
- if aws.ToString(c.Engine) == engineRedis {
+ switch aws.ToString(c.Engine) {
+ case engineValkey:
  if err := setEngineVersionRedis(d, c.EngineVersion); err != nil {
  return err // nosemgrep:ci.bare-error-returns
  }
- } else {
+ case engineRedis:
+ if err := setEngineVersionValkey(d, c.EngineVersion); err != nil {
+ return err // nosemgrep:ci.bare-error-returns
+ }
+ default:
  setEngineVersionMemcached(d, c.EngineVersion)
  }
  d.Set(names.AttrAutoMinorVersionUpgrade, strconv.FormatBool(aws.ToBool(c.AutoMinorVersionUpgrade)))
@@ -1010,13 +1020,14 @@ func clusterValidateAZMode(_ context.Context, diff *schema.ResourceDiff, v inter
 
 // clusterValidateNumCacheNodes validates that `num_cache_nodes` is 1 when `engine` is "redis"
 func clusterValidateNumCacheNodes(_ context.Context, diff *schema.ResourceDiff, v interface{}) error {
- if v, ok := diff.GetOk(names.AttrEngine); !ok || v.(string) == engineMemcached {
+ engine, ok := diff.GetOk(names.AttrEngine)
+ if !ok || engine.(string) == engineMemcached {
  return nil
  }
  if v, ok := diff.GetOk("num_cache_nodes"); !ok || v.(int) == 1 {
  return nil
  }
- return errors.New(`engine "redis" does not support num_cache_nodes > 1`)
+ return fmt.Errorf(`engine "%s" does not support num_cache_nodes > 1`, engine.(string))
 }
 
 // clusterForceNewOnMemcachedNodeTypeChange causes re-creation when `node_type` is changed and `engine` is "memcached"
@@ -1026,15 +1037,15 @@ func clusterForceNewOnMemcachedNodeTypeChange(_ context.Context, diff *schema.Re
  if diff.Id() == "" || !diff.HasChange("node_type") {
  return nil
  }
- if v, ok := diff.GetOk(names.AttrEngine); !ok || v.(string) == engineRedis {
+ if v, ok := diff.GetOk(names.AttrEngine); !ok || v.(string) == engineRedis || v.(string) == engineValkey {
  return nil
  }
  return diff.ForceNew("node_type")
 }
 
 // clusterValidateMemcachedSnapshotIdentifier validates that `final_snapshot_identifier` is not set when `engine` is "memcached"
 func clusterValidateMemcachedSnapshotIdentifier(_ context.Context, diff *schema.ResourceDiff, v interface{}) error {
- if v, ok := diff.GetOk(names.AttrEngine); !ok || v.(string) == engineRedis {
+ if v, ok := diff.GetOk(names.AttrEngine); !ok || v.(string) == engineRedis || v.(string) == engineValkey {
  return nil
  }
  if _, ok := diff.GetOk(names.AttrFinalSnapshotIdentifier); !ok {

internal/service/elasticache/consts.go

@@ -6,13 +6,15 @@ package elasticache
 const (
  engineMemcached = "memcached"
  engineRedis = "redis"
+ engineValkey = "valkey"
 )
 
 // engine_Values returns all elements of the Engine enum
 func engine_Values() []string {
  return []string{
  engineMemcached,
  engineRedis,
+ engineValkey,
  }
 }
 

internal/service/elasticache/engine_version.go

@@ -56,6 +56,24 @@ func validRedisVersionString(v any, k string) (ws []string, errors []error) {
  return
 }
 
+const (
+ valkeyVersionRegexpPattern = `^[7-9]\.[[:digit:]]+$`
+)
+
+var (
+ valkeyVersionRegexp = regexache.MustCompile(valkeyVersionRegexpPattern)
+)
+
+func validValkeyVersionString(v any, k string) (ws []string, errors []error) {
+ value := v.(string)
+
+ if !valkeyVersionRegexp.MatchString(value) {
+ errors = append(errors, fmt.Errorf("%s: %s is invalid. For Valkey use <major>.<minor>.", k, value))
+ }
+
+ return
+}
+
 // customizeDiffValidateClusterEngineVersion validates the correct format for `engine_version`, based on `engine`
 func customizeDiffValidateClusterEngineVersion(_ context.Context, diff *schema.ResourceDiff, _ any) error {
  engineVersion, ok := diff.GetOk(names.AttrEngineVersion)
@@ -70,11 +88,15 @@ func customizeDiffValidateClusterEngineVersion(_ context.Context, diff *schema.R
 func validateClusterEngineVersion(engine, engineVersion string) error {
  // Memcached: Versions in format <major>.<minor>.<patch>
  // Redis: Starting with version 6, must match <major>.<minor>, prior to version 6, <major>.<minor>.<patch>
+ // Valkey: Versions in format <major>.<minor>
  var validator schema.SchemaValidateFunc
- if engine == "" || engine == engineMemcached {
+ switch engine {
+ case "", engineMemcached:
  validator = validMemcachedVersionString
- } else {
+ case engineRedis:
  validator = validRedisVersionString
+ case engineValkey:
+ validator = validValkeyVersionString
  }
 
  _, errs := validator(engineVersion, names.AttrEngineVersion)
@@ -187,6 +209,17 @@ func setEngineVersionRedis(d *schema.ResourceData, version *string) error {
  return nil
 }
 
+func setEngineVersionValkey(d *schema.ResourceData, version *string) error {
+ engineVersion, err := gversion.NewVersion(aws.ToString(version))
+ if err != nil {
+ return fmt.Errorf("reading engine version: %w", err)
+ }
+ d.Set(names.AttrEngineVersion, fmt.Sprintf("%d.%d", engineVersion.Segments()[0], engineVersion.Segments()[1]))
+ d.Set("engine_version_actual", engineVersion.String())
+
+ return nil
+}
+
 type versionDiff [3]int
 
 // diffVersion returns a diff of the versions, component by component.

internal/service/elasticache/engine_version_test.go

@@ -279,6 +279,22 @@ func TestValidateClusterEngineVersion(t *testing.T) {
  version: "7.0",
  valid: true,
  },
+
+ {
+ engine: tfelasticache.EngineValkey,
+ version: "7.x",
+ valid: false,
+ },
+ {
+ engine: tfelasticache.EngineValkey,
+ version: "7.2",
+ valid: true,
+ },
+ {
+ engine: tfelasticache.EngineValkey,
+ version: "7.2.6",
+ valid: false,
+ },
  }
 
  for _, testcase := range testcases {

internal/service/elasticache/exports_test.go

@@ -36,6 +36,7 @@ var (
  EmptyDescription = emptyDescription
  EngineMemcached = engineMemcached
  EngineRedis = engineRedis
+ EngineValkey = engineValkey
  EngineVersionForceNewOnDowngrade = engineVersionForceNewOnDowngrade
  EngineVersionIsDowngrade = engineVersionIsDowngrade
  GlobalReplicationGroupRegionPrefixFormat = globalReplicationGroupRegionPrefixFormat
@@ -44,6 +45,7 @@ var (
  ValidateClusterEngineVersion = validateClusterEngineVersion
  ValidMemcachedVersionString = validMemcachedVersionString
  ValidRedisVersionString = validRedisVersionString
+ ValidValkeyVersionString = validValkeyVersionString
 )
 
 type (

internal/service/elasticache/global_replication_group.go

@@ -94,10 +94,13 @@ func resourceGlobalReplicationGroup() *schema.Resource {
  Computed: true,
  },
  names.AttrEngineVersion: {
- Type: schema.TypeString,
- Optional: true,
- Computed: true,
- ValidateFunc: validRedisVersionString,
+ Type: schema.TypeString,
+ Optional: true,
+ Computed: true,
+ ValidateFunc: validation.Any(
+ validRedisVersionString,
+ validValkeyVersionString,
+ ),
  DiffSuppressFunc: func(_, old, new string, _ *schema.ResourceData) bool {
  if t, _ := regexp.MatchString(`[6-9]\.x`, new); t && old != "" {
  oldVersion, err := gversion.NewVersion(old)
@@ -399,7 +402,13 @@ func resourceGlobalReplicationGroupRead(ctx context.Context, d *schema.ResourceD
  d.Set("global_replication_group_id", globalReplicationGroup.GlobalReplicationGroupId)
  d.Set("transit_encryption_enabled", globalReplicationGroup.TransitEncryptionEnabled)
 
- if err := setEngineVersionRedis(d, globalReplicationGroup.EngineVersion); err != nil {
+ switch aws.ToString(globalReplicationGroup.Engine) {
+ case engineValkey:
+ err = setEngineVersionValkey(d, globalReplicationGroup.EngineVersion)
+ default:
+ err = setEngineVersionRedis(d, globalReplicationGroup.EngineVersion)
+ }
+ if err != nil {
  return sdkdiag.AppendErrorf(diags, "reading ElastiCache Replication Group (%s): %s", d.Id(), err)
  }