update dc

tencentcloud/provider.go

@@ -637,6 +637,7 @@ Serverless Cloud Function(SCF)
     tencentcloud_scf_function
 	tencentcloud_scf_function_version
 	tencentcloud_scf_function_event_invoke_config
+	tencentcloud_scf_reserved_concurrency_config
     tencentcloud_scf_namespace
 	tencentcloud_scf_layer
 	tencentcloud_scf_function_alias
@@ -1982,6 +1983,7 @@ func Provider() *schema.Provider {
 			"tencentcloud_scf_function":                                  resourceTencentCloudScfFunction(),
 			"tencentcloud_scf_function_version":                          resourceTencentCloudScfFunctionVersion(),
 			"tencentcloud_scf_function_event_invoke_config":              resourceTencentCloudScfFunctionEventInvokeConfig(),
+			"tencentcloud_scf_reserved_concurrency_config":               resourceTencentCloudScfReservedConcurrencyConfig(),
 			"tencentcloud_scf_namespace":                                 resourceTencentCloudScfNamespace(),
 			"tencentcloud_scf_layer":                                     resourceTencentCloudScfLayer(),
 			"tencentcloud_scf_function_alias":                            resourceTencentCloudScfFunctionAlias(),

tencentcloud/resource_tc_scf_reserved_concurrency_config.go

@@ -0,0 +1,172 @@
+/*
+Provides a resource to create a scf reserved_concurrency_config
+
+Example Usage
+
+```hcl
+resource "tencentcloud_scf_reserved_concurrency_config" "reserved_concurrency_config" {
+  function_name = "keep-1676351130"
+  reserved_concurrency_mem = 128000
+  namespace     = "default"
+}
+```
+
+Import
+
+scf reserved_concurrency_config can be imported using the id, e.g.
+
+```
+terraform import tencentcloud_scf_reserved_concurrency_config.reserved_concurrency_config reserved_concurrency_config_id
+```
+*/
+package tencentcloud
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"strings"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	scf "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/scf/v20180416"
+	"github.com/tencentcloudstack/terraform-provider-tencentcloud/tencentcloud/internal/helper"
+)
+
+func resourceTencentCloudScfReservedConcurrencyConfig() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceTencentCloudScfReservedConcurrencyConfigCreate,
+		Read:   resourceTencentCloudScfReservedConcurrencyConfigRead,
+		Delete: resourceTencentCloudScfReservedConcurrencyConfigDelete,
+		Importer: &schema.ResourceImporter{
+			State: schema.ImportStatePassthrough,
+		},
+		Schema: map[string]*schema.Schema{
+			"function_name": {
+				Required:    true,
+				ForceNew:    true,
+				Type:        schema.TypeString,
+				Description: "Specifies the function of which you want to configure the reserved quota.",
+			},
+
+			"reserved_concurrency_mem": {
+				Required:    true,
+				ForceNew:    true,
+				Type:        schema.TypeInt,
+				Description: "Reserved memory quota of the function. Note: the upper limit for the total reserved quota of the function is the user's total concurrency memory minus 12800.",
+			},
+
+			"namespace": {
+				Optional:    true,
+				ForceNew:    true,
+				Default:     "default",
+				Type:        schema.TypeString,
+				Description: "Function namespace. Default value: default.",
+			},
+		},
+	}
+}
+
+func resourceTencentCloudScfReservedConcurrencyConfigCreate(d *schema.ResourceData, meta interface{}) error {
+	defer logElapsed("resource.tencentcloud_scf_reserved_concurrency_config.create")()
+	defer inconsistentCheck(d, meta)()
+
+	logId := getLogId(contextNil)
+
+	var (
+		request      = scf.NewPutReservedConcurrencyConfigRequest()
+		namespace    string
+		functionName string
+	)
+	if v, ok := d.GetOk("function_name"); ok {
+		functionName = v.(string)
+		request.FunctionName = helper.String(v.(string))
+	}
+
+	if v, ok := d.GetOkExists("reserved_concurrency_mem"); ok {
+		request.ReservedConcurrencyMem = helper.IntUint64(v.(int))
+	}
+
+	if v, ok := d.GetOk("namespace"); ok {
+		namespace = v.(string)
+		request.Namespace = helper.String(v.(string))
+	}
+
+	err := resource.Retry(writeRetryTimeout, func() *resource.RetryError {
+		result, e := meta.(*TencentCloudClient).apiV3Conn.UseScfClient().PutReservedConcurrencyConfig(request)
+		if e != nil {
+			return retryError(e)
+		} else {
+			log.Printf("[DEBUG]%s api[%s] success, request body [%s], response body [%s]\n", logId, request.GetAction(), request.ToJsonString(), result.ToJsonString())
+		}
+		return nil
+	})
+	if err != nil {
+		log.Printf("[CRITAL]%s create scf ReservedConcurrencyConfig failed, reason:%+v", logId, err)
+		return err
+	}
+
+	d.SetId(namespace + FILED_SP + functionName)
+
+	return resourceTencentCloudScfReservedConcurrencyConfigRead(d, meta)
+}
+
+func resourceTencentCloudScfReservedConcurrencyConfigRead(d *schema.ResourceData, meta interface{}) error {
+	defer logElapsed("resource.tencentcloud_scf_reserved_concurrency_config.read")()
+	defer inconsistentCheck(d, meta)()
+
+	logId := getLogId(contextNil)
+
+	ctx := context.WithValue(context.TODO(), logIdKey, logId)
+
+	service := ScfService{client: meta.(*TencentCloudClient).apiV3Conn}
+
+	idSplit := strings.Split(d.Id(), FILED_SP)
+	if len(idSplit) != 2 {
+		return fmt.Errorf("id is broken,%s", d.Id())
+	}
+	namespace := idSplit[0]
+	functionName := idSplit[1]
+
+	reservedConcurrencyConfig, err := service.DescribeScfReservedConcurrencyConfigById(ctx, namespace, functionName)
+	if err != nil {
+		return err
+	}
+
+	if reservedConcurrencyConfig == nil {
+		d.SetId("")
+		log.Printf("[WARN]%s resource `ScfReservedConcurrencyConfig` [%s] not found, please check if it has been deleted.\n", logId, d.Id())
+		return nil
+	}
+
+	_ = d.Set("namespace", namespace)
+	_ = d.Set("function_name", functionName)
+
+	if reservedConcurrencyConfig.Response.ReservedMem != nil {
+		_ = d.Set("reserved_concurrency_mem", reservedConcurrencyConfig.Response.ReservedMem)
+	}
+
+	return nil
+}
+
+func resourceTencentCloudScfReservedConcurrencyConfigDelete(d *schema.ResourceData, meta interface{}) error {
+	defer logElapsed("resource.tencentcloud_scf_reserved_concurrency_config.delete")()
+	defer inconsistentCheck(d, meta)()
+
+	logId := getLogId(contextNil)
+	ctx := context.WithValue(context.TODO(), logIdKey, logId)
+
+	service := ScfService{client: meta.(*TencentCloudClient).apiV3Conn}
+	idSplit := strings.Split(d.Id(), FILED_SP)
+	if len(idSplit) != 2 {
+		return fmt.Errorf("id is broken,%s", d.Id())
+	}
+	namespace := idSplit[0]
+	functionName := idSplit[1]
+
+	if err := service.DeleteScfReservedConcurrencyConfigById(ctx, namespace, functionName); err != nil {
+		return err
+	}
+
+	return nil
+}

