feat(eg): add new operation resource for event subscription

Author: greyworld

docs/resources/eg_event_subscription_action.md

@@ -0,0 +1,70 @@
+---
+subcategory: "EventGrid (EG)"
+layout: "huaweicloud"
+page_title: "Huaweicloud: huaweicloud_eg_event_subscription_action"
+description: |-
+  Manages an EG event subscription action resource within HuaweiCloud.
+---
+
+# huaweicloud_eg_event_subscription_action
+
+Manages an EG event subscription action resource within HuaweiCloud.
+
+## Example Usage
+
+### Enable event subscription
+
+```hcl
+variable "subscription_ids" {
+  type = list(string)
+}
+
+resource "huaweicloud_eg_event_subscription_action" "enable" {
+  subscription_ids = var.subscription_ids
+  operation        = "ENABLE"
+}
+```
+
+### Disable event subscription
+
+```hcl
+variable "subscription_ids" {
+  type = list(string)
+}
+
+resource "huaweicloud_eg_event_subscription_action" "disable" {
+  subscription_ids = var.subscription_ids
+  operation        = "DISABLE"
+}
+```
+
+## Argument Reference
+
+The following arguments are supported:
+
+* `region` - (Optional, String, ForceNew) The region where the event subscription actions are located.  
+  If omitted, the provider-level region will be used.
+  Changing this creates a new resource.
+
+* `subscription_ids` - (Required, List, ForceNew) Specifies the list of subscription IDs to be operated.  
+  Changing this creates a new resource.
+
+* `operation` - (Required, Bool, ForceNew) Specifies whether to enable the event subscription.  
+  Changing this creates a new resource.
+  The valid values are as follows:
+  + **ENABLE**
+  + **DISABLE**
+
+* `enterprise_project_id` - (Optional, String) Specifies the ID of the enterprise project to which the event subscription action belongs.
+
+## Attribute Reference
+
+In addition to all arguments above, the following attributes are exported:
+
+* `id` - The resource ID.
+
+## Timeouts
+
+This resource provides the following timeouts configuration options:
+
+* `create` - Default is 3 minutes.

huaweicloud/provider.go

