Skip to content

Commit

Permalink
resource/alicloud_cen_transit_router_multicast_domain: Refactored the…
Browse files Browse the repository at this point in the history 
… resource alicloud_cen_transit_router_multicast_domain; Added the field options, region_id (#8148)
  • Loading branch information
@MrWolong
MrWolong authored Jan 22, 2025
1 parent d1c66fc commit bbba0cc
Show file tree
Hide file tree
Showing 4 changed files with 295 additions and 107 deletions.
217 changes: 131 additions & 86 deletions alicloud/resource_alicloud_cen_transit_router_multicast_domain.go
View file
Original file line number Diff line number Diff line change
@@ -1,14 +1,16 @@
// Package alicloud. This file is generated automatically. Please do not modify it manually, thank you!
package alicloud

import (
"fmt"
"log"
"time"

"github.com/PaesslerAG/jsonpath"
util "github.com/alibabacloud-go/tea-utils/service"
"github.com/aliyun/terraform-provider-alicloud/alicloud/connectivity"
"github.com/hashicorp/terraform-plugin-sdk/helper/resource"
"github.com/hashicorp/terraform-plugin-sdk/helper/schema"

"time"
)

func resourceAliCloudCenTransitRouterMulticastDomain() *schema.Resource {
Expand All @@ -21,61 +23,91 @@ func resourceAliCloudCenTransitRouterMulticastDomain() *schema.Resource {
State: schema.ImportStatePassthrough,
},
Timeouts: &schema.ResourceTimeout{
Create: schema.DefaultTimeout(3 * time.Minute),
Update: schema.DefaultTimeout(3 * time.Minute),
Delete: schema.DefaultTimeout(3 * time.Minute),
Create: schema.DefaultTimeout(5 * time.Minute),
Update: schema.DefaultTimeout(5 * time.Minute),
Delete: schema.DefaultTimeout(5 * time.Minute),
},
Schema: map[string]*schema.Schema{
"options": {
Type: schema.TypeList,
Optional: true,
Computed: true,
MaxItems: 1,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"igmpv2_support": {
Type: schema.TypeString,
Optional: true,
Computed: true,
},
},
},
},
"region_id": {
Type: schema.TypeString,
Computed: true,
},
"status": {
Type: schema.TypeString,
Computed: true,
},
"tags": tagsSchema(),
"transit_router_id": {
Type: schema.TypeString,
Required: true,
ForceNew: true,
},
"transit_router_multicast_domain_name": {
Type: schema.TypeString,
Optional: true,
},
"transit_router_multicast_domain_description": {
Type: schema.TypeString,
Optional: true,
},
"tags": tagsSchema(),
"status": {
"transit_router_multicast_domain_name": {
Type: schema.TypeString,
Computed: true,
Optional: true,
},
},
}
}

