fix: cynos - support serverless cluster pause/resume (#1429)

* fix: cynos - support serverless cluster pause/resume

* changelog 1429

Author: Kagashino

.changelog/1429.txt

@@ -0,0 +1,3 @@
+```release-note:enhancement
+resource/tencentcloud_cynosdb_cluster: fix: cynos - support serverless cluster pause/resume
+```

tencentcloud/extension_cynosdb.go

@@ -372,6 +372,17 @@ func TencentCynosdbClusterBaseInfo() map[string]*schema.Schema {
 			Optional:    true,
 			Description: "Specify auto-pause delay in second while `db_mode` is `SERVERLESS`. Value range: `[600, 691200]`. Default: `600`.",
 		},
+		"serverless_status_flag": {
+			Type:         schema.TypeString,
+			Optional:     true,
+			ValidateFunc: validateAllowedStringValue([]string{"resume", "pause"}),
+			Description:  "Specify whether to pause or resume serverless cluster. values: `resume`, `pause`.",
+		},
+		"serverless_status": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Serverless cluster status. NOTE: This is a readonly attribute, to modify, please set `serverless_status_flag`.",
+		},
 	}
 
 	for k, v := range TencentCynosdbInstanceBaseInfo() {

tencentcloud/resource_tc_cynosdb_cluster.go

@@ -167,6 +167,10 @@ func resourceTencentCloudCynosdbClusterCreate(d *schema.ResourceData, meta inter
 		return fmt.Errorf("`instance_memory_size` is required while creating non-serverless cluster")
 	}
 
+	if _, ok := d.GetOk("serverless_status_flag"); ok && !isServerless {
+		return fmt.Errorf("cannot set `serverless_status_flag` while creating non-serverless cluster")
+	}
+
 	var chargeType int64 = 0
 	if v, ok := d.GetOk("charge_type"); ok {
 		if v == CYNOSDB_CHARGE_TYPE_PREPAID {
@@ -321,6 +325,15 @@ func resourceTencentCloudCynosdbClusterCreate(d *schema.ResourceData, meta inter
 		}
 	}
 
+	// serverless status
+	if v, ok := d.GetOk("serverless_status_flag"); ok {
+		resume := v.(string) == "resume"
+		err := cynosdbService.SwitchServerlessCluster(ctx, id, resume)
+		if err != nil {
+			return err
+		}
+	}
+
 	return resourceTencentCloudCynosdbClusterRead(d, meta)
 }
 
@@ -358,6 +371,12 @@ func resourceTencentCloudCynosdbClusterRead(d *schema.ResourceData, meta interfa
 	_ = d.Set("create_time", cluster.CreateTime)
 	_ = d.Set("storage_used", *cluster.UsedStorage/1000/1000)
 	_ = d.Set("auto_renew_flag", *item.RenewFlag)
+	_ = d.Set("serverless_status", cluster.ServerlessStatus)
+
+	if _, ok := d.GetOk("serverless_status_flag"); ok && *item.DbMode == CYNOSDB_SERVERLESS {
+		status := *item.ServerlessStatus
+		_ = d.Set("serverless_status_flag", status)
+	}
 
 	if _, ok := d.GetOk("db_mode"); ok || *item.DbMode == CYNOSDB_SERVERLESS {
 		_ = d.Set("db_mode", item.DbMode)
@@ -472,31 +491,34 @@ func resourceTencentCloudCynosdbClusterRead(d *schema.ResourceData, meta interfa
 		}
 	}
 
-	currentParamMap := make(map[string]*cynosdb.ParamInfo)
-	params, err := cynosdbService.DescribeClusterParams(ctx, id)
-	if err != nil {
-		return err
-	}
-	for _, param := range params {
-		currentParamMap[*param.ParamName] = param
-	}
-	resultParamItems := make([]map[string]string, 0)
-	if v, ok := d.GetOk("param_items"); ok {
-		paramItems := v.([]interface{})
-		for _, paramItem := range paramItems {
-			item := paramItem.(map[string]interface{})
-			name := item["name"].(string)
-			oldValue := item["old_value"].(string)
-			currentParamItem := make(map[string]string)
-			currentParamItem["name"] = name
-			currentParamItem["current_value"] = *currentParamMap[name].CurrentValue
-			if oldValue != "" {
-				currentParamItem["old_value"] = oldValue
+	isServerlessPaused := *item.DbMode == CYNOSDB_SERVERLESS && *item.ServerlessStatus == "pause"
+	if !isServerlessPaused {
+		currentParamMap := make(map[string]*cynosdb.ParamInfo)
+		params, err := cynosdbService.DescribeClusterParams(ctx, id)
+		if err != nil {
+			return err
+		}
+		for _, param := range params {
+			currentParamMap[*param.ParamName] = param
+		}
+		resultParamItems := make([]map[string]string, 0)
+		if v, ok := d.GetOk("param_items"); ok {
+			paramItems := v.([]interface{})
+			for _, paramItem := range paramItems {
+				item := paramItem.(map[string]interface{})
+				name := item["name"].(string)
+				oldValue := item["old_value"].(string)
+				currentParamItem := make(map[string]string)
+				currentParamItem["name"] = name
+				currentParamItem["current_value"] = *currentParamMap[name].CurrentValue
+				if oldValue != "" {
+					currentParamItem["old_value"] = oldValue
+				}
+				resultParamItems = append(resultParamItems, currentParamItem)
 			}
-			resultParamItems = append(resultParamItems, currentParamItem)
 		}
+		_ = d.Set("param_items", resultParamItems)
 	}
-	_ = d.Set("param_items", resultParamItems)
 
 	return nil
 }
@@ -690,6 +712,17 @@ func resourceTencentCloudCynosdbClusterUpdate(d *schema.ResourceData, meta inter
 		}
 	}
 
+	// update serverless status
+
+	// serverless status
+	if d.HasChange("serverless_status_flag") {
+		resume := d.Get("serverless_status_flag").(string) == "resume"
+		err := cynosdbService.SwitchServerlessCluster(ctx, clusterId, resume)
+		if err != nil {
+			return err
+		}
+	}
+
 	d.Partial(false)
 
 	return resourceTencentCloudCynosdbClusterRead(d, meta)

tencentcloud/resource_tc_cynosdb_cluster_test.go

@@ -49,7 +49,7 @@ func init() {
 	})
 }
 
-func TestAccTencentCloudCynosdbClusterResource(t *testing.T) {
+func TestAccTencentCloudCynosdbClusterResourceBasic(t *testing.T) {
 	t.Parallel()
 	resource.Test(t, resource.TestCase{
 		PreCheck:     func() { testAccPreCheck(t) },
@@ -156,6 +156,24 @@ func TestAccTencentCloudCynosdbClusterResourceServerless(t *testing.T) {
 					"auto_pause_delay",
 				},
 			},
+			{
+				Config: testAccCynosdbClusterServerlessPause,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckCynosdbClusterExists("tencentcloud_cynosdb_cluster.foo"),
+					resource.TestCheckResourceAttr("tencentcloud_cynosdb_cluster.foo", "db_mode", "SERVERLESS"),
+					resource.TestCheckResourceAttr("tencentcloud_cynosdb_cluster.foo", "serverless_status", "pause"),
+					resource.TestCheckResourceAttr("tencentcloud_cynosdb_cluster.foo", "serverless_status_flag", "pause"),
+				),
+			},
+			{
+				Config: testAccCynosdbClusterServerlessResume,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckCynosdbClusterExists("tencentcloud_cynosdb_cluster.foo"),
+					resource.TestCheckResourceAttr("tencentcloud_cynosdb_cluster.foo", "db_mode", "SERVERLESS"),
+					resource.TestCheckResourceAttr("tencentcloud_cynosdb_cluster.foo", "serverless_status", "resume"),
+					resource.TestCheckResourceAttr("tencentcloud_cynosdb_cluster.foo", "serverless_status_flag", "resume"),
+				),
+			},
 		},
 	})
 }
