in alicloud/resource_alicloud_rds_ddr_instance.go [567:1376]
func resourceAlicloudRdsDdrInstanceUpdate(d *schema.ResourceData, meta interface{}) error {
client := meta.(*connectivity.AliyunClient)
rdsService := RdsService{client}
d.Partial(true)
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("payment_type") == "PayAsYouGo" {
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), 3*time.Minute, 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(client.GetRetryTimeout(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), 3*time.Minute, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
d.SetPartial("storage_auto_scale")
d.SetPartial("storage_threshold")
d.SetPartial("storage_upper_bound")
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
payType := PayType(convertRdsDdrPaymentTypeRequest(d.Get("payment_type")).(string))
if !d.IsNewResource() && d.HasChange("payment_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), 3*time.Minute, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
d.SetPartial("payment_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), 3*time.Minute, 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") {
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), 3*time.Minute, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
d.SetPartial("security_group_ids")
}
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), 3*time.Minute, 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), 3*time.Minute, 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), 3*time.Minute, 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(client.GetRetryTimeout(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), 3*time.Minute, 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), 3*time.Minute, 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("ssl_action") {
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" {
request["SSLEnabled"] = 1
}
instance, err := rdsService.DescribeDBInstance(d.Id())
if err != nil {
if NotFoundError(err) {
d.SetId("")
return nil
}
return WrapError(err)
}
if d.Get("engine").(string) == "PostgreSQL" {
if v, ok := d.GetOk("ca_type"); ok && v.(string) != "" {
request["CAType"] = v.(string)
}
if v, ok := d.GetOk("server_cert"); ok && v.(string) != "" {
request["ServerCert"] = v.(string)
}
if v, ok := d.GetOk("server_key"); ok && v.(string) != "" {
request["ServerKey"] = v.(string)
}
if v, ok := d.GetOk("client_ca_enabled"); ok {
request["ClientCAEnabled"] = v.(int)
}
if v, ok := d.GetOk("client_ca_cert"); ok && v.(string) != "" {
request["ClientCACert"] = v.(string)
}
if v, ok := d.GetOk("client_crl_enabled"); ok {
request["ClientCrlEnabled"] = v.(int)
}
if v, ok := d.GetOk("client_cert_revocation_list"); ok && v.(string) != "" {
request["ClientCertRevocationList"] = v.(string)
}
if v, ok := d.GetOk("acl"); ok && v.(string) != "" {
request["ACL"] = v.(string)
}
if v, ok := d.GetOk("replication_acl"); ok && v.(string) != "" {
request["ReplicationACL"] = v.(string)
}
}
request["ConnectionString"] = instance["ConnectionString"]
var response map[string]interface{}
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(client.GetRetryTimeout(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), 3*time.Minute, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
d.SetPartial("ssl_action")
// wait instance status is running after modifying
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
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) {
if v, ok := d.GetOk("encryption_key"); ok && v.(string) != "" {
request["EncryptionKey"] = v.(string)
roleArn, err := rdsService.FindKmsRoleArnDdr(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
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 3*time.Minute, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
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(client.GetRetryTimeout(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), 3*time.Minute, 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,
}
if d.HasChange("port") {
connectUpdate = true
}
if d.HasChange("connection_string_prefix") {
connectUpdate = true
}
if connectUpdate {
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"] {
connectRequest["Port"] = v
}
if v, ok := d.GetOk("connection_string_prefix"); ok && v != connectionStringPrefix {
connectRequest["ConnectionStringPrefix"] = v
}
var response map[string]interface{}
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(client.GetRetryTimeout(d.Timeout(schema.TimeoutUpdate)), func() *resource.RetryError {
response, err = client.RpcPost("Rds", "2014-08-15", connectAction, nil, connectRequest, 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(), connectAction, AlibabaCloudSdkGoERROR)
}
addDebug(connectAction, response, connectRequest)
d.SetPartial("port")
d.SetPartial("connection_string")
// 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.IsNewResource() {
d.Partial(false)
return resourceAlicloudRdsDdrInstanceRead(d, meta)
}
if !d.IsNewResource() && 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)
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(client.GetRetryTimeout(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": payType,
"SourceIp": client.SourceIp,
}
if v, ok := d.GetOk("effective_time"); ok && v.(string) != "" {
request["EffectiveTime"] = v
}
if !d.IsNewResource() && d.HasChange("instance_type") {
request["DBInstanceClass"] = d.Get("instance_type")
update = true
}
if !d.IsNewResource() && d.HasChange("instance_storage") {
request["DBInstanceStorage"] = d.Get("instance_storage")
update = true
}
if !d.IsNewResource() && d.HasChange("db_instance_storage_type") {
request["DBInstanceStorageType"] = d.Get("db_instance_storage_type")
update = true
}
if update {
// wait instance status is running before modifying
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 3*time.Minute, rdsService.RdsDBInstanceStateRefreshFunc(d.Id(), []string{"Deleting"}))
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")
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), 3*time.Minute, 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.IsNewResource() && d.HasChange("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(client.GetRetryTimeout(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), 3*time.Minute, 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())
}
}
if 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(client.GetRetryTimeout(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), 3*time.Minute, 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 resourceAlicloudRdsDdrInstanceRead(d, meta)
}