@@ -2288,12 +2288,13 @@ func Provider() *schema.Provider {
 			"huaweicloud_dws_workload_queue_user_associate": dws.ResourceWorkloadQueueUserAssociate(),
 			"huaweicloud_dws_workload_queue":                dws.ResourceWorkLoadQueue(),
 
-			"huaweicloud_eg_connection":           eg.ResourceConnection(),
-			"huaweicloud_eg_custom_event_channel": eg.ResourceCustomEventChannel(),
-			"huaweicloud_eg_custom_event_source":  eg.ResourceCustomEventSource(),
-			"huaweicloud_eg_endpoint":             eg.ResourceEndpoint(),
-			"huaweicloud_eg_event_stream":         eg.ResourceEventStream(),
-			"huaweicloud_eg_event_subscription":   eg.ResourceEventSubscription(),
+			"huaweicloud_eg_connection":                eg.ResourceConnection(),
+			"huaweicloud_eg_custom_event_channel":      eg.ResourceCustomEventChannel(),
+			"huaweicloud_eg_custom_event_source":       eg.ResourceCustomEventSource(),
+			"huaweicloud_eg_endpoint":                  eg.ResourceEndpoint(),
+			"huaweicloud_eg_event_stream":              eg.ResourceEventStream(),
+			"huaweicloud_eg_event_subscription":        eg.ResourceEventSubscription(),
+			"huaweicloud_eg_event_subscription_action": eg.ResourceEventSubscriptionAction(),
 
 			"huaweicloud_elb_certificate":                  elb.ResourceCertificateV3(),
 			"huaweicloud_elb_certificate_private_key_echo": elb.ResourceCertificatePrivateKeyEcho(),

huaweicloud/services/acceptance/acceptance.go

@@ -501,12 +501,13 @@ var (
 	HW_CODEARTS_SSH_CREDENTIAL_ID = os.Getenv("HW_CODEARTS_SSH_CREDENTIAL_ID")
 
 	HW_EG_TEST_ON     = os.Getenv("HW_EG_TEST_ON") // Whether to run the EG related tests.
-	HW_EG_CHANNEL_ID  = os.Getenv("HW_EG_CHANNEL_ID")
 	HW_EG_AGENCY_NAME = os.Getenv("HW_EG_AGENCY_NAME")
+	HW_EG_CHANNEL_ID  = os.Getenv("HW_EG_CHANNEL_ID")
 	// Currently, only up to 3 target connections are allowed to be created, so this variable is provided.
 	// The IDs of the EG connections. Using commas (,) to separate multiple IDs, the first ID is the webhook connection,
 	// the second is the Kafka connection, and the connections cannot be the default.
-	HW_EG_CONNECTION_IDS = os.Getenv("HW_EG_CONNECTION_IDS")
+	HW_EG_CONNECTION_IDS        = os.Getenv("HW_EG_CONNECTION_IDS")
+	HW_EG_EVENT_SUBSCRIPTION_ID = os.Getenv("HW_EG_EVENT_SUBSCRIPTION_ID")
 
 	HW_KOOGALLERY_ASSET = os.Getenv("HW_KOOGALLERY_ASSET")
 
@@ -2591,6 +2592,13 @@ func TestAccPreCheckEgConnectionIds(t *testing.T) {
 	}
 }
 
+// lintignore:AT003
+func TestAccPreCheckEgEventSubscriptionId(t *testing.T) {
+	if HW_EG_EVENT_SUBSCRIPTION_ID == "" {
+		t.Skip("The sub-resource acceptance test of the EG event subscription must set 'HW_EG_EVENT_SUBSCRIPTION_ID'")
+	}
+}
+
 // lintignore:AT003
 func TestAccPreCheckLtsAomAccess(t *testing.T) {
 	if HW_LTS_CLUSTER_ID == "" || HW_LTS_CLUSTER_NAME == "" {

huaweicloud/services/acceptance/eg/resource_huaweicloud_eg_event_subscription_action_test.go

@@ -0,0 +1,61 @@
+package eg
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+
+	"github.com/huaweicloud/terraform-provider-huaweicloud/huaweicloud/services/acceptance"
+)
+
+func TestAccEventSubscriptionAction_basic(t *testing.T) {
+	var (
+		rcName = "huaweicloud_eg_event_subscription_action.test"
+	)
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck: func() {
+			acceptance.TestAccPreCheck(t)
+			acceptance.TestAccPreCheckEgEventSubscriptionId(t)
+		},
+		ProviderFactories: acceptance.TestAccProviderFactories,
+		// This resource is a one-time action resource and there is no logic in the delete method.
+		// lintignore:AT001
+		CheckDestroy: nil,
+		Steps: []resource.TestStep{
+			{
+				Config: testEventSubscriptionAction_basic(),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr(rcName, "operation", "ENABLE"),
+					resource.TestCheckResourceAttr(rcName, "subscription_ids.#", "1"),
+				),
+			},
+			{
+				Config: testEventSubscriptionAction_disable(),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr(rcName, "operation", "DISABLE"),
+					resource.TestCheckResourceAttr(rcName, "subscription_ids.#", "1"),
+				),
+			},
+		},
+	})
+}
+
+func testEventSubscriptionAction_basic() string {
+	return fmt.Sprintf(`
+resource "huaweicloud_eg_event_subscription_action" "test" {
+  subscription_ids = ["%[1]s"]
+  operation        = "ENABLE"
+}
+`, acceptance.HW_EG_EVENT_SUBSCRIPTION_ID)
+}
+
+func testEventSubscriptionAction_disable() string {
+	return fmt.Sprintf(`
+resource "huaweicloud_eg_event_subscription_action" "test" {
+  subscription_ids = ["%[1]s"]
+  operation        = "DISABLE"
+}
+`, acceptance.HW_EG_EVENT_SUBSCRIPTION_ID)
+}

huaweicloud/services/eg/resource_huaweicloud_eg_event_subscription_action.go

