feat(container): add trigger resource (#2036)

* feat(container): add trigger resource

* add doc

* fix return

Author: Codelax

docs/resources/container_trigger.md

@@ -0,0 +1,62 @@
+---
+subcategory: "Containers"
+page_title: "Scaleway: scaleway_container_trigger"
+---
+
+# scaleway_container_trigger
+
+Creates and manages Scaleway Container Triggers.
+For more information see [the documentation](https://www.scaleway.com/en/developers/api/serverless-containers/#path-triggers).
+
+## Examples
+
+### Basic
+
+```hcl
+resource scaleway_container_trigger main {
+  container_id = scaleway_container.main.id
+  name = "my-trigger"
+  sqs {
+    namespace_id = scaleway_mnq_namespace.main.id
+    queue = "MyQueue"
+    # If project or region is different
+    project_id = scaleway_mnq_namespace.main.project_id
+    region = scaleway_mnq_namespace.main.region
+  }
+}
+```
+
+## Arguments Reference
+
+The following arguments are supported:
+
+- `container_id` (Required) The ID of the container to create a trigger for
+
+- `name` - (Optional) The unique name of the trigger. Default to a generated name.
+
+- `description` (Optional) The description of the trigger.
+
+- `sqs` The configuration of the Scaleway's SQS used by the trigger
+    - `namespace_id` (Required) ID of the mnq namespace
+    - `queue` (Required) Name of the queue
+    - `project_id` (Optional) ID of the project that contain the mnq namespace, defaults to provider's project
+    - `region` (Optional) Region where the mnq namespace is, defaults to provider's region
+
+- `region` - (Defaults to [provider](../index.md#region) `region`). The [region](../guides/regions_and_zones.md#regions) in which the namespace should be created.
+
+
+## Attributes Reference
+
+In addition to all arguments above, the following attributes are exported:
+
+- `id` - The ID of the container trigger
+
+- ~> **Important:** Container Triggers' IDs are [regional](../guides/regions_and_zones.md#resource-ids), which means they are of the form `{region}/{id}`, e.g. `fr-par/11111111-1111-1111-1111-111111111111`
+
+## Import
+
+Container Triggers can be imported using the `{region}/{id}`, e.g.
+
+```bash
+$ terraform import scaleway_container_trigger.main fr-par/11111111-1111-1111-1111-111111111111
+```

scaleway/helpers_container_triggers.go

@@ -0,0 +1,56 @@
+package scaleway
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	container "github.com/scaleway/scaleway-sdk-go/api/container/v1beta1"
+	"github.com/scaleway/scaleway-sdk-go/scw"
+)
+
+func waitForContainerTrigger(ctx context.Context, containerAPI *container.API, region scw.Region, id string, timeout time.Duration) (*container.Trigger, error) {
+	retryInterval := defaultFunctionRetryInterval
+	if DefaultWaitRetryInterval != nil {
+		retryInterval = *DefaultWaitRetryInterval
+	}
+
+	trigger, err := containerAPI.WaitForTrigger(&container.WaitForTriggerRequest{
+		Region:        region,
+		TriggerID:     id,
+		RetryInterval: &retryInterval,
+		Timeout:       scw.TimeDurationPtr(timeout),
+	}, scw.WithContext(ctx))
+
+	return trigger, err
+}
+
+func expandContainerTriggerMnqSqsCreationConfig(i interface{}) *container.CreateTriggerRequestMnqSqsClientConfig {
+	m := i.(map[string]interface{})
+
+	return &container.CreateTriggerRequestMnqSqsClientConfig{
+		MnqNamespaceID: expandID(m["namespace_id"].(string)),
+		Queue:          m["queue"].(string),
+		MnqProjectID:   m["project_id"].(string),
+		MnqRegion:      m["region"].(string),
+	}
+}
+
+func completeContainerTriggerMnqSqsCreationConfig(i interface{}, d *schema.ResourceData, meta interface{}, region scw.Region) error {
+	m := i.(map[string]interface{})
+
+	if sqsRegion, exists := m["region"]; !exists || sqsRegion == "" {
+		m["region"] = region.String()
+	}
+
+	if projectID, exists := m["project_id"]; !exists || projectID == "" {
+		projectID, _, err := extractProjectID(d, meta.(*Meta))
+		if err != nil {
+			return fmt.Errorf("failed to find a valid project_id")
+		}
+		m["project_id"] = projectID
+	}
+
+	return nil
+}

scaleway/provider.go

@@ -94,6 +94,7 @@ func Provider(config *ProviderConfig) plugin.ProviderFunc {
 				"scaleway_container_namespace":                 resourceScalewayContainerNamespace(),
 				"scaleway_container_cron":                      resourceScalewayContainerCron(),
 				"scaleway_container_domain":                    resourceScalewayContainerDomain(),
+				"scaleway_container_trigger":                   resourceScalewayContainerTrigger(),
 				"scaleway_domain_record":                       resourceScalewayDomainRecord(),
 				"scaleway_domain_zone":                         resourceScalewayDomainZone(),
 				"scaleway_flexible_ip":                         resourceScalewayFlexibleIP(),

scaleway/resource_container_trigger.go

@@ -0,0 +1,221 @@
+package scaleway
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	container "github.com/scaleway/scaleway-sdk-go/api/container/v1beta1"
+	"github.com/scaleway/scaleway-sdk-go/scw"
+)
+
+func resourceScalewayContainerTrigger() *schema.Resource {
+	return &schema.Resource{
+		CreateContext: resourceScalewayContainerTriggerCreate,
+		ReadContext:   resourceScalewayContainerTriggerRead,
+		UpdateContext: resourceScalewayContainerTriggerUpdate,
+		DeleteContext: resourceScalewayContainerTriggerDelete,
+		Importer: &schema.ResourceImporter{
+			StateContext: schema.ImportStatePassthroughContext,
+		},
+		Timeouts: &schema.ResourceTimeout{
+			Default: schema.DefaultTimeout(defaultFunctionTimeout),
+			Read:    schema.DefaultTimeout(defaultFunctionTimeout),
+			Update:  schema.DefaultTimeout(defaultFunctionTimeout),
+			Delete:  schema.DefaultTimeout(defaultFunctionTimeout),
+			Create:  schema.DefaultTimeout(defaultFunctionTimeout),
+		},
+		SchemaVersion: 0,
+		Schema: map[string]*schema.Schema{
+			"container_id": {
+				Type:         schema.TypeString,
+				Required:     true,
+				Description:  "The ID of the container to create a trigger for",
+				ValidateFunc: validationUUIDorUUIDWithLocality(),
+			},
+			"name": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Optional:    true,
+				Description: "The trigger name",
+			},
+			"description": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				Description: "The trigger description",
+			},
+			"sqs": {
+				Type:        schema.TypeList,
+				MaxItems:    1,
+				Description: "Config for sqs based trigger using scaleway mnq",
+				Optional:    true,
+				ForceNew:    true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"namespace_id": {
+							Required:         true,
+							Type:             schema.TypeString,
+							Description:      "ID of the mnq namespace",
+							DiffSuppressFunc: diffSuppressFuncLocality,
+						},
+						"queue": {
+							Required:    true,
+							Type:        schema.TypeString,
+							Description: "Name of the queue",
+						},
+						"project_id": {
+							Computed:    true,
+							Optional:    true,
+							Type:        schema.TypeString,
+							Description: "Project ID of the project where the mnq sqs exists, defaults to provider project_id",
+						},
+						"region": {
+							Computed:    true,
+							Optional:    true,
+							Type:        schema.TypeString,
+							Description: "Region where the mnq sqs exists, defaults to function's region",
+						},
+					},
+				},
+			},
+			"region": regionSchema(),
+		},
+		CustomizeDiff: customizeDiffLocalityCheck("container_id"),
+	}
+}
+
+func resourceScalewayContainerTriggerCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	api, region, err := containerAPIWithRegion(d, meta)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	req := &container.CreateTriggerRequest{
+		Region:      region,
+		Name:        expandOrGenerateString(d.Get("name").(string), "trigger"),
+		ContainerID: expandID(d.Get("container_id")),
+		Description: expandStringPtr(d.Get("description")),
+	}
+
+	if scwSqs, isScwSqs := d.GetOk("sqs.0"); isScwSqs {
+		err := completeContainerTriggerMnqSqsCreationConfig(scwSqs, d, meta, region)
+		if err != nil {
+			return diag.FromErr(fmt.Errorf("failed to complete sqs config: %w", err))
+		}
+
+		_ = d.Set("sqs", []any{scwSqs})
+		req.ScwSqsConfig = expandContainerTriggerMnqSqsCreationConfig(scwSqs)
+	}
+
+	trigger, err := api.CreateTrigger(req, scw.WithContext(ctx))
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	d.SetId(newRegionalIDString(region, trigger.ID))
+
+	_, err = waitForContainerTrigger(ctx, api, region, trigger.ID, d.Timeout(schema.TimeoutCreate))
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	return resourceScalewayContainerTriggerRead(ctx, d, meta)
+}
+
+func resourceScalewayContainerTriggerRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	api, region, id, err := containerAPIWithRegionAndID(meta, d.Id())
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	trigger, err := waitForContainerTrigger(ctx, api, region, id, d.Timeout(schema.TimeoutRead))
+	if err != nil {
+		if is404Error(err) {
+			d.SetId("")
+			return nil
+		}
+		return diag.FromErr(err)
+	}
+
+	_ = d.Set("name", trigger.Name)
+	_ = d.Set("description", trigger.Description)
+
+	diags := diag.Diagnostics(nil)
+
+	if trigger.Status == container.TriggerStatusError {
+		errMsg := ""
+		if trigger.ErrorMessage != nil {
+			errMsg = *trigger.ErrorMessage
+		}
+		diags = append(diags, diag.Diagnostic{
+			Severity: diag.Warning,
+			Summary:  "Trigger in error state",
+			Detail:   errMsg,
+		})
+	}
+
+	return diags
+}
+
+func resourceScalewayContainerTriggerUpdate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	api, region, id, err := containerAPIWithRegionAndID(meta, d.Id())
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	trigger, err := waitForContainerTrigger(ctx, api, region, id, d.Timeout(schema.TimeoutUpdate))
+	if err != nil {
+		if is404Error(err) {
+			d.SetId("")
+			return nil
+		}
+		return diag.FromErr(err)
+	}
+
+	req := &container.UpdateTriggerRequest{
+		Region:    region,
+		TriggerID: trigger.ID,
+	}
+
+	if d.HasChange("name") {
+		req.Name = expandUpdatedStringPtr(d.Get("name"))
+	}
+
+	if d.HasChange("description") {
+		req.Description = expandUpdatedStringPtr(d.Get("description"))
+	}
+
+	if _, err := api.UpdateTrigger(req, scw.WithContext(ctx)); err != nil {
+		return diag.FromErr(err)
+	}
+
+	return resourceScalewayContainerTriggerRead(ctx, d, meta)
+}
+
+func resourceScalewayContainerTriggerDelete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	api, region, id, err := containerAPIWithRegionAndID(meta, d.Id())
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	_, err = waitForContainerTrigger(ctx, api, region, id, d.Timeout(schema.TimeoutDelete))
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	_, err = api.DeleteTrigger(&container.DeleteTriggerRequest{
+		Region:    region,
+		TriggerID: id,
+	}, scw.WithContext(ctx))
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	_, err = waitForContainerTrigger(ctx, api, region, id, d.Timeout(schema.TimeoutDelete))
+	if err != nil && !is404Error(err) {
+		return diag.FromErr(err)
+	}
+
+	return nil
+}