feat(cockpit): add datasources (#2543)

* feat(cockpit): add datasources

* add type possible values

* rename to source

---------

Co-authored-by: Rémy Léone <[email protected]>

Author: yfodil

docs/resources/cockpit_source.md

@@ -0,0 +1,53 @@
+---
+subcategory: "Cockpit"
+page_title: "Scaleway: scaleway_cockpit_source"
+---
+
+# Resource: scaleway_cockpit_source
+
+Creates and manages Scaleway Cockpit Data Sources.
+
+For more information consult the [documentation](https://www.scaleway.com/en/docs/observability/cockpit/concepts/#data-sources).
+
+## Example Usage
+
+```terraform
+resource "scaleway_account_project" "project" {
+    name = "test project data source"
+}
+
+resource "scaleway_cockpit_source" "main" {
+    project_id = scaleway_account_project.project.id
+    name       = "my-data-source"
+    type       = "metrics"
+}
+```
+
+## Argument Reference
+
+- `name` - (Required) The name of the cockpit data source.
+- `type` - (Required) The type of the cockpit data source. Possible values are: `metrics`, `logs` or `traces`.
+- `region` - (Defaults to [provider](../index.md#region) `region`) The [region](../guides/regions_and_zones.md#regions) of the cockpit datasource.
+- `project_id` - (Defaults to [provider](../index.md#project_id) `project_id`) The ID of the project the cockpit data source is associated with.
+
+## Attributes Reference
+
+In addition to all arguments above, the following attributes are exported:
+
+- `id` - The ID of the cockpit data source.
+
+~> **Important:** cockpit data sources' 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
+
+- `url` - The URL of the cockpit data source.
+- `origin` - The origin of the cockpit data source.
+- `synchronized_with_grafana` - Indicates whether the data source is synchronized with Grafana.
+- `created_at` - Date and time of the cockpit data source's creation (RFC 3339 format).
+- `updated_at` - Date and time of the cockpit datas ource's last update (RFC 3339 format).
+
+## Import
+
+Cockpits Data Sources can be imported using the `{region}/{id}`, e.g.
+
+```bash
+$ terraform import scaleway_cockpit_source.main fr-par/11111111-1111-1111-1111-111111111111
+```

internal/provider/provider.go

@@ -123,6 +123,7 @@ func Provider(config *Config) plugin.ProviderFunc {
 				"scaleway_block_snapshot":                      block.ResourceSnapshot(),
 				"scaleway_block_volume":                        block.ResourceVolume(),
 				"scaleway_cockpit":                             cockpit.ResourceCockpit(),
+				"scaleway_cockpit_source":                      cockpit.ResourceCockpitSource(),
 				"scaleway_cockpit_grafana_user":                cockpit.ResourceCockpitGrafanaUser(),
 				"scaleway_cockpit_token":                       cockpit.ResourceToken(),
 				"scaleway_container":                           container.ResourceContainer(),

internal/services/cockpit/helpers_cockpit.go

@@ -7,8 +7,11 @@ import (
 	"strings"
 	"time"
 
-	cockpit "github.com/scaleway/scaleway-sdk-go/api/cockpit/v1beta1"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/scaleway/scaleway-sdk-go/api/cockpit/v1"
+	cockpitv1beta1 "github.com/scaleway/scaleway-sdk-go/api/cockpit/v1beta1"
 	"github.com/scaleway/scaleway-sdk-go/scw"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/locality/regional"
 	"github.com/scaleway/terraform-provider-scaleway/v2/internal/meta"
 	"github.com/scaleway/terraform-provider-scaleway/v2/internal/transport"
 )
@@ -21,14 +24,34 @@ const (
 )
 
 // NewAPI returns a new cockpit API.
-func NewAPI(m interface{}) (*cockpit.API, error) {
-	api := cockpit.NewAPI(meta.ExtractScwClient(m))
+func NewAPI(m interface{}) (*cockpitv1beta1.API, error) {
+	api := cockpitv1beta1.NewAPI(meta.ExtractScwClient(m))
 
 	return api, nil
 }
 
+func cockpitAPIWithRegion(d *schema.ResourceData, m interface{}) (*cockpit.RegionalAPI, scw.Region, error) {
+	api := cockpit.NewRegionalAPI(meta.ExtractScwClient(m))
+
+	region, err := meta.ExtractRegion(d, m)
+	if err != nil {
+		return nil, "", err
+	}
+	return api, region, err
+}
+
+func NewAPIWithRegionAndID(m interface{}, id string) (*cockpit.RegionalAPI, scw.Region, string, error) {
+	api := cockpit.NewRegionalAPI(meta.ExtractScwClient(m))
+
+	region, id, err := regional.ParseID(id)
+	if err != nil {
+		return nil, "", "", err
+	}
+	return api, region, id, nil
+}
+
 // NewAPIGrafanaUserID returns a new cockpit API with the Grafana user ID and the project ID.
-func NewAPIGrafanaUserID(m interface{}, id string) (*cockpit.API, string, uint32, error) {
+func NewAPIGrafanaUserID(m interface{}, id string) (*cockpitv1beta1.API, string, uint32, error) {
 	projectID, resourceIDString, err := parseCockpitID(id)
 	if err != nil {
 		return nil, "", 0, err
@@ -61,13 +84,13 @@ func parseCockpitID(id string) (projectID string, cockpitID string, err error) {
 	return parts[0], parts[1], nil
 }
 
-func waitForCockpit(ctx context.Context, api *cockpit.API, projectID string, timeout time.Duration) (*cockpit.Cockpit, error) {
+func waitForCockpit(ctx context.Context, api *cockpitv1beta1.API, projectID string, timeout time.Duration) (*cockpitv1beta1.Cockpit, error) {
 	retryInterval := defaultCockpitRetryInterval
 	if transport.DefaultWaitRetryInterval != nil {
 		retryInterval = *transport.DefaultWaitRetryInterval
 	}
 
-	return api.WaitForCockpit(&cockpit.WaitForCockpitRequest{
+	return api.WaitForCockpit(&cockpitv1beta1.WaitForCockpitRequest{
 		ProjectID:     projectID,
 		Timeout:       scw.TimeDurationPtr(timeout),
 		RetryInterval: &retryInterval,

internal/services/cockpit/source.go

@@ -0,0 +1,147 @@
+package cockpit
+
+import (
+	"context"
+
+	"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/scaleway/scaleway-sdk-go/api/cockpit/v1"
+	"github.com/scaleway/scaleway-sdk-go/scw"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/httperrors"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/locality/regional"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/services/account"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/types"
+)
+
+func ResourceCockpitSource() *schema.Resource {
+	return &schema.Resource{
+		CreateContext: ResourceCockpitSourceCreate,
+		ReadContext:   ResourceCockpitSourceRead,
+		DeleteContext: ResourceCockpitSourceDelete,
+		Timeouts: &schema.ResourceTimeout{
+			Create:  schema.DefaultTimeout(DefaultCockpitTimeout),
+			Read:    schema.DefaultTimeout(DefaultCockpitTimeout),
+			Delete:  schema.DefaultTimeout(DefaultCockpitTimeout),
+			Default: schema.DefaultTimeout(DefaultCockpitTimeout),
+		},
+		Importer: &schema.ResourceImporter{
+			StateContext: schema.ImportStatePassthroughContext,
+		},
+		Schema: map[string]*schema.Schema{
+			"name": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				ForceNew:    true,
+				Description: "Name of the datasource",
+			},
+			"type": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				ForceNew:    true,
+				Description: "The type of the datasource",
+				ValidateFunc: validation.StringInSlice([]string{
+					cockpit.DataSourceTypeMetrics.String(),
+					cockpit.DataSourceTypeLogs.String(),
+					cockpit.DataSourceTypeTraces.String(),
+				}, false),
+			},
+			// computed
+			"url": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "The URL of the datasource",
+			},
+			"origin": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "The origin of the datasource",
+			},
+			"synchronized_with_grafana": {
+				Type:        schema.TypeBool,
+				Computed:    true,
+				Description: "Indicates whether the data source is synchronized with Grafana",
+			},
+			"created_at": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "The date and time of the creation of the cockpit datasource",
+			},
+			"updated_at": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "The date and time of the last update of the cockpit datasource",
+			},
+			"project_id": account.ProjectIDSchema(),
+			"region":     regional.Schema(),
+		},
+	}
+}
+
+func ResourceCockpitSourceCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	api, region, err := cockpitAPIWithRegion(d, meta)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	res, err := api.CreateDataSource(&cockpit.RegionalAPICreateDataSourceRequest{
+		Region:    region,
+		ProjectID: d.Get("project_id").(string),
+		Name:      d.Get("name").(string),
+		Type:      cockpit.DataSourceType(d.Get("type").(string)),
+	}, scw.WithContext(ctx))
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	d.SetId(regional.NewIDString(region, res.ID))
+	return ResourceCockpitSourceRead(ctx, d, meta)
+}
+
+func ResourceCockpitSourceRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	api, region, id, err := NewAPIWithRegionAndID(meta, d.Id())
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	res, err := api.GetDataSource(&cockpit.RegionalAPIGetDataSourceRequest{
+		Region:       region,
+		DataSourceID: id,
+	}, scw.WithContext(ctx))
+	if err != nil {
+		if httperrors.Is404(err) {
+			d.SetId("")
+			return nil
+		}
+		return diag.FromErr(err)
+	}
+
+	_ = d.Set("name", res.Name)
+	_ = d.Set("type", res.Type.String())
+	_ = d.Set("url", res.URL)
+	_ = d.Set("origin", res.Origin)
+	_ = d.Set("synchronized_with_grafana", res.SynchronizedWithGrafana)
+	_ = d.Set("region", res.Region)
+	_ = d.Set("created_at", types.FlattenTime(res.CreatedAt))
+	_ = d.Set("updated_at", types.FlattenTime(res.UpdatedAt))
+	_ = d.Set("project_id", res.ProjectID)
+
+	return nil
+}
+
+func ResourceCockpitSourceDelete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	api, region, id, err := NewAPIWithRegionAndID(meta, d.Id())
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	err = api.DeleteDataSource(&cockpit.RegionalAPIDeleteDataSourceRequest{
+		DataSourceID: id,
+		Region:       region,
+	}, scw.WithContext(ctx))
+	if err != nil && !httperrors.Is404(err) {
+		return diag.FromErr(err)
+	}
+
+	return nil
+}

internal/services/cockpit/source_test.go

@@ -0,0 +1,105 @@
+package cockpit_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/terraform"
+	cockpitSDK "github.com/scaleway/scaleway-sdk-go/api/cockpit/v1"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/acctest"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/httperrors"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/services/cockpit"
+)
+
+func TestAccCockpitSource_Basic(t *testing.T) {
+	tt := acctest.NewTestTools(t)
+	defer tt.Cleanup()
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:          func() { acctest.PreCheck(t) },
+		ProviderFactories: tt.ProviderFactories,
+		CheckDestroy:      isSourceDestroyed(tt),
+		Steps: []resource.TestStep{
+			{
+				Config: `
+					resource "scaleway_account_project" "project" {
+						name = "tf_tests_cockpit_datasource_basic"
+				  	}
+
+					resource "scaleway_cockpit_source" "main" {
+					  project_id = scaleway_account_project.project.id
+					  name       = "my-source"
+					  type       = "metrics"
+					}
+				`,
+				Check: resource.ComposeTestCheckFunc(
+					isSourcePresent(tt, "scaleway_cockpit_source.main"),
+					resource.TestCheckResourceAttr("scaleway_cockpit_source.main", "name", "my-source"),
+					resource.TestCheckResourceAttr("scaleway_cockpit_source.main", "type", "metrics"),
+					resource.TestCheckResourceAttr("scaleway_cockpit_source.main", "region", "fr-par"),
+					resource.TestCheckResourceAttrSet("scaleway_cockpit_source.main", "url"),
+					resource.TestCheckResourceAttrSet("scaleway_cockpit_source.main", "origin"),
+					resource.TestCheckResourceAttrSet("scaleway_cockpit_source.main", "created_at"),
+					resource.TestCheckResourceAttrSet("scaleway_cockpit_source.main", "updated_at"),
+					resource.TestCheckResourceAttrSet("scaleway_cockpit_source.main", "synchronized_with_grafana"),
+					resource.TestCheckResourceAttrPair("scaleway_cockpit_source.main", "project_id", "scaleway_account_project.project", "id"),
+				),
+			},
+		},
+	})
+}
+
+func isSourcePresent(tt *acctest.TestTools, n string) resource.TestCheckFunc {
+	return func(state *terraform.State) error {
+		rs, ok := state.RootModule().Resources[n]
+		if !ok {
+			return fmt.Errorf("resource cockpit source not found: %s", n)
+		}
+
+		api, region, ID, err := cockpit.NewAPIWithRegionAndID(tt.Meta, rs.Primary.ID)
+		if err != nil {
+			return err
+		}
+
+		_, err = api.GetDataSource(&cockpitSDK.RegionalAPIGetDataSourceRequest{
+			Region:       region,
+			DataSourceID: ID,
+		})
+		if err != nil {
+			return err
+		}
+
+		return nil
+	}
+}
+
+func isSourceDestroyed(tt *acctest.TestTools) resource.TestCheckFunc {
+	return func(state *terraform.State) error {
+		for _, rs := range state.RootModule().Resources {
+			if rs.Type != "scaleway_cockpit_source" {
+				continue
+			}
+
+			api, region, ID, err := cockpit.NewAPIWithRegionAndID(tt.Meta, rs.Primary.ID)
+			if err != nil {
+				return err
+			}
+
+			_, err = api.GetDataSource(&cockpitSDK.RegionalAPIGetDataSourceRequest{
+				Region:       region,
+				DataSourceID: ID,
+			})
+
+			if err == nil {
+				return fmt.Errorf("cockpit source (%s) still exists", rs.Primary.ID)
+			}
+
+			if !httperrors.Is404(err) {
+				return err
+			}
+		}
+
+		return nil
+	}
+}