add examples file

Author: cyberHermanwang

examples/tencentcloud-ckafka/main.tf

@@ -23,4 +23,25 @@ data "tencentcloud_ckafka_acls" "foo" {
   instance_id   = tencentcloud_ckafka_acl.foo.instance_id
   resource_type = tencentcloud_ckafka_acl.foo.resource_type
   resource_name = tencentcloud_ckafka_acl.foo.resource_name
+}
+
+resource "tencentcloud_ckafka_topic" "kafka_topic" {
+	instance_id                         = "ckafka-f9ife4zz"
+	topic_name                          = "ckafka-topic-tf-test"
+	note                                = "this is test ckafka topic"
+	replica_num                         = 2
+	partition_num                       = 2
+	enable_white_list                   = true
+	ip_white_list                       = ["192.168.1.1"]
+	clean_up_policy                     = "delete"
+	sync_replica_min_num                = 1
+	unclean_leader_election_enable      = false
+	segment                             = 3600000
+	retention                           = 60000
+	max_message_bytes                   = 0
+}
+
+data "tencentcloud_ckafka_topics" "kafka_topics" {
+	instance_id						= tencentcloud_ckafka_topic.kafka_topic.instance_id
+	topic_name						= tencentcloud_ckafka_topic.kafka_topic.topic_name
 }

tencentcloud/data_source_tc_ckafka_topics.go

