in alicloud/resource_alicloud_alb_listener.go [878:1387]
func resourceAliCloudAlbListenerUpdate(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.HasChange("status") {
albServiceV2 := AlbServiceV2{client}
object, err := albServiceV2.DescribeAlbListener(d.Id())
if err != nil {
return WrapError(err)
}
target := d.Get("status").(string)
if object["ListenerStatus"].(string) != target {
if target == "Running" {
action := "StartListener"
request = make(map[string]interface{})
query = make(map[string]interface{})
request["ListenerId"] = 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{"IncorrectBusinessStatus.LoadBalancer", "SystemBusy", "IdempotenceProcessing", "IncorrectStatus.Listener", "VipStatusNotSupport", "-22001"}) || 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{"Running"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, albServiceV2.AlbListenerStateRefreshFunc(d.Id(), "ListenerStatus", []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
if target == "Stopped" {
action := "StopListener"
request = make(map[string]interface{})
query = make(map[string]interface{})
request["ListenerId"] = 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{"IncorrectBusinessStatus.LoadBalancer", "SystemBusy", "IdempotenceProcessing", "IncorrectStatus.Listener", "-22001", "VipStatusNotSupport"}) || 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{"Stopped"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, albServiceV2.AlbListenerStateRefreshFunc(d.Id(), "ListenerStatus", []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
}
}
action := "UpdateListenerAttribute"
var err error
request = make(map[string]interface{})
query = make(map[string]interface{})
request["ListenerId"] = d.Id()
request["ClientToken"] = buildClientToken(action)
if !d.IsNewResource() && d.HasChange("certificates") {
update = true
if v, ok := d.GetOk("certificates"); ok || d.HasChange("certificates") {
certificatesMapsArray := make([]interface{}, 0)
for _, dataLoop := range v.([]interface{}) {
dataLoopTmp := dataLoop.(map[string]interface{})
dataLoopMap := make(map[string]interface{})
dataLoopMap["CertificateId"] = dataLoopTmp["certificate_id"]
certificatesMapsArray = append(certificatesMapsArray, dataLoopMap)
}
request["Certificates"] = certificatesMapsArray
}
}
if !d.IsNewResource() && d.HasChange("request_timeout") {
update = true
request["RequestTimeout"] = d.Get("request_timeout")
}
if !d.IsNewResource() && d.HasChange("gzip_enabled") {
update = true
request["GzipEnabled"] = d.Get("gzip_enabled")
}
if !d.IsNewResource() && d.HasChange("http2_enabled") {
update = true
request["Http2Enabled"] = d.Get("http2_enabled")
}
if !d.IsNewResource() && d.HasChange("security_policy_id") {
update = true
request["SecurityPolicyId"] = d.Get("security_policy_id")
}
if !d.IsNewResource() && d.HasChange("quic_config") {
update = true
objectDataLocalMap := make(map[string]interface{})
if v := d.Get("quic_config"); v != nil {
quicUpgradeEnabled1, _ := jsonpath.Get("$[0].quic_upgrade_enabled", v)
if quicUpgradeEnabled1 != nil && (d.HasChange("quic_config.0.quic_upgrade_enabled") || quicUpgradeEnabled1 != "") {
objectDataLocalMap["QuicUpgradeEnabled"] = quicUpgradeEnabled1
}
quicListenerId1, _ := jsonpath.Get("$[0].quic_listener_id", v)
if quicListenerId1 != nil && (d.HasChange("quic_config.0.quic_listener_id") || quicListenerId1 != "") {
objectDataLocalMap["QuicListenerId"] = quicListenerId1
}
request["QuicConfig"] = objectDataLocalMap
}
}
if !d.IsNewResource() && d.HasChange("default_actions") {
update = true
}
if v, ok := d.GetOk("default_actions"); ok || d.HasChange("default_actions") {
defaultActionsMapsArray := make([]interface{}, 0)
for _, dataLoop1 := range v.([]interface{}) {
dataLoop1Tmp := dataLoop1.(map[string]interface{})
dataLoop1Map := make(map[string]interface{})
if !IsNil(dataLoop1Tmp["forward_group_config"]) {
localData2 := make(map[string]interface{})
if v, ok := dataLoop1Tmp["forward_group_config"]; ok {
localData3, err := jsonpath.Get("$[0].server_group_tuples", v)
if err != nil {
localData3 = make([]interface{}, 0)
}
localMaps1 := make([]interface{}, 0)
for _, dataLoop3 := range localData3.([]interface{}) {
dataLoop3Tmp := make(map[string]interface{})
if dataLoop3 != nil {
dataLoop3Tmp = dataLoop3.(map[string]interface{})
}
dataLoop3Map := make(map[string]interface{})
dataLoop3Map["ServerGroupId"] = dataLoop3Tmp["server_group_id"]
localMaps1 = append(localMaps1, dataLoop3Map)
}
localData2["ServerGroupTuples"] = localMaps1
}
dataLoop1Map["ForwardGroupConfig"] = localData2
}
dataLoop1Map["Type"] = dataLoop1Tmp["type"]
defaultActionsMapsArray = append(defaultActionsMapsArray, dataLoop1Map)
}
request["DefaultActions"] = defaultActionsMapsArray
}
if !d.IsNewResource() && d.HasChange("idle_timeout") {
update = true
request["IdleTimeout"] = d.Get("idle_timeout")
}
if !d.IsNewResource() && d.HasChange("ca_enabled") {
update = true
request["CaEnabled"] = d.Get("ca_enabled")
}
if !d.IsNewResource() && d.HasChange("ca_certificates") {
update = true
if v, ok := d.GetOk("ca_certificates"); ok || d.HasChange("ca_certificates") {
caCertificatesMapsArray := make([]interface{}, 0)
for _, dataLoop4 := range v.([]interface{}) {
dataLoop4Tmp := dataLoop4.(map[string]interface{})
dataLoop4Map := make(map[string]interface{})
dataLoop4Map["CertificateId"] = dataLoop4Tmp["certificate_id"]
caCertificatesMapsArray = append(caCertificatesMapsArray, dataLoop4Map)
}
request["CaCertificates"] = caCertificatesMapsArray
}
}
if !d.IsNewResource() && d.HasChange("listener_description") {
update = true
request["ListenerDescription"] = d.Get("listener_description")
}
if !d.IsNewResource() && d.HasChange("x_forwarded_for_config") {
update = true
objectDataLocalMap1 := make(map[string]interface{})
if v := d.Get("x_forwarded_for_config"); v != nil {
xForwardedForClientCertClientVerifyAlias1, _ := jsonpath.Get("$[0].x_forwarded_for_client_cert_client_verify_alias", v)
if xForwardedForClientCertClientVerifyAlias1 != nil && (d.HasChange("x_forwarded_for_config.0.x_forwarded_for_client_cert_client_verify_alias") || xForwardedForClientCertClientVerifyAlias1 != "") {
objectDataLocalMap1["XForwardedForClientCertClientVerifyAlias"] = xForwardedForClientCertClientVerifyAlias1
}
xForwardedForClientCertClientVerifyEnabled1, _ := jsonpath.Get("$[0].x_forwarded_for_client_cert_client_verify_enabled", v)
if xForwardedForClientCertClientVerifyEnabled1 != nil && (d.HasChange("x_forwarded_for_config.0.x_forwarded_for_client_cert_client_verify_enabled") || xForwardedForClientCertClientVerifyEnabled1 != "") {
objectDataLocalMap1["XForwardedForClientCertClientVerifyEnabled"] = xForwardedForClientCertClientVerifyEnabled1
}
xForwardedForClientCertFingerPrintAlias, _ := jsonpath.Get("$[0].x_forwarded_for_client_cert_finger_print_alias", v)
if xForwardedForClientCertFingerPrintAlias != nil && (d.HasChange("x_forwarded_for_config.0.x_forwarded_for_client_cert_finger_print_alias") || xForwardedForClientCertFingerPrintAlias != "") {
objectDataLocalMap1["XForwardedForClientCertFingerprintAlias"] = xForwardedForClientCertFingerPrintAlias
}
xForwardedForClientCertFingerPrintEnabled, _ := jsonpath.Get("$[0].x_forwarded_for_client_cert_finger_print_enabled", v)
if xForwardedForClientCertFingerPrintEnabled != nil && (d.HasChange("x_forwarded_for_config.0.x_forwarded_for_client_cert_finger_print_enabled") || xForwardedForClientCertFingerPrintEnabled != "") {
objectDataLocalMap1["XForwardedForClientCertFingerprintEnabled"] = xForwardedForClientCertFingerPrintEnabled
}
xForwardedForClientCertIssuerDnAlias, _ := jsonpath.Get("$[0].x_forwarded_for_client_cert_issuer_dn_alias", v)
if xForwardedForClientCertIssuerDnAlias != nil && (d.HasChange("x_forwarded_for_config.0.x_forwarded_for_client_cert_issuer_dn_alias") || xForwardedForClientCertIssuerDnAlias != "") {
objectDataLocalMap1["XForwardedForClientCertIssuerDNAlias"] = xForwardedForClientCertIssuerDnAlias
}
xForwardedForClientCertIssuerDnEnabled, _ := jsonpath.Get("$[0].x_forwarded_for_client_cert_issuer_dn_enabled", v)
if xForwardedForClientCertIssuerDnEnabled != nil && (d.HasChange("x_forwarded_for_config.0.x_forwarded_for_client_cert_issuer_dn_enabled") || xForwardedForClientCertIssuerDnEnabled != "") {
objectDataLocalMap1["XForwardedForClientCertIssuerDNEnabled"] = xForwardedForClientCertIssuerDnEnabled
}
xForwardedForClientCertSubjectDnAlias, _ := jsonpath.Get("$[0].x_forwarded_for_client_cert_subject_dn_alias", v)
if xForwardedForClientCertSubjectDnAlias != nil && (d.HasChange("x_forwarded_for_config.0.x_forwarded_for_client_cert_subject_dn_alias") || xForwardedForClientCertSubjectDnAlias != "") {
objectDataLocalMap1["XForwardedForClientCertSubjectDNAlias"] = xForwardedForClientCertSubjectDnAlias
}
xForwardedForClientCertSubjectDnEnabled, _ := jsonpath.Get("$[0].x_forwarded_for_client_cert_subject_dn_enabled", v)
if xForwardedForClientCertSubjectDnEnabled != nil && (d.HasChange("x_forwarded_for_config.0.x_forwarded_for_client_cert_subject_dn_enabled") || xForwardedForClientCertSubjectDnEnabled != "") {
objectDataLocalMap1["XForwardedForClientCertSubjectDNEnabled"] = xForwardedForClientCertSubjectDnEnabled
}
xForwardedForClientSrcPortEnabled1, _ := jsonpath.Get("$[0].x_forwarded_for_client_src_port_enabled", v)
if xForwardedForClientSrcPortEnabled1 != nil && (d.HasChange("x_forwarded_for_config.0.x_forwarded_for_client_src_port_enabled") || xForwardedForClientSrcPortEnabled1 != "") {
objectDataLocalMap1["XForwardedForClientSrcPortEnabled"] = xForwardedForClientSrcPortEnabled1
}
xForwardedForEnabled1, _ := jsonpath.Get("$[0].x_forwarded_for_enabled", v)
if xForwardedForEnabled1 != nil && (d.HasChange("x_forwarded_for_config.0.x_forwarded_for_enabled") || xForwardedForEnabled1 != "") {
objectDataLocalMap1["XForwardedForEnabled"] = xForwardedForEnabled1
}
xForwardedForProtoEnabled1, _ := jsonpath.Get("$[0].x_forwarded_for_proto_enabled", v)
if xForwardedForProtoEnabled1 != nil && (d.HasChange("x_forwarded_for_config.0.x_forwarded_for_proto_enabled") || xForwardedForProtoEnabled1 != "") {
objectDataLocalMap1["XForwardedForProtoEnabled"] = xForwardedForProtoEnabled1
}
xForwardedForSlbIdEnabled, _ := jsonpath.Get("$[0].x_forwarded_for_slb_id_enabled", v)
if xForwardedForSlbIdEnabled != nil && (d.HasChange("x_forwarded_for_config.0.x_forwarded_for_slb_id_enabled") || xForwardedForSlbIdEnabled != "") {
objectDataLocalMap1["XForwardedForSLBIdEnabled"] = xForwardedForSlbIdEnabled
}
xForwardedForSlbPortEnabled, _ := jsonpath.Get("$[0].x_forwarded_for_slb_port_enabled", v)
if xForwardedForSlbPortEnabled != nil && (d.HasChange("x_forwarded_for_config.0.x_forwarded_for_slb_port_enabled") || xForwardedForSlbPortEnabled != "") {
objectDataLocalMap1["XForwardedForSLBPortEnabled"] = xForwardedForSlbPortEnabled
}
xForwardedForClientSourceIpsEnabled1, _ := jsonpath.Get("$[0].x_forwarded_for_client_source_ips_enabled", v)
if xForwardedForClientSourceIpsEnabled1 != nil && (d.HasChange("x_forwarded_for_config.0.x_forwarded_for_client_source_ips_enabled") || xForwardedForClientSourceIpsEnabled1 != "") {
objectDataLocalMap1["XForwardedForClientSourceIpsEnabled"] = xForwardedForClientSourceIpsEnabled1
}
xForwardedForProcessingMode1, _ := jsonpath.Get("$[0].x_forwarded_for_processing_mode", v)
if xForwardedForProcessingMode1 != nil && (d.HasChange("x_forwarded_for_config.0.x_forwarded_for_processing_mode") || xForwardedForProcessingMode1 != "") {
objectDataLocalMap1["XForwardedForProcessingMode"] = xForwardedForProcessingMode1
}
xForwardedForClientSourceIpsTrusted1, _ := jsonpath.Get("$[0].x_forwarded_for_client_source_ips_trusted", v)
if xForwardedForClientSourceIpsTrusted1 != nil && (d.HasChange("x_forwarded_for_config.0.x_forwarded_for_client_source_ips_trusted") || xForwardedForClientSourceIpsTrusted1 != "") {
objectDataLocalMap1["XForwardedForClientSourceIpsTrusted"] = xForwardedForClientSourceIpsTrusted1
}
xForwardedForHostEnabled1, _ := jsonpath.Get("$[0].x_forwarded_for_host_enabled", v)
if xForwardedForHostEnabled1 != nil && (d.HasChange("x_forwarded_for_config.0.x_forwarded_for_host_enabled") || xForwardedForHostEnabled1 != "") {
objectDataLocalMap1["XForwardedForHostEnabled"] = xForwardedForHostEnabled1
}
request["XForwardedForConfig"] = objectDataLocalMap1
}
}
if v, ok := d.GetOkExists("dry_run"); ok {
request["DryRun"] = v
}
if !d.IsNewResource() && d.HasChange("xforwarded_for_config") {
update = true
if v, ok := d.GetOk("xforwarded_for_config"); ok {
xforwardedForConfigMap := map[string]interface{}{}
for _, xforwardedForConfig := range v.(*schema.Set).List() {
xforwardedForConfigArg := xforwardedForConfig.(map[string]interface{})
xforwardedForConfigMap["XForwardedForClientCertIssuerDNAlias"] = xforwardedForConfigArg["xforwardedforclientcert_issuerdnalias"]
xforwardedForConfigMap["XForwardedForClientCertIssuerDNEnabled"] = xforwardedForConfigArg["xforwardedforclientcert_issuerdnenabled"]
xforwardedForConfigMap["XForwardedForClientCertClientVerifyAlias"] = xforwardedForConfigArg["xforwardedforclientcertclientverifyalias"]
xforwardedForConfigMap["XForwardedForClientCertClientVerifyEnabled"] = xforwardedForConfigArg["xforwardedforclientcertclientverifyenabled"]
xforwardedForConfigMap["XForwardedForClientCertFingerprintAlias"] = xforwardedForConfigArg["xforwardedforclientcertfingerprintalias"]
xforwardedForConfigMap["XForwardedForClientCertFingerprintEnabled"] = xforwardedForConfigArg["xforwardedforclientcertfingerprintenabled"]
xforwardedForConfigMap["XForwardedForClientCertSubjectDNAlias"] = xforwardedForConfigArg["xforwardedforclientcertsubjectdnalias"]
xforwardedForConfigMap["XForwardedForClientCertSubjectDNEnabled"] = xforwardedForConfigArg["xforwardedforclientcertsubjectdnenabled"]
xforwardedForConfigMap["XForwardedForClientSrcPortEnabled"] = xforwardedForConfigArg["xforwardedforclientsrcportenabled"]
xforwardedForConfigMap["XForwardedForEnabled"] = xforwardedForConfigArg["xforwardedforenabled"]
xforwardedForConfigMap["XForwardedForProtoEnabled"] = xforwardedForConfigArg["xforwardedforprotoenabled"]
xforwardedForConfigMap["XForwardedForSLBIdEnabled"] = xforwardedForConfigArg["xforwardedforslbidenabled"]
xforwardedForConfigMap["XForwardedForSLBPortEnabled"] = xforwardedForConfigArg["xforwardedforslbportenabled"]
}
request["XForwardedForConfig"] = xforwardedForConfigMap
}
}
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{"IncorrectBusinessStatus.LoadBalancer", "SystemBusy", "IdempotenceProcessing", "IncorrectStatus.Listener", "VipStatusNotSupport", "-22001"}) || 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{"[Succeeded]"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, albServiceV2.DescribeAsyncAlbListenerStateRefreshFunc(d, response, "$.Jobs[*].Status", []string{}))
if jobDetail, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id(), jobDetail)
}
}
update = false
action = "UpdateListenerLogConfig"
request = make(map[string]interface{})
query = make(map[string]interface{})
request["ListenerId"] = d.Id()
request["ClientToken"] = buildClientToken(action)
if d.HasChange("access_log_record_customized_headers_enabled") {
update = true
request["AccessLogRecordCustomizedHeadersEnabled"] = d.Get("access_log_record_customized_headers_enabled")
}
if d.HasChange("access_log_tracing_config") {
update = true
objectDataLocalMap := make(map[string]interface{})
if v := d.Get("access_log_tracing_config"); v != nil {
tracingSample1, _ := jsonpath.Get("$[0].tracing_sample", v)
if tracingSample1 != nil && (d.HasChange("access_log_tracing_config.0.tracing_sample") || tracingSample1 != "") && tracingSample1.(int) > 0 {
objectDataLocalMap["TracingSample"] = tracingSample1
}
tracingType1, _ := jsonpath.Get("$[0].tracing_type", v)
if tracingType1 != nil && (d.HasChange("access_log_tracing_config.0.tracing_type") || tracingType1 != "") {
objectDataLocalMap["TracingType"] = tracingType1
}
tracingEnabled1, _ := jsonpath.Get("$[0].tracing_enabled", v)
if tracingEnabled1 != nil && (d.HasChange("access_log_tracing_config.0.tracing_enabled") || tracingEnabled1 != "") {
objectDataLocalMap["TracingEnabled"] = tracingEnabled1
}
request["AccessLogTracingConfig"] = objectDataLocalMap
}
}
if v, ok := d.GetOkExists("dry_run"); ok {
request["DryRun"] = v
}
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{"IncorrectBusinessStatus.LoadBalancer", "SystemBusy", "IdempotenceProcessing", "IncorrectStatus.Listener", "-22001", "VipStatusNotSupport"}) || 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{"[Succeeded]"}, d.Timeout(schema.TimeoutUpdate), 0, albServiceV2.DescribeAsyncAlbListenerStateRefreshFunc(d, response, "$.Jobs[*].Status", []string{}))
if jobDetail, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id(), jobDetail)
}
}
if d.HasChange("tags") {
albServiceV2 := AlbServiceV2{client}
if err := albServiceV2.SetResourceTags(d, "listener"); err != nil {
return WrapError(err)
}
}
if d.HasChange("acl_config") {
albService := AlbService{client}
albServiceV2 := AlbServiceV2{client}
oldAssociateAcls, newAssociateVpcs := d.GetChange("acl_config")
oldAssociateAclsSet := oldAssociateAcls.(*schema.Set)
newAssociateAclsSet := newAssociateVpcs.(*schema.Set)
removed := oldAssociateAclsSet.Difference(newAssociateAclsSet)
added := newAssociateAclsSet.Difference(oldAssociateAclsSet)
if removed.Len() > 0 {
action := "DissociateAclsFromListener"
dissociateAclsFromListenerReq := map[string]interface{}{
"ListenerId": d.Id(),
}
dissociateAclsFromListenerReq["ClientToken"] = buildClientToken("DissociateAclsFromListener")
associateAclIds := make([]string, 0)
for _, aclConfig := range removed.List() {
if aclRelationsMaps, ok := aclConfig.(map[string]interface{})["acl_relations"]; ok {
for _, aclRelationsMap := range aclRelationsMaps.(*schema.Set).List() {
associateAclIds = append(associateAclIds, aclRelationsMap.(map[string]interface{})["acl_id"].(string))
}
}
}
dissociateAclsFromListenerReq["AclIds"] = associateAclIds
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(client.GetRetryTimeout(d.Timeout(schema.TimeoutUpdate)), func() *resource.RetryError {
response, err = client.RpcPost("Alb", "2020-06-16", action, nil, dissociateAclsFromListenerReq, true)
if err != nil {
if IsExpectedErrors(err, []string{"VipStatusNotSupport"}) || NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
addDebug(action, response, dissociateAclsFromListenerReq)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, albService.AlbListenerStateRefreshFunc(d.Id(), []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
stateConf = BuildStateConf([]string{}, []string{"Succeeded"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, albServiceV2.AlbJobStateRefreshFunc(d.Id(), "listener", response["JobId"].(string), []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
if added.Len() > 0 {
action := "AssociateAclsWithListener"
associateAclsWithListenerReq := map[string]interface{}{
"ListenerId": d.Id(),
}
associateAclsWithListenerReq["ClientToken"] = buildClientToken("AssociateAclsWithListener")
associateAclIds := make([]string, 0)
for _, aclConfig := range added.List() {
if aclRelationsMaps, ok := aclConfig.(map[string]interface{})["acl_relations"]; ok {
for _, aclRelationsMap := range aclRelationsMaps.(*schema.Set).List() {
associateAclIds = append(associateAclIds, aclRelationsMap.(map[string]interface{})["acl_id"].(string))
}
}
associateAclsWithListenerReq["AclType"] = aclConfig.(map[string]interface{})["acl_type"]
}
associateAclsWithListenerReq["AclIds"] = associateAclIds
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(client.GetRetryTimeout(d.Timeout(schema.TimeoutUpdate)), func() *resource.RetryError {
response, err = client.RpcPost("Alb", "2020-06-16", action, nil, associateAclsWithListenerReq, true)
if err != nil {
if IsExpectedErrors(err, []string{"VipStatusNotSupport"}) || NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
return nil
})
addDebug(action, response, associateAclsWithListenerReq)
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
stateConf := BuildStateConf([]string{}, []string{"Running"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, albService.AlbListenerStateRefreshFunc(d.Id(), []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
stateConf = BuildStateConf([]string{}, []string{"Succeeded"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, albServiceV2.AlbJobStateRefreshFunc(d.Id(), "listener", response["JobId"].(string), []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}
}
}
d.Partial(false)
return resourceAliCloudAlbListenerRead(d, meta)
}