Merge pull request #1489 from ritch2022/feature/ci_guetzli_and_original_pic_protection

CI resources: Guetzli and original image protection

Author: gitmkn

.changelog/1489.txt

@@ -0,0 +1,7 @@
+```release-note:new-resource
+tencentcloud_ci_guetzli
+```
+
+```release-note:new-resource
+tencentcloud_ci_original_image_protection
+```

tencentcloud/common.go

@@ -19,6 +19,7 @@ import (
 	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
 	"github.com/pkg/errors"
 	sdkErrors "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/errors"
+	"github.com/tencentyun/cos-go-sdk-v5"
 	"gopkg.in/yaml.v2"
 )
 
@@ -81,6 +82,15 @@ var retryableErrorCode = []string{
 	"InvalidParameter.ActionInProgress",
 }
 
+// retryableCosErrorCode is retryable error code for COS/CI SDK
+var retryableCosErrorCode = []string{
+	"RequestTimeout",
+	"InternalError",
+	"KmsInternalException",
+	"ServiceUnavailable",
+	"SlowDown",
+}
+
 func init() {
 	logFirstTime = fmt.Sprintf("%d", time.Now().UnixNano()/int64(time.Millisecond))
 }
@@ -161,14 +171,64 @@ func retryError(err error, additionRetryableError ...string) *resource.RetryErro
 				return resource.RetryableError(err)
 			}
 		}
-
+	case *cos.ErrorResponse:
+		if isCosExpectedError(realErr, retryableCosErrorCode) {
+			log.Printf("[CRITAL] Retryable defined error: %v", err)
+			return resource.RetryableError(err)
+		}
+		if len(additionRetryableError) > 0 {
+			if isCosExpectedError(realErr, additionRetryableError) {
+				log.Printf("[CRITAL] Retryable additional error: %v", err)
+				return resource.RetryableError(err)
+			}
+		}
 	default:
 	}
 
 	log.Printf("[CRITAL] NonRetryable error: %v", err)
 	return resource.NonRetryableError(err)
 }
 
