in alicloud/resource_alicloud_alb_load_balancer.go [539:1021]
func resourceAliCloudAlbLoadBalancerUpdate(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)
if !d.IsNewResource() && d.HasChanges("deletion_protection_config.0.enabled", "deletion_protection_enabled") {
albServiceV2 := AlbServiceV2{client}
object, err := albServiceV2.DescribeAlbLoadBalancer(d.Id())
if err != nil {
return WrapError(err)
}
target := d.Get("deletion_protection_config.0.enabled").(bool)
if d.HasChange("deletion_protection_enabled") {
target = d.Get("deletion_protection_enabled").(bool)
}
currentValue, err := jsonpath.Get("$.DeletionProtectionConfig.Enabled", object)
if currentValue != nil && currentValue.(bool) != target {
if target == false {
action := "DisableDeletionProtection"
request = make(map[string]interface{})
query = make(map[string]interface{})
request["ResourceId"] = d.Id()
request["ClientToken"] = buildClientToken(action)
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Alb", "2020-06-16", action, query, request, true)
if err != nil {
if IsExpectedErrors(err, []string{"SystemBusy", "IncorrectStatus.LoadBalancer", "IdempotenceProcessing"}) || 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)
}
albServiceV2 := AlbServiceV2{client}
stateConf := BuildStateConf([]string{}, []string{"Active"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, albServiceV2.AlbLoadBalancerStateRefreshFunc(d.Id(), "LoadBalancerStatus", []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
if target == true {
action := "EnableDeletionProtection"
request = make(map[string]interface{})
query = make(map[string]interface{})
request["ResourceId"] = d.Id()
request["ClientToken"] = buildClientToken(action)
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Alb", "2020-06-16", action, query, request, true)
if err != nil {
if IsExpectedErrors(err, []string{"SystemBusy", "IncorrectStatus.LoadBalancer", "IdempotenceProcessing", "undefined"}) || 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)
}
albServiceV2 := AlbServiceV2{client}
stateConf := BuildStateConf([]string{}, []string{"Active"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, albServiceV2.AlbLoadBalancerStateRefreshFunc(d.Id(), "LoadBalancerStatus", []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
}
}
if d.HasChange("ipv6_address_type") {
albServiceV2 := AlbServiceV2{client}
object, err := albServiceV2.DescribeAlbLoadBalancer(d.Id())
if err != nil {
return WrapError(err)
}
target := d.Get("ipv6_address_type").(string)
if object["Ipv6AddressType"].(string) != target {
if target == "Internet" {
action := "EnableLoadBalancerIpv6Internet"
request = make(map[string]interface{})
query = make(map[string]interface{})
request["LoadBalancerId"] = d.Id()
request["ClientToken"] = buildClientToken(action)
if v, ok := d.GetOkExists("dry_run"); ok {
request["DryRun"] = v
}
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Alb", "2020-06-16", action, query, request, true)
if err != nil {
if IsExpectedErrors(err, []string{"IncorrectStatus.LoadBalancer"}) || 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)
}
albServiceV2 := AlbServiceV2{client}
stateConf := BuildStateConf([]string{}, []string{"Internet"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, albServiceV2.AlbLoadBalancerStateRefreshFunc(d.Id(), "Ipv6AddressType", []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
if target == "Intranet" {
action := "DisableLoadBalancerIpv6Internet"
request = make(map[string]interface{})
query = make(map[string]interface{})
request["LoadBalancerId"] = d.Id()
request["ClientToken"] = buildClientToken(action)
if v, ok := d.GetOkExists("dry_run"); ok {
request["DryRun"] = v
}
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Alb", "2020-06-16", action, query, request, true)
if err != nil {
if IsExpectedErrors(err, []string{"IncorrectStatus.LoadBalancer"}) || 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)
}
albServiceV2 := AlbServiceV2{client}
stateConf := BuildStateConf([]string{}, []string{"Intranet"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, albServiceV2.AlbLoadBalancerStateRefreshFunc(d.Id(), "Ipv6AddressType", []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
}
}
var err error
action := "UpdateLoadBalancerAttribute"
request = make(map[string]interface{})
query = make(map[string]interface{})
request["LoadBalancerId"] = d.Id()
request["ClientToken"] = buildClientToken(action)
if !d.IsNewResource() && d.HasChange("modification_protection_config") {
update = true
objectDataLocalMap := make(map[string]interface{})
if v := d.Get("modification_protection_config"); v != nil {
status1, _ := jsonpath.Get("$[0].status", v)
if status1 != nil && (d.HasChange("modification_protection_config.0.status") || status1 != "") {
objectDataLocalMap["Status"] = status1
}
reason1, _ := jsonpath.Get("$[0].reason", v)
if reason1 != nil && (d.HasChange("modification_protection_config.0.reason") || reason1 != "") {
objectDataLocalMap["Reason"] = reason1
}
request["ModificationProtectionConfig"] = objectDataLocalMap
}
}
if v, ok := d.GetOk("dry_run"); ok {
request["DryRun"] = v
}
if !d.IsNewResource() && d.HasChange("load_balancer_name") {
update = true
request["LoadBalancerName"] = d.Get("load_balancer_name")
}
if update {
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Alb", "2020-06-16", action, query, request, true)
if err != nil {
if IsExpectedErrors(err, []string{"SystemBusy", "IncorrectStatus.LoadBalancer", "ResourceNotFound.LoadBalancer", "IdempotenceProcessing"}) || 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)
}
albServiceV2 := AlbServiceV2{client}
stateConf := BuildStateConf([]string{}, []string{"Active"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, albServiceV2.AlbLoadBalancerStateRefreshFunc(d.Id(), "LoadBalancerStatus", []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
update = false
action = "UpdateLoadBalancerEdition"
request = make(map[string]interface{})
query = make(map[string]interface{})
request["LoadBalancerId"] = d.Id()
request["ClientToken"] = buildClientToken(action)
if v, ok := d.GetOk("dry_run"); ok {
request["DryRun"] = v
}
if !d.IsNewResource() && d.HasChange("load_balancer_edition") {
update = true
}
request["LoadBalancerEdition"] = d.Get("load_balancer_edition")
if update {
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Alb", "2020-06-16", action, query, request, true)
if err != nil {
if IsExpectedErrors(err, []string{"SystemBusy", "IncorrectStatus.LoadBalancer", "IdempotenceProcessing"}) || 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)
}
albServiceV2 := AlbServiceV2{client}
stateConf := BuildStateConf([]string{}, []string{fmt.Sprint(d.Get("load_balancer_edition"))}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, albServiceV2.AlbLoadBalancerStateRefreshFunc(d.Id(), "LoadBalancerEdition", []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
update = false
action = "MoveResourceGroup"
request = make(map[string]interface{})
query = make(map[string]interface{})
request["ResourceId"] = d.Id()
if _, ok := d.GetOk("resource_group_id"); ok && !d.IsNewResource() && d.HasChange("resource_group_id") {
update = true
}
request["NewResourceGroupId"] = d.Get("resource_group_id")
request["ResourceType"] = "loadbalancer"
if update {
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Alb", "2020-06-16", action, query, request, true)
if err != nil {
if IsExpectedErrors(err, []string{"IncorrectStatus.LoadBalancer", "undefined"}) || 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)
}
albServiceV2 := AlbServiceV2{client}
stateConf := BuildStateConf([]string{}, []string{"Active"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, albServiceV2.AlbLoadBalancerStateRefreshFunc(d.Id(), "LoadBalancerStatus", []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
update = false
action = "UpdateLoadBalancerZones"
request = make(map[string]interface{})
query = make(map[string]interface{})
request["LoadBalancerId"] = d.Id()
request["ClientToken"] = buildClientToken(action)
if !d.IsNewResource() && d.HasChange("zone_mappings") {
update = true
}
if v, ok := d.GetOk("zone_mappings"); ok || d.HasChange("zone_mappings") {
zoneMappingsMapsArray := make([]interface{}, 0)
for _, dataLoop := range v.(*schema.Set).List() {
dataLoopTmp := dataLoop.(map[string]interface{})
dataLoopMap := make(map[string]interface{})
dataLoopMap["ZoneId"] = dataLoopTmp["zone_id"]
dataLoopMap["IntranetAddress"] = dataLoopTmp["intranet_address"]
dataLoopMap["AllocationId"] = dataLoopTmp["allocation_id"]
dataLoopMap["EipType"] = dataLoopTmp["eip_type"]
dataLoopMap["VSwitchId"] = dataLoopTmp["vswitch_id"]
zoneMappingsMapsArray = append(zoneMappingsMapsArray, dataLoopMap)
}
request["ZoneMappings"] = zoneMappingsMapsArray
}
if update {
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Alb", "2020-06-16", action, query, request, true)
if err != nil {
if IsExpectedErrors(err, []string{"IncorrectStatus.LoadBalancer"}) || 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)
}
albServiceV2 := AlbServiceV2{client}
stateConf := BuildStateConf([]string{}, []string{"Active"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, albServiceV2.AlbLoadBalancerStateRefreshFunc(d.Id(), "LoadBalancerStatus", []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
update = false
action = "UpdateLoadBalancerAddressTypeConfig"
request = make(map[string]interface{})
query = make(map[string]interface{})
request["LoadBalancerId"] = d.Id()
request["ClientToken"] = buildClientToken(action)
if !d.IsNewResource() && d.HasChange("address_type") {
update = true
}
request["AddressType"] = d.Get("address_type")
if update {
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Alb", "2020-06-16", action, query, request, true)
if err != nil {
if IsExpectedErrors(err, []string{"IncorrectStatus.LoadBalancer"}) || 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)
}
albServiceV2 := AlbServiceV2{client}
stateConf := BuildStateConf([]string{}, []string{"Active"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, albServiceV2.AlbLoadBalancerStateRefreshFunc(d.Id(), "LoadBalancerStatus", []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
if d.HasChange("tags") {
albServiceV2 := AlbServiceV2{client}
if err := albServiceV2.SetResourceTags(d, "loadbalancer"); err != nil {
return WrapError(err)
}
}
if d.HasChange("access_log_config") {
oldAccessLogConfig, newAccessLogConfig := d.GetChange("access_log_config")
removed := oldAccessLogConfig.(*schema.Set)
added := newAccessLogConfig.(*schema.Set)
if removed.Len() > 0 {
request := map[string]interface{}{
"ClientToken": buildClientToken("DisableLoadBalancerAccessLog"),
"LoadBalancerId": d.Id(),
}
if v, ok := d.GetOkExists("dry_run"); ok {
request["DryRun"] = v
}
action := "DisableLoadBalancerAccessLog"
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("Alb", "2020-06-16", action, nil, request, true)
if err != nil {
if IsExpectedErrors(err, []string{"OperationDenied.AccessLogEnabled", "SystemBusy", "IdempotenceProcessing"}) || 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)
}
albServiceV2 := AlbServiceV2{client}
stateConf := BuildStateConf([]string{}, []string{"Active"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, albServiceV2.AlbLoadBalancerStateRefreshFunc(d.Id(), "LoadBalancerStatus", []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
if added.Len() > 0 {
request := map[string]interface{}{
"ClientToken": buildClientToken("EnableLoadBalancerAccessLog"),
"LoadBalancerId": d.Id(),
}
if v, ok := d.GetOk("access_log_config"); ok {
for _, accessLogConfigList := range v.(*schema.Set).List() {
accessLogConfigArg := accessLogConfigList.(map[string]interface{})
request["LogProject"] = accessLogConfigArg["log_project"]
request["LogStore"] = accessLogConfigArg["log_store"]
}
}
if v, ok := d.GetOkExists("dry_run"); ok {
request["DryRun"] = v
}
action := "EnableLoadBalancerAccessLog"
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("Alb", "2020-06-16", action, nil, request, true)
if err != nil {
if IsExpectedErrors(err, []string{"OperationDenied.AccessLogEnabled", "SystemBusy", "IdempotenceProcessing"}) || 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)
}
albServiceV2 := AlbServiceV2{client}
stateConf := BuildStateConf([]string{}, []string{"Active"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, albServiceV2.AlbLoadBalancerStateRefreshFunc(d.Id(), "LoadBalancerStatus", []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
d.SetPartial("access_log_config")
}
d.Partial(false)
return resourceAliCloudAlbLoadBalancerRead(d, meta)
}