func resourceAliCloudCenTransitRouterMulticastDomainCreate(d *schema.ResourceData, meta interface{}) error {

client := meta.(*connectivity.AliyunClient)
cbnService := CbnService{client}
var response map[string]interface{}

action := "CreateTransitRouterMulticastDomain"
request := make(map[string]interface{})
conn, err := client.NewCbnClient()
var request map[string]interface{}
var response map[string]interface{}
query := make(map[string]interface{})
conn, err := client.NewCenClient()
if err != nil {
return WrapError(err)
}

request = make(map[string]interface{})
request["RegionId"] = client.RegionId
request["ClientToken"] = buildClientToken("CreateTransitRouterMulticastDomain")
request["ClientToken"] = buildClientToken(action)
request["TransitRouterId"] = d.Get("transit_router_id")

if v, ok := d.GetOk("transit_router_multicast_domain_name"); ok {
request["TransitRouterMulticastDomainName"] = v
}

if v, ok := d.GetOk("transit_router_multicast_domain_description"); ok {
request["TransitRouterMulticastDomainDescription"] = v
}
if v, ok := d.GetOk("tags"); ok {
tagsMap := ConvertTags(v.(map[string]interface{}))
request = expandTagsToMap(request, tagsMap)
}

if v, ok := d.GetOk("options"); ok {
jsonPathResult3, err := jsonpath.Get("$[0].igmpv2_support", v)
if err == nil && jsonPathResult3 != "" {
request["Options.Igmpv2Support"] = jsonPathResult3
}
}
runtime := util.RuntimeOptions{}
runtime.SetAutoretry(true)
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(client.GetRetryTimeout(d.Timeout(schema.TimeoutCreate)), func() *resource.RetryError {
response, err = conn.DoRequest(StringPointer(action), nil, StringPointer("POST"), StringPointer("2017-09-12"), StringPointer("AK"), nil, request, &runtime)
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutCreate), func() *resource.RetryError {
response, err = conn.DoRequest(StringPointer(action), nil, StringPointer("POST"), StringPointer("2017-09-12"), StringPointer("AK"), query, request, &runtime)
if err != nil {
if IsExpectedErrors(err, []string{"Operation.Blocking"}) || NeedRetry(err) {
wait()
Expand All @@ -93,87 +125,108 @@ func resourceAliCloudCenTransitRouterMulticastDomainCreate(d *schema.ResourceDat

d.SetId(fmt.Sprint(response["TransitRouterMulticastDomainId"]))

stateConf := BuildStateConf([]string{}, []string{"Active"}, d.Timeout(schema.TimeoutCreate), 5*time.Second, cbnService.CenTransitRouterMulticastDomainStateRefreshFunc(d.Id(), []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}

return resourceAliCloudCenTransitRouterMulticastDomainUpdate(d, meta)
return resourceAliCloudCenTransitRouterMulticastDomainRead(d, meta)
}

func resourceAliCloudCenTransitRouterMulticastDomainRead(d *schema.ResourceData, meta interface{}) error {
client := meta.(*connectivity.AliyunClient)
cbnService := CbnService{client}
cenServiceV2 := CenServiceV2{client}

object, err := cbnService.DescribeCenTransitRouterMulticastDomain(d.Id())
objectRaw, err := cenServiceV2.DescribeCenTransitRouterMulticastDomain(d.Id())
if err != nil {
if !d.IsNewResource() && NotFoundError(err) {
log.Printf("[DEBUG] Resource alicloud_cen_transit_router_multicast_domain DescribeCenTransitRouterMulticastDomain Failed!!! %s", err)
d.SetId("")
return nil
}
return WrapError(err)
}

d.Set("transit_router_id", object["TransitRouterId"])
d.Set("transit_router_multicast_domain_name", object["TransitRouterMulticastDomainName"])
d.Set("transit_router_multicast_domain_description", object["TransitRouterMulticastDomainDescription"])
d.Set("status", object["Status"])
if objectRaw["RegionId"] != nil {
d.Set("region_id", objectRaw["RegionId"])
}
if objectRaw["Status"] != nil {
d.Set("status", objectRaw["Status"])
}
if objectRaw["TransitRouterId"] != nil {
d.Set("transit_router_id", objectRaw["TransitRouterId"])
}
if objectRaw["TransitRouterMulticastDomainDescription"] != nil {
d.Set("transit_router_multicast_domain_description", objectRaw["TransitRouterMulticastDomainDescription"])
}
if objectRaw["TransitRouterMulticastDomainName"] != nil {
d.Set("transit_router_multicast_domain_name", objectRaw["TransitRouterMulticastDomainName"])
}

listTagResourcesObject, err := cbnService.ListTagResources(d.Id(), "TransitRouterMulticastDomain")
if err != nil {
return WrapError(err)
optionsMaps := make([]map[string]interface{}, 0)
optionsMap := make(map[string]interface{})
options1Raw := make(map[string]interface{})
if objectRaw["Options"] != nil {
options1Raw = objectRaw["Options"].(map[string]interface{})
}
if len(options1Raw) > 0 {
optionsMap["igmpv2_support"] = options1Raw["Igmpv2Support"]

d.Set("tags", tagsToMap(listTagResourcesObject))
optionsMaps = append(optionsMaps, optionsMap)
}
if objectRaw["Options"] != nil {
if err := d.Set("options", optionsMaps); err != nil {
return err
}
}
tagsMaps := objectRaw["Tags"]
d.Set("tags", tagsToMap(tagsMaps))

return nil
}

func resourceAliCloudCenTransitRouterMulticastDomainUpdate(d *schema.ResourceData, meta interface{}) error {
client := meta.(*connectivity.AliyunClient)
cbnService := CbnService{client}
var request map[string]interface{}
var response map[string]interface{}
var query map[string]interface{}
update := false
d.Partial(true)

if d.HasChange("tags") {
if err := cbnService.SetResourceTags(d, "TransitRouterMulticastDomain"); err != nil {
return WrapError(err)
}
d.SetPartial("tags")
}

request := map[string]interface{}{
"ClientToken": buildClientToken("ModifyTransitRouterMulticastDomain"),
"TransitRouterMulticastDomainId": d.Id(),
action := "ModifyTransitRouterMulticastDomain"
conn, err := client.NewCenClient()
if err != nil {
return WrapError(err)
}
request = make(map[string]interface{})
query = make(map[string]interface{})
request["TransitRouterMulticastDomainId"] = d.Id()

if !d.IsNewResource() && d.HasChange("transit_router_multicast_domain_name") {
request["ClientToken"] = buildClientToken(action)
if d.HasChange("transit_router_multicast_domain_name") {
update = true
}
if v, ok := d.GetOk("transit_router_multicast_domain_name"); ok {
request["TransitRouterMulticastDomainName"] = v
}

if !d.IsNewResource() && d.HasChange("transit_router_multicast_domain_description") {
if d.HasChange("transit_router_multicast_domain_description") {
update = true
}
if v, ok := d.GetOk("transit_router_multicast_domain_description"); ok {
request["TransitRouterMulticastDomainDescription"] = v
}

if update {
action := "ModifyTransitRouterMulticastDomain"
conn, err := client.NewCbnClient()
if err != nil {
return WrapError(err)
if d.HasChange("options.0.igmpv2_support") {
update = true
}
if v, ok := d.GetOk("options"); ok {
jsonPathResult3, err := jsonpath.Get("$[0].igmpv2_support", v)
if err == nil && jsonPathResult3 != "" {
request["Options.Igmpv2Support"] = jsonPathResult3
}
}

if update {
runtime := util.RuntimeOptions{}
runtime.SetAutoretry(true)
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(client.GetRetryTimeout(d.Timeout(schema.TimeoutUpdate)), func() *resource.RetryError {
response, err = conn.DoRequest(StringPointer(action), nil, StringPointer("POST"), StringPointer("2017-09-12"), StringPointer("AK"), nil, request, &runtime)
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutUpdate), func() *resource.RetryError {
response, err = conn.DoRequest(StringPointer(action), nil, StringPointer("POST"), StringPointer("2017-09-12"), StringPointer("AK"), query, request, &runtime)
if err != nil {
if IsExpectedErrors(err, []string{"Operation.Blocking"}) || NeedRetry(err) {
wait()
Expand All @@ -184,48 +237,45 @@ func resourceAliCloudCenTransitRouterMulticastDomainUpdate(d *schema.ResourceDat
return nil
})
addDebug(action, response, request)

if err != nil {
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}
}

stateConf := BuildStateConf([]string{}, []string{"Active"}, d.Timeout(schema.TimeoutUpdate), 5*time.Second, cbnService.CenTransitRouterMulticastDomainStateRefreshFunc(d.Id(), []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
if d.HasChange("tags") {
cenServiceV2 := CenServiceV2{client}
if err := cenServiceV2.SetResourceTags(d, "TRANSITROUTERMULTICASTDOMAIN"); err != nil {
return WrapError(err)
}

d.SetPartial("transit_router_multicast_domain_name")
d.SetPartial("transit_router_multicast_domain_description")
}

d.Partial(false)

return resourceAliCloudCenTransitRouterMulticastDomainRead(d, meta)
}

func resourceAliCloudCenTransitRouterMulticastDomainDelete(d *schema.ResourceData, meta interface{}) error {

client := meta.(*connectivity.AliyunClient)
cbnService := CbnService{client}
action := "DeleteTransitRouterMulticastDomain"
var request map[string]interface{}
var response map[string]interface{}

conn, err := client.NewCbnClient()
query := make(map[string]interface{})
conn, err := client.NewCenClient()
if err != nil {
return WrapError(err)
}
request = make(map[string]interface{})
request["TransitRouterMulticastDomainId"] = d.Id()

request := map[string]interface{}{
"ClientToken": buildClientToken("DeleteTransitRouterMulticastDomain"),
"TransitRouterMulticastDomainId": d.Id(),
}
request["ClientToken"] = buildClientToken(action)

runtime := util.RuntimeOptions{}
runtime.SetAutoretry(true)
wait := incrementalWait(3*time.Second, 3*time.Second)
err = resource.Retry(client.GetRetryTimeout(d.Timeout(schema.TimeoutDelete)), func() *resource.RetryError {
response, err = conn.DoRequest(StringPointer(action), nil, StringPointer("POST"), StringPointer("2017-09-12"), StringPointer("AK"), nil, request, &runtime)
wait := incrementalWait(3*time.Second, 5*time.Second)
err = resource.Retry(d.Timeout(schema.TimeoutDelete), func() *resource.RetryError {
response, err = conn.DoRequest(StringPointer(action), nil, StringPointer("POST"), StringPointer("2017-09-12"), StringPointer("AK"), query, request, &runtime)
request["ClientToken"] = buildClientToken(action)

if err != nil {
if IsExpectedErrors(err, []string{"Operation.Blocking", "IncorrectStatus.MulticastDomain", "InvalidOperation.MulticastGroupExist"}) || NeedRetry(err) {
if IsExpectedErrors(err, []string{"Operation.Blocking"}) || NeedRetry(err) {
wait()
return resource.RetryableError(err)
}
Expand All @@ -242,10 +292,5 @@ func resourceAliCloudCenTransitRouterMulticastDomainDelete(d *schema.ResourceDat
return WrapErrorf(err, DefaultErrorMsg, d.Id(), action, AlibabaCloudSdkGoERROR)
}

stateConf := BuildStateConf([]string{}, []string{}, d.Timeout(schema.TimeoutDelete), 5*time.Second, cbnService.CenTransitRouterMulticastDomainStateRefreshFunc(d.Id(), []string{}))
if _, err := stateConf.WaitForState(); err != nil {
return WrapErrorf(err, IdMsg, d.Id())
}

return nil
}
Loading

0 comments on commit bbba0cc

Please sign in to comment.