@@ -0,0 +1,169 @@
+package eg
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/hashicorp/go-uuid"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
+
+	"github.com/chnsz/golangsdk"
+
+	"github.com/huaweicloud/terraform-provider-huaweicloud/huaweicloud/config"
+	"github.com/huaweicloud/terraform-provider-huaweicloud/huaweicloud/utils"
+)
+
+var eventSubscriptionNonUpdateParams = []string{"subscription_ids", "operation", "enterprise_project_id"}
+
+// @API EG POST /v1/{project_id}/subscriptions/operation
+func ResourceEventSubscriptionAction() *schema.Resource {
+	return &schema.Resource{
+		CreateContext: resourceEventSubscriptionActionCreate,
+		ReadContext:   resourceEventSubscriptionActionRead,
+		UpdateContext: resourceEventSubscriptionActionUpdate,
+		DeleteContext: resourceEventSubscriptionActionDelete,
+
+		Timeouts: &schema.ResourceTimeout{
+			Create: schema.DefaultTimeout(3 * time.Minute),
+		},
+
+		CustomizeDiff: config.FlexibleForceNew(eventSubscriptionNonUpdateParams),
+
+		Schema: map[string]*schema.Schema{
+			"region": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				Computed:    true,
+				ForceNew:    true,
+				Description: `The region where the event subscriptions are located.`,
+			},
+			"subscription_ids": {
+				Type:        schema.TypeList,
+				Required:    true,
+				ForceNew:    true,
+				Elem:        &schema.Schema{Type: schema.TypeString},
+				Description: `The list of subscription IDs to be operated.`,
+			},
+			"operation": {
+				Type:        schema.TypeString,
+				Required:    true,
+				Description: `Whether to enable the event subscription.`,
+			},
+			"enterprise_project_id": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				Description: `The ID of the enterprise project.`,
+			},
+			// Internal parameters.
+			"enable_force_new": {
+				Type:         schema.TypeString,
+				Optional:     true,
+				ValidateFunc: validation.StringInSlice([]string{"true", "false"}, false),
+				Description:  utils.SchemaDesc("", utils.SchemaDescInput{Internal: true}),
+			},
+		},
+	}
+}
+
+func buildEventSubscriptionActionBodyParams(d *schema.ResourceData) map[string]interface{} {
+	return map[string]interface{}{
+		"subscription_ids": d.Get("subscription_ids"),
+		"operation":        d.Get("operation"),
+	}
+}
+
+func buildEventSubscriptionActionQueryParams(d *schema.ResourceData) string {
+	res := ""
+	if v, ok := d.GetOk("enterprise_project_id"); ok {
+		res += fmt.Sprintf("?enterprise_project_id=%s", v.(string))
+	}
+	return res
+}
+
+func checkEventSubscriptionActionResult(respBody interface{}) error {
+	failedCount := utils.PathSearch("failed_count", respBody, 0).(int)
+	if failedCount > 0 {
+		events := utils.PathSearch("events", respBody, make([]interface{}, 0)).([]interface{})
+		var failedSubscriptions []string
+		for _, event := range events {
+			if errorCode := utils.PathSearch("error_code", event, nil); errorCode != nil {
+				subscriptionId := utils.PathSearch("subscription_id", event, "").(string)
+				errorMsg := utils.PathSearch("error_msg", event, "").(string)
+				failedSubscriptions = append(failedSubscriptions, fmt.Sprintf("subscription %s: %s (%s)", subscriptionId, errorMsg, errorCode))
+			}
+		}
+		return fmt.Errorf("failed to operate %d subscription(s): %s", failedCount, strings.Join(failedSubscriptions, "; "))
+	}
+	return nil
+}
+
+func resourceEventSubscriptionActionCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	var (
+		cfg     = meta.(*config.Config)
+		region  = cfg.GetRegion(d)
+		httpUrl = "v1/{project_id}/subscriptions/operation"
+	)
+
+	client, err := cfg.NewServiceClient("eg", region)
+	if err != nil {
+		return diag.Errorf("error creating EG client: %s", err)
+	}
+
+	createPath := client.Endpoint + httpUrl
+	createPath = strings.ReplaceAll(createPath, "{project_id}", client.ProjectID)
+	createPath += buildEventSubscriptionActionQueryParams(d)
+	createOpt := golangsdk.RequestOpts{
+		KeepResponseBody: true,
+		MoreHeaders: map[string]string{
+			"Content-Type": "application/json",
+		},
+		JSONBody: buildEventSubscriptionActionBodyParams(d),
+	}
+
+	resp, err := client.Request("POST", createPath, &createOpt)
+	if err != nil {
+		return diag.Errorf("error creating EG event subscription action: %s", err)
+	}
+
+	respBody, err := utils.FlattenResponse(resp)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	// Check if there are any failed operations
+	err = checkEventSubscriptionActionResult(respBody)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	randomUUID, err := uuid.GenerateUUID()
+	if err != nil {
+		return diag.Errorf("unable to generate ID: %s", err)
+	}
+	d.SetId(randomUUID)
+
+	return resourceEventSubscriptionActionRead(ctx, d, meta)
+}
+
+func resourceEventSubscriptionActionRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	return nil
+}
+
+func resourceEventSubscriptionActionUpdate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	return nil
+}
+
+func resourceEventSubscriptionActionDelete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	errorMsg := `This resource is a one-time action resource using to operate event subscription status. Deleting this resource will
+not clear the corresponding request record, but will only remove the resource information from the tfstate file.`
+	return diag.Diagnostics{
+		diag.Diagnostic{
+			Severity: diag.Warning,
+			Summary:  errorMsg,
+		},
+	}
+}