@@ -176,7 +176,7 @@ func dataSourceTencentCloudCkafkaTopicsRead(d *schema.ResourceData, meta interfa
 	for _, topic := range topicDetails {
 		var uncleanLeaderElectionEnable bool
 		if topic.Config.UncleanLeaderElectionEnable != nil {
-			uncleanLeaderElectionEnable = *topic.Config.UncleanLeaderElectionEnable == 1
+			uncleanLeaderElectionEnable = *topic.Config.UncleanLeaderElectionEnable != 0
 		}
 		instance := map[string]interface{}{
 			"topic_name":                     topic.TopicName,

tencentcloud/resource_tc_ckafka_topic.go

@@ -175,49 +175,32 @@ func resourceTencentCloudCkafkaTopicCreate(d *schema.ResourceData, meta interfac
 		ckafkcService = CkafkaService{
 			client: meta.(*TencentCloudClient).apiV3Conn,
 		}
-		request                                  = ckafka.NewCreateTopicRequest()
-		instanceId                               = d.Get("instance_id").(string)
-		topicName                                = d.Get("topic_name").(string)
-		cleanUpPolicy, note                      string
-		syncReplicaMinNum, uncleanLeaderElection int64
-		whiteListSwitch                          bool
-		ipWhiteLists                             = d.Get("ip_white_list").([]interface{})
-		ipWhiteList                              = make([]*string, 0, len(ipWhiteLists))
+		request               = ckafka.NewCreateTopicRequest()
+		instanceId            = d.Get("instance_id").(string)
+		topicName             = d.Get("topic_name").(string)
+		note                  string
+		ipWhiteLists          = d.Get("ip_white_list").([]interface{})
+		ipWhiteList           = make([]*string, 0, len(ipWhiteLists))
+		syncReplicaMinNum     = int64(d.Get("sync_replica_min_num").(int))
+		uncleanLeaderElection = d.Get("unclean_leader_election_enable").(bool)
+		cleanUpPolicy         = d.Get("clean_up_policy").(string)
+		whiteListSwitch       = d.Get("enable_white_list").(bool)
+		retention             = d.Get("retention").(int)
 	)
 	for _, value := range ipWhiteLists {
 		ipWhiteList = append(ipWhiteList, helper.String(value.(string)))
 	}
-	if v, ok := d.GetOk("sync_replica_min_num"); ok {
-		syncReplicaMinNum = int64(v.(int))
-		request.MinInsyncReplicas = &syncReplicaMinNum
-	}
-	if v, ok := d.GetOk("unclean_leader_election_enable"); ok {
-		uncleanLeaderElection = *helper.BoolToInt64Ptr(v.(bool))
-		request.UncleanLeaderElectionEnable = &uncleanLeaderElection
-	}
-	if v, ok := d.GetOk("enable_white_list"); ok {
-		whiteListSwitch = v.(bool)
-		request.EnableWhiteList = helper.BoolToInt64Ptr(whiteListSwitch)
-		if whiteListSwitch {
-			if len(ipWhiteList) == 0 {
-				return fmt.Errorf("this Topic %s Create Failed, reason: ip whitelist switch is on, ip whitelist cannot be empty", topicName)
-			}
-			request.IpWhiteList = ipWhiteList
+	request.EnableWhiteList = helper.BoolToInt64Ptr(whiteListSwitch)
+	if whiteListSwitch {
+		if len(ipWhiteList) == 0 {
+			return fmt.Errorf("this Topic %s Create Failed, reason: ip whitelist switch is on, ip whitelist cannot be empty", topicName)
 		}
-	}
-	if v, ok := d.GetOk("clean_up_policy"); ok {
-		cleanUpPolicy = v.(string)
-		request.CleanUpPolicy = &cleanUpPolicy
+		request.IpWhiteList = ipWhiteList
 	}
 	if v, ok := d.GetOk("note"); ok {
 		note = v.(string)
 		request.Note = &note
 	}
-	if v, ok := d.GetOk("retention"); ok {
-		if v.(int) != 0 {
-			request.RetentionMs = helper.IntInt64(v.(int))
-		}
-	}
 	if v, ok := d.GetOk("segment"); ok {
 		if v.(int) != 0 {
 			request.SegmentMs = helper.IntInt64(v.(int))
@@ -227,6 +210,10 @@ func resourceTencentCloudCkafkaTopicCreate(d *schema.ResourceData, meta interfac
 	request.TopicName = &topicName
 	request.PartitionNum = helper.IntInt64(d.Get("partition_num").(int))
 	request.ReplicaNum = helper.IntInt64(d.Get("replica_num").(int))
+	request.MinInsyncReplicas = &syncReplicaMinNum
+	request.UncleanLeaderElectionEnable = helper.BoolToInt64Ptr(uncleanLeaderElection)
+	request.CleanUpPolicy = &cleanUpPolicy
+	request.RetentionMs = helper.IntInt64(retention)
 	//Before create topic,Check if kafka exists
 	_, has, error := ckafkcService.DescribeInstanceById(ctx, instanceId)
 	if error != nil {
@@ -332,20 +319,13 @@ func resourceTencentCloudCkafkaTopicUpdate(d *schema.ResourceData, meta interfac
 	instanceId := d.Get("instance_id").(string)
 	topicName := d.Get("topic_name").(string)
 	whiteListSwitch := d.Get("enable_white_list").(bool)
-	var cleanUpPolicy, note string
-	if v, ok := d.GetOk("clean_up_policy"); ok {
-		cleanUpPolicy = v.(string)
-		request.CleanUpPolicy = &cleanUpPolicy
-	}
+	cleanUpPolicy := d.Get("clean_up_policy").(string)
+	retention := d.Get("retention").(int)
+	var note string
 	if v, ok := d.GetOk("note"); ok {
 		note = v.(string)
 		request.Note = &note
 	}
-	if v, ok := d.GetOk("retention"); ok {
-		if v.(int) != 0 {
-			request.RetentionMs = helper.IntInt64(v.(int))
-		}
-	}
 	if v, ok := d.GetOk("segment"); ok {
 		if v.(int) != 0 {
 			request.SegmentMs = helper.IntInt64(v.(int))
@@ -356,6 +336,8 @@ func resourceTencentCloudCkafkaTopicUpdate(d *schema.ResourceData, meta interfac
 	request.EnableWhiteList = helper.BoolToInt64Ptr(whiteListSwitch)
 	request.MinInsyncReplicas = helper.IntInt64(d.Get("sync_replica_min_num").(int))
 	request.UncleanLeaderElectionEnable = helper.BoolToInt64Ptr(d.Get("unclean_leader_election_enable").(bool))
+	request.CleanUpPolicy = &cleanUpPolicy
+	request.RetentionMs = helper.IntInt64(retention)
 	if d.Get("max_message_bytes").(int) != 0 {
 		request.MaxMessageBytes = helper.IntInt64(d.Get("max_message_bytes").(int))
 	}

tencentcloud/service_tencentcloud_ckafka.go

@@ -710,8 +710,13 @@ func (me *CkafkaService) DeleteCkafkaTopic(ctx context.Context, instanceId strin
 	request.TopicName = &name
 
 	ratelimit.Check(request.GetAction())
-	_, errRet = me.client.UseCkafkaClient().DeleteTopic(request)
-
+	errRet = resource.Retry(writeRetryTimeout, func() *resource.RetryError {
+		_, err := me.client.UseCkafkaClient().DeleteTopic(request)
+		if err != nil {
+			return retryError(err)
+		}
+		return nil
+	})
 	if errRet != nil {
 		return
 	}