tencentcloud/resource_tc_scf_reserved_concurrency_config_test.go

@@ -0,0 +1,38 @@
+package tencentcloud
+
+import (
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+)
+
+func TestAccTencentCloudScfReservedConcurrencyConfigResource_basic(t *testing.T) {
+	t.Parallel()
+	resource.Test(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+		},
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccScfReservedConcurrencyConfig,
+				Check:  resource.ComposeTestCheckFunc(resource.TestCheckResourceAttrSet("tencentcloud_scf_reserved_concurrency_config.reserved_concurrency_config", "id")),
+			},
+			{
+				ResourceName:      "tencentcloud_scf_reserved_concurrency_config.reserved_concurrency_config",
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+		},
+	})
+}
+
+const testAccScfReservedConcurrencyConfig = `
+
+resource "tencentcloud_scf_reserved_concurrency_config" "reserved_concurrency_config" {
+  function_name = "keep-1676351130"
+  reserved_concurrency_mem = 128000
+  namespace     = "default"
+}
+
+`

tencentcloud/service_tencentcloud_scf.go

@@ -738,3 +738,54 @@ func (me *ScfService) DescribeScfFunctionEventInvokeConfigById(ctx context.Conte
 	FunctionEventInvokeConfig = response.Response.AsyncTriggerConfig
 	return
 }
