in alicloud/resource_alicloud_db_instance.go [700:1730]
func resourceAliCloudDBInstanceUpdate(d *schema.ResourceData, meta interface{}) error {
client := meta.(*connectivity.AliyunClient)
rdsService := RdsService{client}
d.Partial(true)
stateConf := BuildStateConf([]string{"DBInstanceClassChanging", "DBInstanceNetTypeChanging", "CONFIG_ENCRYPTING", "SSL_MODIFYING", "TDE_MODIFYING"}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 60*time.Second, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if d.HasChange("parameters") {
if err := rdsService.ModifyParameters(d, "parameters"); err != nil {
return WrapError(err)
}
}
if d.HasChange("pg_hba_conf") {
err := rdsService.ModifyPgHbaConfig(d, "pg_hba_conf")
if err != nil {
return WrapError(err)
}
}
if d.HasChange("deletion_protection") && (d.Get("instance_charge_type") == string(Postpaid) || d.Get("instance_charge_type") == string(Serverless)) {
err := rdsService.ModifyDBInstanceDeletionProtection(d, "deletion_protection")
if err != nil {
return WrapError(err)
}
}
if d.HasChange("tcp_connection_type") {
err := rdsService.ModifyHADiagnoseConfig(d, "tcp_connection_type")
if err != nil {
return WrapError(err)
}
}
if err := rdsService.setInstanceTags(d); err != nil {
return WrapError(err)
}
var err error
if d.HasChanges("storage_auto_scale", "storage_threshold", "storage_upper_bound") {
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
action := "ModifyDasInstanceConfig"
request := map[string]interface{}{
"DBInstanceId": d.Id(),
"RegionId": client.RegionId,
"SourceIp": client.SourceIp,
}
if v, ok := d.GetOk("storage_auto_scale"); ok && v.(string) != "" {
request["StorageAutoScale"] = v
}
if v, ok := d.GetOk("storage_threshold"); ok {
request["StorageThreshold"] = v.(int)
}
if v, ok := d.GetOk("storage_upper_bound"); ok {
request["StorageUpperBound"] = v.(int)
}
var response map[string]interface{}
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Rds", "2014-08-15", action, nil, request, false)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
addDebug(action, response, request)
stateConf = BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
d.SetPartial("storage_auto_scale")
d.SetPartial("storage_threshold")
d.SetPartial("storage_upper_bound")
// wait instance status is running after modifying
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
payType := PayType(d.Get("instance_charge_type").(string))
if !d.IsNewResource() && d.HasChange("instance_charge_type") {
action := "TransformDBInstancePayType"
request := map[string]interface{}{
"RegionId": client.RegionId,
"DBInstanceId": d.Id(),
"PayType": payType,
"SourceIp": client.SourceIp,
}
if payType == Prepaid {
period := d.Get("period").(int)
request["UsedTime"] = d.Get("period")
request["Period"] = Month
if period > 9 {
request["UsedTime"] = period / 12
request["Period"] = Year
}
}
response, err := client.RpcPost("Rds", "2014-08-15", action, nil, request, false)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
addDebug(action, response, request)
// wait instance status change from Creating to running
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
d.SetPartial("instance_charge_type")
d.SetPartial("period")
}
if payType == Prepaid && (d.HasChange("auto_renew") || d.HasChange("auto_renew_period")) {
action := "ModifyInstanceAutoRenewalAttribute"
request := map[string]interface{}{
"DBInstanceId": d.Id(),
"RegionId": client.RegionId,
"SourceIp": client.SourceIp,
}
auto_renew := d.Get("auto_renew").(bool)
if auto_renew {
request["AutoRenew"] = "True"
} else {
request["AutoRenew"] = "False"
}
request["Duration"] = strconv.Itoa(d.Get("auto_renew_period").(int))
response, err := client.RpcPost("Rds", "2014-08-15", action, nil, request, false)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
addDebug(action, response, request)
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
d.SetPartial("auto_renew")
d.SetPartial("auto_renew_period")
}
if d.HasChange("security_group_ids") || d.HasChange("security_group_id") {
groupIds := d.Get("security_group_id").(string)
if d.HasChange("security_group_ids") {
groupIds = strings.Join(expandStringList(d.Get("security_group_ids").(*schema.Set).List())[:], COMMA_SEPARATED)
}
err := rdsService.ModifySecurityGroupConfiguration(d.Id(), groupIds)
if err != nil {
return WrapError(err)
}
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
d.SetPartial("security_group_ids")
d.SetPartial("security_group_id")
}
if d.HasChange("monitoring_period") {
period := d.Get("monitoring_period").(int)
action := "ModifyDBInstanceMonitor"
request := map[string]interface{}{
"RegionId": client.RegionId,
"DBInstanceId": d.Id(),
"Period": strconv.Itoa(period),
"SourceIp": client.SourceIp,
}
response, err := client.RpcPost("Rds", "2014-08-15", action, nil, request, false)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
addDebug(action, response, request)
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
if d.HasChange("maintain_time") {
action := "ModifyDBInstanceMaintainTime"
request := map[string]interface{}{
"RegionId": client.RegionId,
"DBInstanceId": d.Id(),
"MaintainTime": d.Get("maintain_time"),
"ClientToken": buildClientToken(action),
"SourceIp": client.SourceIp,
}
response, err := client.RpcPost("Rds", "2014-08-15", action, nil, request, true)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
addDebug(action, response, request)
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
d.SetPartial("maintain_time")
}
if d.HasChange("auto_upgrade_minor_version") {
action := "ModifyDBInstanceAutoUpgradeMinorVersion"
request := map[string]interface{}{
"RegionId": client.SourceIp,
"DBInstanceId": d.Id(),
"AutoUpgradeMinorVersion": d.Get("auto_upgrade_minor_version"),
"ClientToken": buildClientToken(action),
"SourceIp": client.SourceIp,
}
response, err := client.RpcPost("Rds", "2014-08-15", action, nil, request, true)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
addDebug(action, response, request)
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
d.SetPartial("auto_upgrade_minor_version")
}
if !d.IsNewResource() && d.HasChange("engine_version") && d.Get("engine").(string) == string(MySQL) {
action := "UpgradeDBInstanceEngineVersion"
request := map[string]interface{}{
"RegionId": client.SourceIp,
"DBInstanceId": d.Id(),
"EngineVersion": d.Get("engine_version"),
"EffectiveTime": d.Get("effective_time"),
"ClientToken": buildClientToken(action),
"SourceIp": client.SourceIp,
}
var response map[string]interface{}
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Rds", "2014-08-15", action, nil, request, true)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
addDebug(action, response, request)
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
d.SetPartial("engine_version")
d.SetPartial("effective_time")
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
if d.HasChange("security_ip_mode") && d.Get("security_ip_mode").(string) == SafetyMode {
action := "MigrateSecurityIPMode"
request := map[string]interface{}{
"RegionId": client.RegionId,
"DBInstanceId": d.Id(),
"SourceIp": client.SourceIp,
}
response, err := client.RpcPost("Rds", "2014-08-15", action, nil, request, false)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
addDebug(action, response, request)
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
d.SetPartial("security_ip_mode")
}
if d.HasChange("sql_collector_status") {
action := "ModifySQLCollectorPolicy"
request := map[string]interface{}{
"RegionId": client.RegionId,
"DBInstanceId": d.Id(),
"SourceIp": client.SourceIp,
}
if d.Get("sql_collector_status").(string) == "Enabled" {
request["SQLCollectorStatus"] = "Enable"
} else {
request["SQLCollectorStatus"] = d.Get("sql_collector_status")
}
response, err := client.RpcPost("Rds", "2014-08-15", action, nil, request, false)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
addDebug(action, response, request)
// wait instance status is running after modifying
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 0, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
d.SetPartial("sql_collector_status")
}
if d.Get("sql_collector_status").(string) == "Enabled" && d.HasChange("sql_collector_config_value") && d.Get("engine").(string) == string(MySQL) {
action := "ModifySQLCollectorRetention"
request := map[string]interface{}{
"RegionId": client.RegionId,
"DBInstanceId": d.Id(),
"ConfigValue": strconv.Itoa(d.Get("sql_collector_config_value").(int)),
"SourceIp": client.SourceIp,
}
response, err := client.RpcPost("Rds", "2014-08-15", action, nil, request, false)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
addDebug(action, response, request)
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 0, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
d.SetPartial("sql_collector_config_value")
}
if d.HasChange("tde_status") {
action := "ModifyDBInstanceTDE"
request := map[string]interface{}{
"RegionId": client.RegionId,
"DBInstanceId": d.Id(),
"TDEStatus": d.Get("tde_status"),
"SourceIp": client.SourceIp,
}
if "MySQL" == d.Get("engine").(string) || string(PostgreSQL) == d.Get("engine").(string) {
if v, ok := d.GetOk("role_arn"); ok && v.(string) != "" {
request["RoleARN"] = v.(string)
}
if v, ok := d.GetOk("tde_encryption_key"); ok && v.(string) != "" {
request["EncryptionKey"] = v.(string)
if ro, ok := request["RoleARN"].(string); !ok || ro == "" {
roleArn, err := findKmsRoleArn(client, v.(string))
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
request["RoleARN"] = roleArn
}
}
}
response, err := client.RpcPost("Rds", "2014-08-15", action, nil, request, false)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
addDebug(action, response, request)
d.SetPartial("tde_status")
// wait instance status is running after modifying
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
if d.HasChanges("node_id") {
action := "SwitchDBInstanceHA"
request := map[string]interface{}{
"RegionId": client.RegionId,
"DBInstanceId": d.Id(),
"NodeId": d.Get("node_id"),
"SourceIp": client.SourceIp,
}
if v, ok := d.GetOk("force"); ok && v.(string) != "" {
request["Force"] = v
}
if v, ok := d.GetOk("effective_time"); ok && v.(string) != "" {
request["EffectiveTime"] = v
}
var response map[string]interface{}
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Rds", "2014-08-15", action, nil, request, false)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
addDebug(action, response, request)
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
// wait instance status is running after modifying
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
nodeId := d.Get("node_id").(string)
stateConfNodeId := BuildStateConf([]string{}, []string{nodeId}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, rdsService.RdsDBInstanceNodeIdRefreshFunc(d.Id()))
if _, err := stateConfNodeId.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
d.SetPartial("node_id")
d.SetPartial("force")
}
if d.HasChanges("ha_config", "manual_ha_time") {
action := "ModifyHASwitchConfig"
request := map[string]interface{}{
"RegionId": client.RegionId,
"DBInstanceId": d.Id(),
"SourceIp": client.SourceIp,
}
if v, ok := d.GetOk("ha_config"); ok && v.(string) != "" {
request["HAConfig"] = v
}
if v, ok := d.GetOk("manual_ha_time"); ok && v.(string) != "" {
request["ManualHATime"] = v
}
var response map[string]interface{}
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Rds", "2014-08-15", action, nil, request, false)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
addDebug(action, response, request)
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
d.SetPartial("ha_config")
d.SetPartial("manual_ha_time")
// wait instance status is running after modifying
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
connectUpdate := false
connectAction := "ModifyDBInstanceConnectionString"
connectRequest := map[string]interface{}{
"DBInstanceId": d.Id(),
"RegionId": client.RegionId,
"SourceIp": client.SourceIp,
}
// port default to 3306 and if setting port to 3306, there will have a change
if d.HasChanges("port", "connection_string_prefix", "babelfish_port") {
instance, err := rdsService.DescribeDBInstance(d.Id())
if err != nil {
return err
}
connectionStringPrefix := strings.Split(instance["ConnectionString"].(string), ".")[0]
connectRequest["CurrentConnectionString"] = instance["ConnectionString"]
connectRequest["Port"] = instance["Port"]
connectRequest["ConnectionStringPrefix"] = connectionStringPrefix
if v, ok := d.GetOk("port"); ok && v != instance["Port"] {
connectUpdate = true
connectRequest["Port"] = v
}
if v, ok := d.GetOk("connection_string_prefix"); ok && v != connectionStringPrefix {
connectUpdate = true
connectRequest["ConnectionStringPrefix"] = v
}
if d.HasChange("babelfish_port") {
connectUpdate = true
}
if v, ok := d.GetOk("babelfish_port"); ok {
connectRequest["BabelfishPort"] = v
}
if connectUpdate {
var response map[string]interface{}
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Rds", "2014-08-15", connectAction, nil, connectRequest, true)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), connectAction, AlibabaCloudSdkGoERROR)
}
addDebug(connectAction, response, connectRequest)
d.SetPartial("port")
d.SetPartial("connection_string")
d.SetPartial("babelfish_port")
// wait instance status is running after modifying
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 1*time.Minute, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
}
if d.HasChanges("ssl_action", "ssl_connection_string") {
action := "ModifyDBInstanceSSL"
request := map[string]interface{}{
"DBInstanceId": d.Id(),
"RegionId": client.RegionId,
"SourceIp": client.SourceIp,
}
sslAction := d.Get("ssl_action").(string)
if sslAction == "Close" {
request["SSLEnabled"] = 0
}
if sslAction == "Open" {
request["SSLEnabled"] = 1
}
if sslAction == "Update" {
request["SSLEnabled"] = 2
}
if sslAction == "Update" && (d.Get("engine").(string) == "PostgreSQL" || d.Get("engine").(string) == "MySQL") {
request["SSLEnabled"] = 1
}
instance, err := rdsService.DescribeDBInstance(d.Id())
if err != nil {
return WrapError(err)
}
if d.Get("engine").(string) == "PostgreSQL" {
if d.HasChange("ca_type") {
if v, ok := d.GetOk("ca_type"); ok && v.(string) != "" {
request["CAType"] = v.(string)
}
}
if d.HasChange("server_cert") {
if v, ok := d.GetOk("server_cert"); ok && v.(string) != "" {
request["ServerCert"] = v.(string)
}
}
if d.HasChange("server_key") {
if v, ok := d.GetOk("server_key"); ok && v.(string) != "" {
request["ServerKey"] = v.(string)
}
}
if d.HasChange("client_ca_enabled") {
if v, ok := d.GetOk("client_ca_enabled"); ok {
request["ClientCAEnabled"] = v.(int)
}
}
if d.HasChange("client_ca_cert") {
if v, ok := d.GetOk("client_ca_cert"); ok && v.(string) != "" {
request["ClientCACert"] = v.(string)
}
}
if d.HasChange("client_crl_enabled") {
if v, ok := d.GetOk("client_crl_enabled"); ok {
request["ClientCrlEnabled"] = v.(int)
}
}
if d.HasChange("client_cert_revocation_list") {
if v, ok := d.GetOk("client_cert_revocation_list"); ok && v.(string) != "" {
request["ClientCertRevocationList"] = v.(string)
}
}
if d.HasChange("acl") {
if v, ok := d.GetOk("acl"); ok && v.(string) != "" {
request["ACL"] = v.(string)
}
}
if d.HasChange("replication_acl") {
if v, ok := d.GetOk("replication_acl"); ok && v.(string) != "" {
request["ReplicationACL"] = v.(string)
}
}
}
if d.Get("engine").(string) == "MySQL" {
if d.HasChange("ca_type") {
if v, ok := d.GetOk("ca_type"); ok && v.(string) != "" {
request["CAType"] = v.(string)
}
}
if d.HasChange("server_cert") {
if v, ok := d.GetOk("server_cert"); ok && v.(string) != "" {
request["ServerCert"] = v.(string)
}
}
if d.HasChange("server_key") {
if v, ok := d.GetOk("server_key"); ok && v.(string) != "" {
request["ServerKey"] = v.(string)
}
}
}
request["ConnectionString"] = instance["ConnectionString"]
if d.HasChange("ssl_connection_string") {
if v, ok := d.GetOk("ssl_connection_string"); ok && v.(string) != "" {
request["ConnectionString"] = v.(string)
}
}
var response map[string]interface{}
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Rds", "2014-08-15", action, nil, request, false)
if err != nil {
if NeedRetry(err) || IsExpectedErrors(err, []string{"InternalError"}) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
addDebug(action, response, request)
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
d.SetPartial("ssl_action")
d.SetPartial("ssl_connection_string")
// wait instance status is running after modifying
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
if d.IsNewResource() {
d.Partial(false)
return resourceAliCloudDBInstanceRead(d, meta)
}
if d.HasChange("instance_name") {
action := "ModifyDBInstanceDescription"
request := map[string]interface{}{
"RegionId": client.RegionId,
"DBInstanceId": d.Id(),
"DBInstanceDescription": d.Get("instance_name"),
"SourceIp": client.SourceIp,
}
response, err := client.RpcPost("Rds", "2014-08-15", action, nil, request, false)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
addDebug(action, response, request)
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 0, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
d.SetPartial("instance_name")
}
if d.HasChange("security_ips") {
ipList := expandStringList(d.Get("security_ips").(*schema.Set).List())
ipstr := strings.Join(ipList[:], COMMA_SEPARATED)
// default disable connect from outside
if ipstr == "" {
ipstr = LOCAL_HOST_IP
}
action := "ModifySecurityIps"
request := map[string]interface{}{
"RegionId": client.RegionId,
"DBInstanceId": d.Id(),
"SecurityIps": ipstr,
"SourceIp": client.SourceIp,
}
if v, ok := d.GetOk("db_instance_ip_array_name"); ok && v.(string) != "" {
request["DBInstanceIPArrayName"] = v
}
if v, ok := d.GetOk("db_instance_ip_array_attribute"); ok && v.(string) != "" {
request["DBInstanceIPArrayAttribute"] = v
}
if v, ok := d.GetOk("security_ip_type"); ok && v.(string) != "" {
request["SecurityIPType"] = v
}
if v, ok := d.GetOk("whitelist_network_type"); ok && v.(string) != "" {
request["WhitelistNetworkType"] = v
}
if v, ok := d.GetOk("modify_mode"); ok && v.(string) != "" {
request["ModifyMode"] = v
}
if v, ok := d.GetOk("fresh_white_list_readins"); ok && v.(string) != "" {
request["FreshWhiteListReadins"] = v
}
var response map[string]interface{}
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Rds", "2014-08-15", action, nil, request, false)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
addDebug(action, response, request)
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 1*time.Second, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
d.SetPartial("security_ips")
d.SetPartial("db_instance_ip_array_name")
d.SetPartial("db_instance_ip_array_attribute")
d.SetPartial("security_ip_type")
d.SetPartial("whitelist_network_type")
}
if !d.IsNewResource() && d.HasChange("resource_group_id") {
action := "ModifyResourceGroup"
request := map[string]interface{}{
"DBInstanceId": d.Id(),
"ResourceGroupId": d.Get("resource_group_id"),
"ClientToken": buildClientToken(action),
"SourceIp": client.SourceIp,
}
response, err := client.RpcPost("Rds", "2014-08-15", action, nil, request, true)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
addDebug(action, response, request)
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 0, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
d.SetPartial("resource_group_id")
}
update := false
action := "ModifyDBInstanceSpec"
request := map[string]interface{}{
"RegionId": client.RegionId,
"DBInstanceId": d.Id(),
"PayType": d.Get("instance_charge_type"),
"SourceIp": client.SourceIp,
}
if v, ok := d.GetOk("effective_time"); ok && v.(string) != "" {
request["EffectiveTime"] = v
}
if d.HasChange("instance_type") {
update = true
}
if v, ok := d.GetOk("direction"); ok && v.(string) != "" {
request["Direction"] = v
}
request["DBInstanceClass"] = d.Get("instance_type")
if d.HasChange("instance_storage") {
update = true
}
request["DBInstanceStorage"] = d.Get("instance_storage")
if d.HasChange("bursting_enabled") {
update = true
}
if v, ok := d.GetOkExists("bursting_enabled"); ok {
request["BurstingEnabled"] = v
}
if d.HasChange("serverless_config") {
update = true
if v, ok := d.GetOk("serverless_config"); ok {
v := v.([]interface{})[0].(map[string]interface{})
if string(MySQL) == d.Get("engine").(string) || string(PostgreSQL) == d.Get("engine") {
serverlessConfig, err := json.Marshal(struct {
MaxCapacity float64 `json:"MaxCapacity"`
MinCapacity float64 `json:"MinCapacity"`
AutoPause bool `json:"AutoPause"`
SwitchForce bool `json:"SwitchForce"`
}{
v["max_capacity"].(float64),
v["min_capacity"].(float64),
v["auto_pause"].(bool),
v["switch_force"].(bool),
})
if err != nil {
return WrapError(err)
}
request["ServerlessConfiguration"] = string(serverlessConfig)
if category, ok := d.GetOk("category"); ok {
request["Category"] = category
}
request["Direction"] = "Serverless"
} else if string(SQLServer) == d.Get("engine") {
serverlessConfig, err := json.Marshal(struct {
MaxCapacity float64 `json:"MaxCapacity"`
MinCapacity float64 `json:"MinCapacity"`
}{
v["max_capacity"].(float64),
v["min_capacity"].(float64),
})
if err != nil {
return WrapError(err)
}
request["ServerlessConfiguration"] = string(serverlessConfig)
if category, ok := d.GetOk("category"); ok {
request["Category"] = category
}
request["Direction"] = "Serverless"
}
}
}
if d.HasChange("optimized_writes") && d.Get("engine").(string) == "MySQL" {
update = true
if optimizedWrites, ok := d.GetOk("optimized_writes"); ok && optimizedWrites.(string) != "" {
request["OptimizedWrites"] = optimizedWrites.(string)
}
}
if d.HasChange("db_instance_storage_type") {
update = true
}
request["DBInstanceStorageType"] = d.Get("db_instance_storage_type")
if update {
// wait instance status is running before modifying
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
err := resource.Retry(5*time.Minute, func() *resource.RetryError {
response, err := client.RpcPost("Rds", "2014-08-15", action, nil, request, false)
if err != nil {
if IsExpectedErrors(err, []string{"InvalidOrderTask.NotSupport"}) || NeedRetry(err) {
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
addDebug(action, response, request)
d.SetPartial("instance_type")
d.SetPartial("instance_storage")
d.SetPartial("db_instance_storage_type")
d.SetPartial("effective_time")
d.SetPartial("serverless_config")
return nil
})
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
// wait instance status is running after modifying
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
vpcService := VpcService{client}
netUpdate := false
netAction := "SwitchDBInstanceVpc"
netRequest := map[string]interface{}{
"DBInstanceId": d.Id(),
"RegionId": client.RegionId,
"SourceIp": client.SourceIp,
}
if d.HasChanges("vswitch_id") {
netUpdate = true
}
if d.HasChange("private_ip_address") {
netUpdate = true
}
if netUpdate {
v := d.Get("vswitch_id").(string)
vsw, err := vpcService.DescribeVSwitch(v)
if err != nil {
return WrapError(err)
}
netRequest["VPCId"] = vsw.VpcId
netRequest["VSwitchId"] = v
if v, ok := d.GetOk("private_ip_address"); ok && v.(string) != "" {
netRequest["PrivateIpAddress"] = v
}
var response map[string]interface{}
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Rds", "2014-08-15", netAction, nil, netRequest, false)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), netAction, AlibabaCloudSdkGoERROR)
}
addDebug(netAction, response, netRequest)
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
d.SetPartial("vswitch_id")
d.SetPartial("private_ip_address")
// wait instance status is running after modifying
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
handleConfigChange := func(configName string, configValue interface{}) error {
action := "ModifyDBInstanceConfig"
request := map[string]interface{}{
"RegionId": client.RegionId,
"DBInstanceId": d.Id(),
"ConfigName": configName,
"ConfigValue": configValue,
}
var response map[string]interface{}
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Rds", "2014-08-15", action, nil, request, false)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
addDebug(action, response, request)
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
return nil
}
if "PostgreSQL" == d.Get("engine").(string) {
if d.HasChange("pg_bouncer_enabled") {
if err := handleConfigChange("pgbouncer", d.Get("pg_bouncer_enabled")); err != nil {
return err
}
}
if d.HasChange("encryption_key") {
if v, ok := d.GetOk("encryption_key"); ok {
var configValue string
if v.(string) == "disabled" {
configValue = "disabled"
} else {
configValue = v.(string)
}
if err := handleConfigChange("encryptionKey", configValue); err != nil {
return err
}
}
}
}
if "SQLServer" == d.Get("engine").(string) {
if d.HasChange("recovery_model") {
if err := handleConfigChange("backup_recovery_model", d.Get("recovery_model")); err != nil {
return err
}
}
}
if !d.IsNewResource() && (d.HasChange("target_minor_version") || d.HasChange("upgrade_db_instance_kernel_version")) {
action := "UpgradeDBInstanceKernelVersion"
request := map[string]interface{}{
"RegionId": client.RegionId,
"DBInstanceId": d.Id(),
"SourceIp": client.SourceIp,
}
if v, ok := d.GetOk("upgrade_time"); ok && v.(string) != "" {
request["UpgradeTime"] = v
}
if v, ok := d.GetOk("switch_time"); ok && v.(string) != "" {
request["SwitchTime"] = v
}
if v, ok := d.GetOk("target_minor_version"); ok && v.(string) != "" {
request["TargetMinorVersion"] = v
}
var response map[string]interface{}
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Rds", "2014-08-15", action, nil, request, false)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
addDebug(action, response, request)
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
d.SetPartial("target_minor_version")
// wait instance status is running after modifying
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
d.Partial(false)
return resourceAliCloudDBInstanceRead(d, meta)
}