in alicloud/resource_alicloud_ecs_network_interface.go [350:942]
func resourceAliCloudEcsNetworkInterfaceUpdate(d *schema.ResourceData, meta interface{}) error {
client := meta.(*connectivity.AliyunClient)
var err error
ecsService := EcsService{client}
var response map[string]interface{}
d.Partial(true)
if d.HasChange("tags") {
if err := ecsService.SetResourceTags(d, "eni"); err != nil {
return WrapError(err)
}
d.SetPartial("tags")
}
update := false
updateSecurityGroup := false
request := map[string]interface{}{
"NetworkInterfaceId": d.Id(),
}
request["RegionId"] = client.RegionId
if d.HasChange("description") {
update = true
request["Description"] = d.Get("description")
}
if d.HasChange("network_interface_name") {
update = true
request["NetworkInterfaceName"] = d.Get("network_interface_name")
}
if d.HasChange("name") {
update = true
request["NetworkInterfaceName"] = d.Get("name")
}
if d.HasChange("queue_number") {
update = true
request["QueueNumber"] = d.Get("queue_number")
}
if d.HasChange("security_group_ids") {
update = true
request["SecurityGroupId"] = d.Get("security_group_ids").(*schema.Set).List()
updateSecurityGroup = true
}
if d.HasChange("security_groups") {
update = true
request["SecurityGroupId"] = d.Get("security_groups").(*schema.Set).List()
updateSecurityGroup = true
}
if update {
action := "ModifyNetworkInterfaceAttribute"
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Ecs", "2014-05-26", action, nil, request, false)
if err != nil {
if NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
addDebug(action, response, request)
return nil
})
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
d.SetPartial("description")
d.SetPartial("name")
d.SetPartial("network_interface_name")
d.SetPartial("queue_number")
d.SetPartial("security_groups")
d.SetPartial("security_group_ids")
if updateSecurityGroup {
time.Sleep(500 * time.Millisecond)
}
}
d.Partial(false)
if d.HasChange("private_ip_addresses") {
oldPrivateIpAddresses, newPrivateIpAddresses := d.GetChange("private_ip_addresses")
oldPrivateIpAddressesSet := oldPrivateIpAddresses.(*schema.Set)
newPrivateIpAddressesSet := newPrivateIpAddresses.(*schema.Set)
removed := oldPrivateIpAddressesSet.Difference(newPrivateIpAddressesSet)
added := newPrivateIpAddressesSet.Difference(oldPrivateIpAddressesSet)
if removed.Len() > 0 {
unassignprivateipaddressesrequest := map[string]interface{}{
"NetworkInterfaceId": d.Id(),
}
unassignprivateipaddressesrequest["PrivateIpAddress"] = removed.List()
unassignprivateipaddressesrequest["RegionId"] = client.RegionId
action := "UnassignPrivateIpAddresses"
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Ecs", "2014-05-26", action, nil, unassignprivateipaddressesrequest, false)
if err != nil {
if IsExpectedErrors(err, []string{"InternalError", "InvalidOperation.InvalidEcsState", "InvalidOperation.InvalidEniState", "OperationConflict", "ServiceUnavailable"}) || NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
addDebug(action, response, unassignprivateipaddressesrequest)
return nil
})
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
d.SetPartial("private_ip_addresses")
}
if added.Len() > 0 {
assignprivateipaddressesrequest := map[string]interface{}{
"NetworkInterfaceId": d.Id(),
}
assignprivateipaddressesrequest["PrivateIpAddress"] = added.List()
assignprivateipaddressesrequest["RegionId"] = client.RegionId
action := "AssignPrivateIpAddresses"
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Ecs", "2014-05-26", action, nil, assignprivateipaddressesrequest, false)
if err != nil {
if IsExpectedErrors(err, []string{"InternalError", "InvalidOperation.InvalidEcsState", "InvalidOperation.InvalidEniState", "OperationConflict", "ServiceUnavailable"}) || NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
addDebug(action, response, assignprivateipaddressesrequest)
return nil
})
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
d.SetPartial("private_ip_addresses")
}
if err := ecsService.WaitForPrivateIpsListChanged(d.Id(), expandStringList(newPrivateIpAddressesSet.List())); err != nil {
return WrapError(err)
}
}
if d.HasChange("private_ips") {
oldPrivateIps, newPrivateIps := d.GetChange("private_ips")
oldPrivateIpsSet := oldPrivateIps.(*schema.Set)
newPrivateIpsSet := newPrivateIps.(*schema.Set)
removed := oldPrivateIpsSet.Difference(newPrivateIpsSet)
added := newPrivateIpsSet.Difference(oldPrivateIpsSet)
if removed.Len() > 0 {
unassignprivateipaddressesrequest := map[string]interface{}{
"NetworkInterfaceId": d.Id(),
}
unassignprivateipaddressesrequest["PrivateIpAddress"] = removed.List()
unassignprivateipaddressesrequest["RegionId"] = client.RegionId
action := "UnassignPrivateIpAddresses"
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Ecs", "2014-05-26", action, nil, unassignprivateipaddressesrequest, false)
if err != nil {
if IsExpectedErrors(err, []string{"InternalError", "InvalidOperation.InvalidEcsState", "InvalidOperation.InvalidEniState", "OperationConflict", "ServiceUnavailable"}) || NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
addDebug(action, response, unassignprivateipaddressesrequest)
return nil
})
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
d.SetPartial("private_ips")
}
if added.Len() > 0 {
assignprivateipaddressesrequest := map[string]interface{}{
"NetworkInterfaceId": d.Id(),
}
assignprivateipaddressesrequest["PrivateIpAddress"] = added.List()
assignprivateipaddressesrequest["RegionId"] = client.RegionId
action := "AssignPrivateIpAddresses"
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Ecs", "2014-05-26", action, nil, assignprivateipaddressesrequest, false)
if err != nil {
if IsExpectedErrors(err, []string{"InternalError", "InvalidOperation.InvalidEcsState", "InvalidOperation.InvalidEniState", "OperationConflict", "ServiceUnavailable"}) || NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
addDebug(action, response, assignprivateipaddressesrequest)
return nil
})
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
d.SetPartial("private_ips")
}
if err := ecsService.WaitForPrivateIpsListChanged(d.Id(), expandStringList(newPrivateIpsSet.List())); err != nil {
return WrapError(err)
}
}
if d.HasChange("private_ips_count") {
privateIpList := expandStringList(d.Get("private_ips").(*schema.Set).List())
oldIpsCount, newIpsCount := d.GetChange("private_ips_count")
if oldIpsCount != nil && newIpsCount != nil && newIpsCount != len(privateIpList) {
diff := newIpsCount.(int) - oldIpsCount.(int)
if diff > 0 {
assignPrivateIpsCountrequest := map[string]interface{}{
"NetworkInterfaceId": d.Id(),
}
assignPrivateIpsCountrequest["RegionId"] = client.RegionId
assignPrivateIpsCountrequest["SecondaryPrivateIpAddressCount"] = requests.NewInteger(diff)
action := "AssignPrivateIpAddresses"
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Ecs", "2014-05-26", action, nil, assignPrivateIpsCountrequest, false)
if err != nil {
if IsExpectedErrors(err, []string{"InternalError", "InvalidOperation.InvalidEcsState", "InvalidOperation.InvalidEniState", "OperationConflict", "ServiceUnavailable"}) || NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
addDebug(action, response, assignPrivateIpsCountrequest)
return nil
})
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
}
if diff < 0 {
diff *= -1
unAssignIps := privateIpList[:diff]
unAssignPrivateIpsCountRequest := map[string]interface{}{
"NetworkInterfaceId": d.Id(),
}
unAssignPrivateIpsCountRequest["RegionId"] = client.RegionId
unAssignPrivateIpsCountRequest["PrivateIpAddress"] = &unAssignIps
action := "UnassignPrivateIpAddresses"
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Ecs", "2014-05-26", action, nil, unAssignPrivateIpsCountRequest, false)
if err != nil {
if IsExpectedErrors(err, []string{"InternalError", "InvalidOperation.InvalidEcsState", "InvalidOperation.InvalidEniState", "OperationConflict", "ServiceUnavailable"}) || NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
addDebug(action, response, unAssignPrivateIpsCountRequest)
return nil
})
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
}
err := ecsService.WaitForPrivateIpsCountChanged(d.Id(), newIpsCount.(int))
if err != nil {
return WrapError(err)
}
d.SetPartial("private_ips_count")
}
}
if d.HasChange("secondary_private_ip_address_count") {
privateIpList := expandStringList(d.Get("private_ip_addresses").(*schema.Set).List())
oldIpsCount, newIpsCount := d.GetChange("secondary_private_ip_address_count")
if oldIpsCount != nil && newIpsCount != nil && newIpsCount != len(privateIpList) {
diff := newIpsCount.(int) - oldIpsCount.(int)
if diff > 0 {
assignSecondaryPrivateIpAddressCountrequest := map[string]interface{}{
"NetworkInterfaceId": d.Id(),
}
assignSecondaryPrivateIpAddressCountrequest["RegionId"] = client.RegionId
assignSecondaryPrivateIpAddressCountrequest["SecondaryPrivateIpAddressCount"] = requests.NewInteger(diff)
action := "AssignPrivateIpAddresses"
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Ecs", "2014-05-26", action, nil, assignSecondaryPrivateIpAddressCountrequest, false)
if err != nil {
if IsExpectedErrors(err, []string{"InternalError", "InvalidOperation.InvalidEcsState", "InvalidOperation.InvalidEniState", "OperationConflict", "ServiceUnavailable"}) || NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
addDebug(action, response, assignSecondaryPrivateIpAddressCountrequest)
return nil
})
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
}
if diff < 0 {
diff *= -1
unAssignIps := privateIpList[:diff]
unassignSecondaryPrivateIpAddressCountrequest := map[string]interface{}{
"NetworkInterfaceId": d.Id(),
}
unassignSecondaryPrivateIpAddressCountrequest["RegionId"] = client.RegionId
unassignSecondaryPrivateIpAddressCountrequest["PrivateIpAddress"] = &unAssignIps
action := "UnassignPrivateIpAddresses"
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = client.RpcPost("Ecs", "2014-05-26", action, nil, unassignSecondaryPrivateIpAddressCountrequest, false)
if err != nil {
if IsExpectedErrors(err, []string{"InternalError", "InvalidOperation.InvalidEcsState", "InvalidOperation.InvalidEniState", "OperationConflict", "ServiceUnavailable"}) || NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
return resource.NonRetryableError(err)
}
addDebug(action, response, unassignSecondaryPrivateIpAddressCountrequest)
return nil
})
if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
}
err := ecsService.WaitForPrivateIpsCountChanged(d.Id(), newIpsCount.(int))
if err != nil {
return WrapError(err)
}
d.SetPartial("secondary_private_ip_address_count")
}
}
if d.HasChange("ipv6_address_count") {
ipv6List := expandStringList(d.Get("ipv6_addresses").(*schema.Set).List())
oldIpv6Count, newIpv6Count := d.GetChange("ipv6_address_count")
if oldIpv6Count != nil && newIpv6Count != nil && newIpv6Count != len(ipv6List) {
diff := newIpv6Count.(int) - oldIpv6Count.(int)
if diff > 0 {
action := "AssignIpv6Addresses"
request := map[string]interface{}{
"RegionId": client.RegionId,
"NetworkInterfaceId": d.Id(),
"ClientToken": buildClientToken(action),
"Ipv6AddressCount": diff,
}
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutCreate), func() *resource.RetryError {
response, err = client.RpcPost("Ecs", "2014-05-26", action, nil, request, false)
if err != nil {
if NeedRetry(err) || IsExpectedErrors(err, []string{"OperationConflict"}) {
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)
}
}
if diff < 0 {
diff *= -1
action := "UnassignIpv6Addresses"
request := map[string]interface{}{
"RegionId": client.RegionId,
"NetworkInterfaceId": d.Id(),
"ClientToken": buildClientToken(action),
}
for index, val := range ipv6List[:diff] {
request[fmt.Sprintf("Ipv6Address.%d", index+1)] = val
}
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutCreate), func() *resource.RetryError {
response, err = client.RpcPost("Ecs", "2014-05-26", action, nil, request, false)
if err != nil {
if NeedRetry(err) || IsExpectedErrors(err, []string{"OperationConflict"}) {
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)
}
}
err = ecsService.WaitForModifyIpv6AddressCount(d.Id(), newIpv6Count.(int), DefaultTimeoutMedium)
if err != nil {
return WrapError(err)
}
d.SetPartial("ipv6_address_count")
d.SetPartial("ipv6_addresses")
}
}
if d.HasChange("ipv6_addresses") {
oraw, nraw := d.GetChange("ipv6_addresses")
remove := oraw.(*schema.Set).Difference(nraw.(*schema.Set)).List()
create := nraw.(*schema.Set).Difference(oraw.(*schema.Set)).List()
if len(remove) > 0 {
action := "UnassignIpv6Addresses"
request := map[string]interface{}{
"RegionId": client.RegionId,
"NetworkInterfaceId": d.Id(),
"ClientToken": buildClientToken(action),
}
for index, val := range remove {
request[fmt.Sprintf("Ipv6Address.%d", index+1)] = val
}
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutCreate), func() *resource.RetryError {
response, err = client.RpcPost("Ecs", "2014-05-26", action, nil, request, false)
if err != nil {
if NeedRetry(err) || IsExpectedErrors(err, []string{"OperationConflict"}) {
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)
}
}
if len(create) > 0 {
action := "AssignIpv6Addresses"
request := map[string]interface{}{
"RegionId": client.RegionId,
"NetworkInterfaceId": d.Id(),
"ClientToken": buildClientToken(action),
}
for index, val := range create {
request[fmt.Sprintf("Ipv6Address.%d", index+1)] = val
}
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutCreate), func() *resource.RetryError {
response, err = client.RpcPost("Ecs", "2014-05-26", action, nil, request, false)
if err != nil {
if NeedRetry(err) || IsExpectedErrors(err, []string{"OperationConflict"}) {
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)
}
}
err = ecsService.WaitForModifyIpv6Address(d.Id(), expandStringList(nraw.(*schema.Set).List()), DefaultTimeoutMedium)
if err != nil {
return WrapError(err)
}
d.SetPartial("ipv6_address_count")
d.SetPartial("ipv6_addresses")
}
if d.HasChange("ipv4_prefix_count") {
ipv4PrefixList := expandStringList(d.Get("ipv4_prefixes").(*schema.Set).List())
oldIpv4PrefixCount, newIpv4PrefixCount := d.GetChange("ipv4_prefix_count")
if oldIpv4PrefixCount != nil && newIpv4PrefixCount != nil && newIpv4PrefixCount != len(ipv4PrefixList) {
diff := newIpv4PrefixCount.(int) - oldIpv4PrefixCount.(int)
if diff > 0 {
action := "AssignPrivateIpAddresses"
request := map[string]interface{}{
"RegionId": client.RegionId,
"NetworkInterfaceId": d.Id(),
"ClientToken": buildClientToken(action),
"Ipv4PrefixCount": diff,
}
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutCreate), func() *resource.RetryError {
response, err = client.RpcPost("Ecs", "2014-05-26", action, nil, request, false)
if err != nil {
if NeedRetry(err) || IsExpectedErrors(err, []string{"OperationConflict"}) {
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)
}
}
if diff < 0 {
diff *= -1
action := "UnassignPrivateIpAddresses"
request := map[string]interface{}{
"RegionId": client.RegionId,
"NetworkInterfaceId": d.Id(),
"ClientToken": buildClientToken(action),
}
for index, val := range ipv4PrefixList[:diff] {
request[fmt.Sprintf("Ipv4Prefix.%d", index+1)] = val
}
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutCreate), func() *resource.RetryError {
response, err = client.RpcPost("Ecs", "2014-05-26", action, nil, request, false)
if err != nil {
if NeedRetry(err) || IsExpectedErrors(err, []string{"OperationConflict"}) {
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)
}
}
err = ecsService.WaitForModifyIpv4PrefixCount(d.Id(), newIpv4PrefixCount.(int), DefaultTimeoutMedium)
if err != nil {
return WrapError(err)
}
d.SetPartial("ipv4_prefix_count")
d.SetPartial("ipv4_prefixes")
}
}
if d.HasChange("ipv4_prefixes") {
oraw, nraw := d.GetChange("ipv4_prefixes")
remove := oraw.(*schema.Set).Difference(nraw.(*schema.Set)).List()
create := nraw.(*schema.Set).Difference(oraw.(*schema.Set)).List()
if len(remove) > 0 {
action := "UnassignPrivateIpAddresses"
request := map[string]interface{}{
"RegionId": client.RegionId,
"NetworkInterfaceId": d.Id(),
"ClientToken": buildClientToken(action),
}
for index, val := range remove {
request[fmt.Sprintf("Ipv4Prefix.%d", index+1)] = val
}
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutCreate), func() *resource.RetryError {
response, err = client.RpcPost("Ecs", "2014-05-26", action, nil, request, false)
if err != nil {
if NeedRetry(err) || IsExpectedErrors(err, []string{"OperationConflict"}) {
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)
}
}
if len(create) > 0 {
action := "AssignPrivateIpAddresses"
request := map[string]interface{}{
"RegionId": client.RegionId,
"NetworkInterfaceId": d.Id(),
"ClientToken": buildClientToken(action),
}
for index, val := range create {
request[fmt.Sprintf("Ipv4Prefix.%d", index+1)] = val
}
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutCreate), func() *resource.RetryError {
response, err = client.RpcPost("Ecs", "2014-05-26", action, nil, request, false)
if err != nil {
if NeedRetry(err) || IsExpectedErrors(err, []string{"OperationConflict"}) {
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)
}
}
err = ecsService.WaitForModifyIpv4Prefix(d.Id(), expandStringList(nraw.(*schema.Set).List()), DefaultTimeoutMedium)
if err != nil {
return WrapError(err)
}
d.SetPartial("ipv4_prefix_count")
d.SetPartial("ipv4_prefixes")
}
return resourceAliCloudEcsNetworkInterfaceRead(d, meta)
}