+// RetryWhenContext retries the function `f` when the error it returns satisfies `predicate`.
+// `f` is retried until `timeout` expires.
+func RetryWithContext(
+	ctx context.Context,
+	timeout time.Duration,
+	f func(context.Context) (interface{}, error),
+	additionRetryableError ...string) (interface{}, error) {
+	var output interface{}
+
+	retryErr := resource.Retry(timeout, func() *resource.RetryError {
+		var err error
+		output, err = f(ctx)
+
+		if err != nil {
+			return retryError(err, additionRetryableError...)
+		}
+		return nil
+
+	})
+	if retryErr != nil {
+		return nil, retryErr
+	}
+	return output, nil
+}
+
+// isCosExpectedError returns whether error is expected error when using COS SDK
+func isCosExpectedError(err error, expectedError []string) bool {
+	e, ok := err.(*cos.ErrorResponse)
+	if !ok {
+		return false
+	}
+
+	errCode := e.Code
+	if IsContains(expectedError, errCode) {
+		return true
+	} else {
+		return false
+	}
+}
+
 // isExpectError returns whether error is expected error
 func isExpectError(err error, expectError []string) bool {
 	e, ok := err.(*sdkErrors.TencentCloudSDKError)

tencentcloud/connectivity/client.go

@@ -980,7 +980,7 @@ func (me *TencentCloudClient) UseDtsClient() *dts.Client {
 func (me *TencentCloudClient) UseCiClient(bucket string) *cos.Client {
 	u, _ := url.Parse(fmt.Sprintf("https://%s.ci.%s.myqcloud.com", bucket, me.Region))
 
-	if me.ciConn != nil && me.ciConn.BaseURL.BucketURL == u {
+	if me.ciConn != nil && me.ciConn.BaseURL.CIURL == u {
 		return me.ciConn
 	}
 

tencentcloud/provider.go

@@ -884,6 +884,8 @@ Cloud Infinite(CI)
 	tencentcloud_ci_media_transcode_pro_template
 	tencentcloud_ci_media_smart_cover_template
 	tencentcloud_ci_media_speech_recognition_template
+	tencentcloud_ci_guetzli
+	tencentcloud_ci_original_image_protection
 
 TDMQ for CMQ
   Data Source
@@ -1581,6 +1583,8 @@ func Provider() terraform.ResourceProvider {
 			"tencentcloud_ci_media_transcode_pro_template":            resourceTencentCloudCiMediaTranscodeProTemplate(),
 			"tencentcloud_ci_media_smart_cover_template":              resourceTencentCloudCiMediaSmartCoverTemplate(),
 			"tencentcloud_ci_media_speech_recognition_template":       resourceTencentCloudCiMediaSpeechRecognitionTemplate(),
+			"tencentcloud_ci_guetzli":                                 resourceTencentCloudCIGuetzli(),
+			"tencentcloud_ci_original_image_protection":               resourceTencentCloudCIOriginalImageProtection(),
 		},
 
 		ConfigureFunc: providerConfigure,

tencentcloud/resource_tc_ci_guetzli.go

@@ -0,0 +1,128 @@
+/*
+Manage Guetzli compression functionality
+
+Example Usage
+
+```hcl
+
+resource "tencentcloud_ci_guetzli" "foo" {
+	bucket = "examplebucket-1250000000"
+	status = "on"
+}
+
+```
+
+Import
+
+Resource guetzli can be imported using the id, e.g.
+
+```
+$ terraform import tencentcloud_ci_guetzli.example examplebucket-1250000000
+```
+
+*/
+package tencentcloud
+
+import (
+	"context"
+	"log"
+
+	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+	"github.com/hashicorp/terraform-plugin-sdk/helper/validation"
+)
+
+func resourceTencentCloudCIGuetzli() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceTencentCloudCIGuetzliCreate,
+		Read:   resourceTencentCloudCIGuetzliRead,
+		Update: resourceTencentCloudCIGuetzliUpdate,
+		Delete: resourceTencentCloudCIGuetzliDelete,
+		Importer: &schema.ResourceImporter{
+			State: schema.ImportStatePassthrough,
+		},
+		Schema: map[string]*schema.Schema{
+			"bucket": {
+				Type:         schema.TypeString,
+				Required:     true,
+				ForceNew:     true,
+				Description:  "The name of a bucket, the format should be [custom name]-[appid], for example `mycos-1258798060`.",
+				ValidateFunc: validateCosBucketName,
+			},
+			"status": {
+				Type:         schema.TypeString,
+				Required:     true,
+				Description:  "Whether Guetzli is set, options: on/off.",
+				ValidateFunc: validation.StringInSlice([]string{"on", "off"}, false),
+			},
+		},
+	}
+}
+
+func resourceTencentCloudCIGuetzliCreate(d *schema.ResourceData, meta interface{}) error {
+	defer logElapsed("resource.tencentcloud_ci_guetzli.create")()
+
+	d.SetId(d.Get("bucket").(string))
+	return resourceTencentCloudCIGuetzliUpdate(d, meta)
+}
+
+func resourceTencentCloudCIGuetzliRead(d *schema.ResourceData, meta interface{}) error {
+	defer logElapsed("resource.tencentcloud_ci_guetzli.read")()
+	defer inconsistentCheck(d, meta)()
+
+	logId := getLogId(contextNil)
+	ctx := context.WithValue(context.TODO(), logIdKey, logId)
+
+	bucket := d.Id()
+	service := CiService{client: meta.(*TencentCloudClient).apiV3Conn}
+	res, err := service.GetCiGuetzliById(ctx, bucket)
+	if err != nil {
+		return err
+	}
+
+	log.Printf("[DEBUG] bucket=%s status=%s", bucket, res.GuetzliStatus)
+	_ = d.Set("bucket", bucket)
+	_ = d.Set("status", res.GuetzliStatus)
+	return nil
+}
+
+func resourceTencentCloudCIGuetzliUpdate(d *schema.ResourceData, meta interface{}) error {
+	defer logElapsed("resource.tencentcloud_ci_guetzli.update")()
+
+	logId := getLogId(contextNil)
+	ctx := context.WithValue(context.TODO(), logIdKey, logId)
+
+	bucket := d.Id()
+	if d.HasChange("status") {
+		var err error
+		service := CiService{client: meta.(*TencentCloudClient).apiV3Conn}
+
+		newStatus := d.Get("status")
+		if newStatus == "on" {
+			err = service.OpenCiGuetzliById(ctx, bucket)
+		} else {
+			err = service.CloseCiGuetzliById(ctx, bucket)
+		}
+		if err != nil {
+			return err
+		}
+		return resourceTencentCloudCIGuetzliRead(d, meta)
+
+	}
+	return nil
+}
+
+func resourceTencentCloudCIGuetzliDelete(d *schema.ResourceData, meta interface{}) error {
+	defer logElapsed("resource.tencentcloud_ci_guetzli.delete")()
+
+	logId := getLogId(contextNil)
+	ctx := context.WithValue(context.TODO(), logIdKey, logId)
+
+	bucket := d.Get("bucket").(string)
+	service := CiService{client: meta.(*TencentCloudClient).apiV3Conn}
+	err := service.CloseCiGuetzliById(ctx, bucket)
+
+	if err != nil {
+		return err
+	}
+	return nil
+}

tencentcloud/resource_tc_ci_guetzli_test.go

@@ -0,0 +1,76 @@
+package tencentcloud
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-sdk/helper/resource"
+	"github.com/hashicorp/terraform-plugin-sdk/terraform"
+)
+
+func TestAccTencentCloudCIGuetzli_basic(t *testing.T) {
+	resourceName := "tencentcloud_ci_guetzli.basic"
+	resource.Test(t, resource.TestCase{
+		PreCheck:  func() { testAccPreCheck(t) },
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccTencentCloudCIGuetzliConfig_basic("on"),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckCIGuetzliOn(resourceName),
+					resource.TestCheckResourceAttr(resourceName, "status", "on"),
+				),
+			},
+			{
+				ResourceName:      resourceName,
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+			{
+				Config: testAccTencentCloudCIGuetzliConfig_basic("off"),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr(resourceName, "status", "off"),
+				),
+			},
+		},
+	})
+}
+
+func testAccCheckCIGuetzliOn(resourceName string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		rs, ok := s.RootModule().Resources[resourceName]
+		if !ok {
+			return fmt.Errorf("Not found: %s", resourceName)
+		}
+
+		if rs.Primary.ID == "" {
+			return fmt.Errorf("Resource (%s) ID not set", resourceName)
+		}
+
+		bucket := rs.Primary.ID
+		service := CiService{client: testAccProvider.Meta().(*TencentCloudClient).apiV3Conn}
+		res, err := service.GetCiGuetzliById(context.Background(), bucket)
+
+		if err != nil {
+			return fmt.Errorf("error getting COS bucket Guetzli set (%s): %w", bucket, err)
+		}
+		if res.GuetzliStatus != "on" {
+			return fmt.Errorf("error setting COS bucket Guetzli (%s): status(%s)", bucket, res.GuetzliStatus)
+		}
+		return nil
+	}
+}
+
+func testAccTencentCloudCIGuetzliConfig_basic(status string) string {
+	return fmt.Sprintf(`
+variable "bucket" {
+	default = %[1]q
+	}
+
+resource "tencentcloud_ci_guetzli" "basic" {
+	bucket = var.bucket
+	status = %[2]q
+}
+`, defaultCiBucket, status)
+}