+
+func (me *ScfService) DescribeScfReservedConcurrencyConfigById(ctx context.Context, namespace string, functionName string) (reservedConcurrencyConfig *scf.GetReservedConcurrencyConfigResponse, errRet error) {
+	logId := getLogId(ctx)
+
+	request := scf.NewGetReservedConcurrencyConfigRequest()
+	request.Namespace = &namespace
+	request.FunctionName = &functionName
+
+	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.UseScfClient().GetReservedConcurrencyConfig(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())
+
+	reservedConcurrencyConfig = response
+	return
+}
+
+func (me *ScfService) DeleteScfReservedConcurrencyConfigById(ctx context.Context, namespace string, functionName string) (errRet error) {
+	logId := getLogId(ctx)
+
+	request := scf.NewDeleteReservedConcurrencyConfigRequest()
+	request.Namespace = &namespace
+	request.FunctionName = &functionName
+
+	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.UseScfClient().DeleteReservedConcurrencyConfig(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
+}

website/docs/r/scf_reserved_concurrency_config.html.markdown

@@ -0,0 +1,47 @@
+---
+subcategory: "Serverless Cloud Function(SCF)"
+layout: "tencentcloud"
+page_title: "TencentCloud: tencentcloud_scf_reserved_concurrency_config"
+sidebar_current: "docs-tencentcloud-resource-scf_reserved_concurrency_config"
+description: |-
+  Provides a resource to create a scf reserved_concurrency_config
+---
+
+# tencentcloud_scf_reserved_concurrency_config
+
+Provides a resource to create a scf reserved_concurrency_config
+
+## Example Usage
+
+```hcl
+resource "tencentcloud_scf_reserved_concurrency_config" "reserved_concurrency_config" {
+  function_name            = "keep-1676351130"
+  reserved_concurrency_mem = 128000
+  namespace                = "default"
+}
+```
+
+## Argument Reference
+
+The following arguments are supported:
+
+* `function_name` - (Required, String, ForceNew) Specifies the function of which you want to configure the reserved quota.
+* `reserved_concurrency_mem` - (Required, Int, ForceNew) Reserved memory quota of the function. Note: the upper limit for the total reserved quota of the function is the user's total concurrency memory minus 12800.
+* `namespace` - (Optional, String, ForceNew) Function namespace. Default value: default.
+
+## Attributes Reference
+
+In addition to all arguments above, the following attributes are exported:
+
+* `id` - ID of the resource.
+
+
+
+## Import
+
+scf reserved_concurrency_config can be imported using the id, e.g.
+
+```
+terraform import tencentcloud_scf_reserved_concurrency_config.reserved_concurrency_config reserved_concurrency_config_id
+```
+

website/tencentcloud.erb

@@ -2070,6 +2070,9 @@
                                 <li>
                                     <a href="/docs/providers/tencentcloud/r/scf_namespace.html">tencentcloud_scf_namespace</a>
                                 </li>
+                                <li>
+                                    <a href="/docs/providers/tencentcloud/r/scf_reserved_concurrency_config.html">tencentcloud_scf_reserved_concurrency_config</a>
+                                </li>
                             </ul>
                         </li>
                     </ul>