@@ -356,3 +374,59 @@ resource "tencentcloud_cynosdb_cluster" "foo" {
 
   force_delete = true
 }`
+const testAccCynosdbClusterServerlessPause = testAccCynosdbBasic + `
+resource "tencentcloud_cynosdb_cluster" "foo" {
+  available_zone               = var.availability_zone
+  vpc_id                       = var.my_vpc
+  subnet_id                    = var.my_subnet
+  db_type                      = "MYSQL"
+  db_version                   = "5.7"
+  cluster_name                 = "tf-cynosdb-s"
+  password                     = "cynos@123"
+  db_mode                      = "SERVERLESS"
+  min_cpu 					   = 0.25
+  max_cpu 					   = 1
+  auto_pause 				   = "yes"
+  auto_pause_delay 			   = 1000
+  instance_maintain_duration   = 3600
+  instance_maintain_start_time = 10800
+  instance_maintain_weekdays   = [
+    "Fri",
+    "Mon",
+    "Sat",
+    "Sun",
+    "Thu",
+    "Wed",
+    "Tue",
+  ]
+  serverless_status_flag       = "pause"
+  force_delete = true
+}`
+const testAccCynosdbClusterServerlessResume = testAccCynosdbBasic + `
+resource "tencentcloud_cynosdb_cluster" "foo" {
+  available_zone               = var.availability_zone
+  vpc_id                       = var.my_vpc
+  subnet_id                    = var.my_subnet
+  db_type                      = "MYSQL"
+  db_version                   = "5.7"
+  cluster_name                 = "tf-cynosdb-s"
+  password                     = "cynos@123"
+  db_mode                      = "SERVERLESS"
+  min_cpu 					   = 0.25
+  max_cpu 					   = 1
+  auto_pause 				   = "yes"
+  auto_pause_delay 			   = 1000
+  instance_maintain_duration   = 3600
+  instance_maintain_start_time = 10800
+  instance_maintain_weekdays   = [
+    "Fri",
+    "Mon",
+    "Sat",
+    "Sun",
+    "Thu",
+    "Wed",
+    "Tue",
+  ]
+  serverless_status_flag       = "resume"
+  force_delete = true
+}`

tencentcloud/service_tencentcloud_cynosdb.go

@@ -519,7 +519,121 @@ func (me *CynosdbService) DescribeClusterParams(ctx context.Context, clusterId s
 		}
 		return nil
 	})
+	if errRet != nil {
+		return
+	}
 	items = response.Response.Items
 
 	return
 }
+
+func (me *CynosdbService) ResumeServerless(ctx context.Context, request *cynosdb.ResumeServerlessRequest) (errRet error) {
+	logId := getLogId(ctx)
+	defer func() {
+		if errRet != nil {
+			log.Printf("[CRITAL]%s api[%s] fail, request body [%s], reason[%s]\n",
+				logId, request.GetAction(), request.ToJsonString(), errRet.Error())
+		}
+	}()
+
+	ratelimit.Check(request.GetAction())
+	response, err := me.client.UseCynosdbClient().ResumeServerless(request)
+
+	if err != nil {
+		errRet = err
+		return
+	}
+
+	log.Printf("[DEBUG]%s api[%s] success, request body [%s], response body [%s]\n",
+		logId, request.GetAction(), request.ToJsonString(), response.ToJsonString())
+
+	return
+}
+
+func (me *CynosdbService) PauseServerless(ctx context.Context, request *cynosdb.PauseServerlessRequest) (errRet error) {
+	logId := getLogId(ctx)
+	defer func() {
+		if errRet != nil {
+			log.Printf("[CRITAL]%s api[%s] fail, request body [%s], reason[%s]\n",
+				logId, request.GetAction(), request.ToJsonString(), errRet.Error())
+		}
+	}()
+
+	ratelimit.Check(request.GetAction())
+	response, err := me.client.UseCynosdbClient().PauseServerless(request)
+
+	if err != nil {
+		errRet = err
+		return
+	}
+
+	log.Printf("[DEBUG]%s api[%s] success, request body [%s], response body [%s]\n",
+		logId, request.GetAction(), request.ToJsonString(), response.ToJsonString())
+
+	return
+}
+
+func (me *CynosdbService) SwitchServerlessCluster(ctx context.Context, clusterId string, resume bool) error {
+	pause := !resume
+	_, detail, _, err := me.DescribeClusterById(ctx, clusterId)
+	if err != nil {
+		return err
+	}
+	st := detail.ServerlessStatus
+	if st == nil {
+		return nil
+	}
+	err = resource.Retry(writeRetryTimeout, func() *resource.RetryError {
+		if resume && *st == "resuming" || pause && *st == "pausing" {
+			return resource.RetryableError(fmt.Errorf("waiting for status %s finish", *st))
+		}
+		if resume && *st == "resume" || pause && *st == "pause" {
+			return nil
+		}
+		if resume && *st == "pause" {
+			request := cynosdb.NewResumeServerlessRequest()
+			request.ClusterId = &clusterId
+			err := me.ResumeServerless(ctx, request)
+			if err != nil {
+				return retryError(err, cynosdb.OPERATIONDENIED_SERVERLESSCLUSTERSTATUSDENIED)
+			}
+			return nil
+		}
+		if pause && *st == "resume" {
+			request := cynosdb.NewPauseServerlessRequest()
+			request.ClusterId = &clusterId
+			err := me.PauseServerless(ctx, request)
+			if err != nil {
+				return retryError(err, cynosdb.OPERATIONDENIED_SERVERLESSCLUSTERSTATUSDENIED)
+			}
+		}
+		return nil
+	})
+
+	if err != nil {
+		return err
+	}
+	statusChangeRetry := 5
+	return resource.Retry(readRetryTimeout*5, func() *resource.RetryError {
+		_, detail, _, err = me.DescribeClusterById(ctx, clusterId)
+		if err != nil {
+			return retryError(err)
+		}
+		st := detail.ServerlessStatus
+		if st == nil {
+			return resource.NonRetryableError(fmt.Errorf("cannot read serverless cluster status"))
+		}
+		if resume && *st == "pause" || pause && *st == "resume" {
+			if statusChangeRetry > 0 {
+				statusChangeRetry -= 1
+				return resource.RetryableError(fmt.Errorf("waiting for status change, retry %d", statusChangeRetry))
+			}
+			return resource.NonRetryableError(fmt.Errorf("api action invoked but status still %s", *st))
+		}
+		if resume && *st == "resuming" || pause && *st == "pausing" {
+			statusChangeRetry = 0
+			return resource.RetryableError(fmt.Errorf("waiting for status %s finished", *st))
+		}
+		return nil
+	})
+}

website/docs/r/cynosdb_cluster.html.markdown

@@ -91,6 +91,7 @@ The following arguments are supported:
 * `project_id` - (Optional, Int, ForceNew) ID of the project. `0` by default.
 * `ro_group_sg` - (Optional, List: [`String`]) IDs of security group for `ro_group`.
 * `rw_group_sg` - (Optional, List: [`String`]) IDs of security group for `rw_group`.
+* `serverless_status_flag` - (Optional, String) Specify whether to pause or resume serverless cluster. values: `resume`, `pause`.
 * `storage_limit` - (Optional, Int, ForceNew) Storage limit of CynosDB cluster instance, unit in GB. The maximum storage of a non-serverless instance in GB. NOTE: If db_type is `MYSQL` and charge_type is `PREPAID`, the value cannot exceed the maximum storage corresponding to the CPU and memory specifications, when charge_type is `POSTPAID_BY_HOUR`, this argument is unnecessary.
 * `tags` - (Optional, Map) The tags of the CynosDB cluster.
 
@@ -126,6 +127,7 @@ In addition to all arguments above, the following attributes are exported:
 * `rw_group_instances` - List of instances in the read-write instance group.
   * `instance_id` - ID of instance.
   * `instance_name` - Name of instance.
+* `serverless_status` - Serverless cluster status. NOTE: This is a readonly attribute, to modify, please set `serverless_status_flag`.
 * `storage_used` - Used storage of CynosDB cluster, unit in MB.