in alicloud/resource_alicloud_redis_tair_instance.go [556:1099]
func resourceAliCloudRedisTairInstanceUpdate(d *schema.ResourceData, meta interface{}) error {
client := meta.(*connectivity.AliyunClient)
var request map[string]interface{}
var response map[string]interface{}
var query map[string]interface{}
update := false
d.Partial(true)
action := "ModifyInstanceAttribute"
var err error
request = make(map[string]interface{})
query = make(map[string]interface{})
request["InstanceId"] = d.Id()
request["RegionId"] = client.RegionId
if !d.IsNewResource() && d.HasChange("tair_instance_name") {
update = true
request["InstanceName"] = d.Get("tair_instance_name")
}
if !d.IsNewResource() && d.HasChange("password") {
update = true
request["NewPassword"] = d.Get("password")
}
if update {
runtime := util.RuntimeOptions{}
runtime.SetAutoretry(true)
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("R-kvstore", "2015-01-01", action, query, request, true)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
addDebug(action, response, request)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
redisServiceV2 := RedisServiceV2{client}
stateConf := BuildStateConf([]string{}, []string{"Normal"}, d.Timeout(schema.TimeoutUpdate), 3*time.Minute, redisServiceV2.RedisTairInstanceStateRefreshFunc(d.Id(), "InstanceStatus", []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
update = false
action = "ModifyInstanceSpec"
request = make(map[string]interface{})
query = make(map[string]interface{})
request["InstanceId"] = d.Id()
request["RegionId"] = client.RegionId
request["ClientToken"] = buildClientToken(action)
if !d.IsNewResource() && d.HasChange("instance_class") {
update = true
}
request["InstanceClass"] = d.Get("instance_class")
if v, ok := d.GetOkExists("force_upgrade"); ok {
request["ForceUpgrade"] = v
}
if v, ok := d.GetOk("effective_time"); ok {
request["EffectiveTime"] = v
}
request["AutoPay"] = "true"
if v, ok := d.GetOkExists("slave_read_only_count"); ok {
request["SlaveReadOnlyCount"] = v
}
if v, ok := d.GetOkExists("read_only_count"); ok {
request["ReadOnlyCount"] = v
}
if !d.IsNewResource() && d.HasChange("node_type") {
update = true
request["NodeType"] = d.Get("node_type")
}
if update {
runtime := util.RuntimeOptions{}
runtime.SetAutoretry(true)
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("R-kvstore", "2015-01-01", action, query, request, true)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
addDebug(action, response, request)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
redisServiceV2 := RedisServiceV2{client}
stateConf := BuildStateConf([]string{}, []string{"true"}, d.Timeout(schema.TimeoutUpdate), 30*time.Second, redisServiceV2.RedisTairInstanceStateRefreshFunc(d.Id(), "$.IsOrderCompleted", []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
update = false
action = "ModifyResourceGroup"
request = make(map[string]interface{})
query = make(map[string]interface{})
request["InstanceId"] = d.Id()
request["RegionId"] = client.RegionId
request["ClientToken"] = buildClientToken(action)
if _, ok := d.GetOk("resource_group_id"); ok && !d.IsNewResource() && d.HasChange("resource_group_id") {
update = true
}
request["ResourceGroupId"] = d.Get("resource_group_id")
if update {
runtime := util.RuntimeOptions{}
runtime.SetAutoretry(true)
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("R-kvstore", "2015-01-01", action, query, request, true)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
addDebug(action, response, request)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
}
update = false
action = "ModifyInstanceMajorVersion"
request = make(map[string]interface{})
query = make(map[string]interface{})
request["InstanceId"] = d.Id()
request["RegionId"] = client.RegionId
if v, ok := d.GetOk("effective_time"); ok {
request["EffectiveTime"] = v
}
if !d.IsNewResource() && d.HasChange("engine_version") {
update = true
}
request["MajorVersion"] = d.Get("engine_version")
if update {
runtime := util.RuntimeOptions{}
runtime.SetAutoretry(true)
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("R-kvstore", "2015-01-01", action, query, request, true)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
addDebug(action, response, request)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
redisServiceV2 := RedisServiceV2{client}
stateConf := BuildStateConf([]string{}, []string{"Normal"}, d.Timeout(schema.TimeoutUpdate), 6*time.Minute, redisServiceV2.RedisTairInstanceStateRefreshFunc(d.Id(), "InstanceStatus", []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
update = false
action = "ModifySecurityGroupConfiguration"
request = make(map[string]interface{})
query = make(map[string]interface{})
request["DBInstanceId"] = d.Id()
request["RegionId"] = client.RegionId
if d.HasChange("security_group_id") {
update = true
}
request["SecurityGroupId"] = d.Get("security_group_id")
if update {
runtime := util.RuntimeOptions{}
runtime.SetAutoretry(true)
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("R-kvstore", "2015-01-01", action, query, request, true)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
addDebug(action, response, request)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
}
update = false
action = "TransformInstanceChargeType"
request = make(map[string]interface{})
query = make(map[string]interface{})
request["InstanceId"] = d.Id()
request["RegionId"] = client.RegionId
if !d.IsNewResource() && d.HasChange("payment_type") {
update = true
}
request["ChargeType"] = convertRedisTairInstanceChargeTypeRequest(d.Get("payment_type").(string))
request["AutoPay"] = "true"
if v, ok := d.GetOkExists("period"); ok {
request["Period"] = v
}
if v, ok := d.GetOk("auto_renew"); ok {
request["AutoRenew"] = v
}
if v, ok := d.GetOk("auto_renew_period"); ok {
request["AutoRenewPeriod"] = v
}
if update {
runtime := util.RuntimeOptions{}
runtime.SetAutoretry(true)
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("R-kvstore", "2015-01-01", action, query, request, true)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
addDebug(action, response, request)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
}
update = false
action = "ModifyInstanceSSL"
request = make(map[string]interface{})
query = make(map[string]interface{})
request["InstanceId"] = d.Id()
request["RegionId"] = client.RegionId
if d.HasChange("ssl_enabled") {
update = true
}
request["SSLEnabled"] = d.Get("ssl_enabled")
redisServiceV2 := RedisServiceV2{client}
objectRaw, _ := redisServiceV2.DescribeTairInstanceDescribeInstanceSSL(d.Id())
if objectRaw["SSLEnabled"] != nil && objectRaw["SSLEnabled"] == d.Get("ssl_enabled") {
update = false
}
if update {
runtime := util.RuntimeOptions{}
runtime.SetAutoretry(true)
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("R-kvstore", "2015-01-01", action, query, request, true)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
addDebug(action, response, request)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
redisServiceV2 := RedisServiceV2{client}
stateConf := BuildStateConf([]string{}, []string{"Normal"}, d.Timeout(schema.TimeoutUpdate), 5*time.Minute, redisServiceV2.RedisTairInstanceStateRefreshFunc(d.Id(), "InstanceStatus", []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
update = false
action = "ModifyInstanceBandwidth"
request = make(map[string]interface{})
query = make(map[string]interface{})
request["InstanceId"] = d.Id()
request["RegionId"] = client.RegionId
if d.HasChange("intranet_bandwidth") {
update = true
}
request["TargetIntranetBandwidth"] = d.Get("intranet_bandwidth")
if update {
runtime := util.RuntimeOptions{}
runtime.SetAutoretry(true)
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("R-kvstore", "2015-01-01", action, query, request, true)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
addDebug(action, response, request)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
redisServiceV2 := RedisServiceV2{client}
stateConf := BuildStateConf([]string{}, []string{"Normal"}, d.Timeout(schema.TimeoutUpdate), 60*time.Second, redisServiceV2.RedisTairInstanceStateRefreshFunc(d.Id(), "InstanceStatus", []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
update = false
action = "ModifyInstanceVpcAuthMode"
request = make(map[string]interface{})
query = make(map[string]interface{})
request["InstanceId"] = d.Id()
request["RegionId"] = client.RegionId
if d.HasChange("vpc_auth_mode") {
update = true
}
request["VpcAuthMode"] = d.Get("vpc_auth_mode")
if update {
runtime := util.RuntimeOptions{}
runtime.SetAutoretry(true)
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("R-kvstore", "2015-01-01", action, query, request, true)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
addDebug(action, response, request)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
redisServiceV2 := RedisServiceV2{client}
stateConf := BuildStateConf([]string{}, []string{"Normal"}, d.Timeout(schema.TimeoutUpdate), 60*time.Second, redisServiceV2.RedisTairInstanceStateRefreshFunc(d.Id(), "InstanceStatus", []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
update = false
action = "ModifySecurityIps"
request = make(map[string]interface{})
query = make(map[string]interface{})
request["InstanceId"] = d.Id()
request["RegionId"] = client.RegionId
if d.HasChange("security_ip_group_name") {
update = true
}
if v, ok := d.GetOk("security_ip_group_name"); ok {
request["SecurityIpGroupName"] = v
}
if v, ok := d.GetOk("modify_mode"); ok {
request["ModifyMode"] = v
}
if d.HasChange("security_ips") {
update = true
}
request["SecurityIps"] = d.Get("security_ips")
if update {
runtime := util.RuntimeOptions{}
runtime.SetAutoretry(true)
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("R-kvstore", "2015-01-01", action, query, request, true)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
addDebug(action, response, request)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
redisServiceV2 := RedisServiceV2{client}
stateConf := BuildStateConf([]string{}, []string{"Normal"}, d.Timeout(schema.TimeoutUpdate), 30*time.Second, redisServiceV2.RedisTairInstanceStateRefreshFunc(d.Id(), "InstanceStatus", []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
update = false
action = "ModifyInstanceConfig"
request = make(map[string]interface{})
query = make(map[string]interface{})
request["InstanceId"] = d.Id()
request["RegionId"] = client.RegionId
if d.HasChange("param_repl_mode") {
update = true
request["ParamReplMode"] = d.Get("param_repl_mode")
}
if d.HasChange("param_semisync_repl_timeout") {
update = true
request["ParamSemisyncReplTimeout"] = d.Get("param_semisync_repl_timeout")
}
if d.HasChange("param_no_loose_sentinel_enabled") {
update = true
request["ParamNoLooseSentinelEnabled"] = d.Get("param_no_loose_sentinel_enabled")
}
if d.HasChange("param_sentinel_compat_enable") {
update = true
request["ParamSentinelCompatEnable"] = d.Get("param_sentinel_compat_enable")
}
if d.HasChange("param_no_loose_sentinel_password_free_access") {
update = true
request["ParamNoLooseSentinelPasswordFreeAccess"] = d.Get("param_no_loose_sentinel_password_free_access")
}
if d.HasChange("param_no_loose_sentinel_password_free_commands") {
update = true
request["ParamNoLooseSentinelPasswordFreeCommands"] = d.Get("param_no_loose_sentinel_password_free_commands")
}
if update {
runtime := util.RuntimeOptions{}
runtime.SetAutoretry(true)
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("R-kvstore", "2015-01-01", action, query, request, true)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
addDebug(action, response, request)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
redisServiceV2 := RedisServiceV2{client}
stateConf := BuildStateConf([]string{}, []string{"Normal"}, d.Timeout(schema.TimeoutUpdate), 3*time.Minute, redisServiceV2.RedisTairInstanceStateRefreshFunc(d.Id(), "InstanceStatus", []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
if !d.IsNewResource() && d.HasChange("shard_count") {
oldEntry, newEntry := d.GetChange("shard_count")
oldEntryValue := oldEntry.(int)
newEntryValue := newEntry.(int)
removed := oldEntryValue - newEntryValue
added := newEntryValue - oldEntryValue
if removed > 0 {
action := "DeleteShardingNode"
request = make(map[string]interface{})
query = make(map[string]interface{})
request["InstanceId"] = d.Id()
request["RegionId"] = client.RegionId
request["ShardCount"] = removed
runtime := util.RuntimeOptions{}
runtime.SetAutoretry(true)
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("R-kvstore", "2015-01-01", action, query, request, true)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
addDebug(action, response, request)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
redisServiceV2 := RedisServiceV2{client}
stateConf := BuildStateConf([]string{}, []string{"true"}, d.Timeout(schema.TimeoutUpdate), 10*time.Second, redisServiceV2.RedisTairInstanceStateRefreshFunc(d.Id(), "$.IsOrderCompleted", []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
if added > 0 {
action := "AddShardingNode"
request = make(map[string]interface{})
query = make(map[string]interface{})
request["InstanceId"] = d.Id()
request["RegionId"] = client.RegionId
request["ClientToken"] = buildClientToken(action)
request["ShardCount"] = added
runtime := util.RuntimeOptions{}
runtime.SetAutoretry(true)
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("R-kvstore", "2015-01-01", action, query, request, true)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
addDebug(action, response, request)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
redisServiceV2 := RedisServiceV2{client}
stateConf := BuildStateConf([]string{}, []string{"true"}, d.Timeout(schema.TimeoutUpdate), 10*time.Second, redisServiceV2.RedisTairInstanceStateRefreshFunc(d.Id(), "$.IsOrderCompleted", []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
}
if d.HasChange("tags") {
redisServiceV2 := RedisServiceV2{client}
if err := redisServiceV2.SetResourceTags(d, "INSTANCE"); err != nil {
return WrapError(err)
}
}
d.Partial(false)
return resourceAliCloudRedisTairInstanceRead(d, meta)
}