feat(vpcgw): add support for vpc public gateway ip (scaleway#863)

Author: remyleone

docs/data-sources/vpc_public_gateway_ip.md

@@ -0,0 +1,27 @@
+---
+page_title: "Scaleway: scaleway_vpc_public_gateway_ip"
+description: |-
+  Get information about Scaleway VPC Public Gateway IPs.
+---
+
+# scaleway_vpc_public_gateway_ip
+
+Gets information about a public gateway IP.
+
+## Example Usage
+
+```hcl
+resource "scaleway_vpc_public_gateway_ip" "main" {
+}
+
+data "scaleway_vpc_public_gateway_ip" "ip_by_id" {
+    ip_id = "${scaleway_vpc_public_gateway_ip.main.id}"
+}
+```
+
+## Argument Reference
+
+## Attributes Reference
+
+`id` is set to the ID of the found public gateway ip. Addition attributes are
+exported.

docs/resources/vpc_public_gateway_ip.md

@@ -0,0 +1,46 @@
+---
+page_title: "Scaleway: scaleway_vpc_public_gateway_ip"
+description: |-
+  Manages Scaleway VPC Public Gateways IP.
+---
+
+# scaleway_vpc_public_gateway_ip
+
+Creates and manages Scaleway VPC Public Gateway IP.
+For more information, see [the documentation](https://developers.scaleway.com/en/products/vpc-gw/api/).
+
+## Example
+
+```hcl
+resource "scaleway_vpc_public_gateway_ip" "main" {
+    reverse = "example.com"
+    tags = ["demo", "terraform"]
+}
+```
+
+## Arguments Reference
+
+The following arguments are supported:
+
+- `reverse` - (Optional) The reverse domain name for the IP address
+- `tags` - (Optional) The tags associated with the public gateway IP.
+- `zone` - (Defaults to [provider](../index.md#zone) `zone`) The [zone](../guides/regions_and_zones.md#zones) in which the public gateway ip should be created.
+- `project_id` - (Defaults to [provider](../index.md#project_id) `project_id`) The ID of the project the public gateway ip is associated with.
+
+## Attributes Reference
+
+In addition to all above arguments, the following attributes are exported:
+
+- `id` - The ID of the public gateway ip.
+- `address` - The IP address itself.
+- `organization_id` - The organization ID the public gateway ip is associated with.
+- `created_at` - The date and time of the creation of the public gateway ip.
+- `updated_at` - The date and time of the last update of the public gateway ip.
+
+## Import
+
+Public gateway can be imported using the `{zone}/{id}`, e.g.
+
+```bash
+$ terraform import scaleway_vpc_public_gateway_ip.main fr-par-1/11111111-1111-1111-1111-111111111111
+```

scaleway/data_source_vpc_public_gateway_ip.go

@@ -0,0 +1,39 @@
+package scaleway
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func dataSourceScalewayVPCPublicGatewayIP() *schema.Resource {
+	// Generate datasource schema from resource
+	dsSchema := datasourceSchemaFromResourceSchema(resourceScalewayVPCPublicGatewayIP().Schema)
+
+	dsSchema["ip_id"] = &schema.Schema{
+		Type:         schema.TypeString,
+		Optional:     true,
+		Description:  "The ID of the IP",
+		ValidateFunc: validationUUIDorUUIDWithLocality(),
+	}
+
+	return &schema.Resource{
+		Schema:      dsSchema,
+		ReadContext: dataSourceScalewayVPCPublicGatewayIPRead,
+	}
+}
+
+func dataSourceScalewayVPCPublicGatewayIPRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	_, zone, err := vpcgwAPIWithZone(d, meta)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	ipID, _ := d.GetOk("ip_id")
+
+	zonedID := datasourceNewZonedID(ipID, zone)
+	d.SetId(zonedID)
+	_ = d.Set("ip_id", zonedID)
+	return resourceScalewayVPCPublicGatewayIPRead(ctx, d, meta)
+}

scaleway/data_source_vpc_public_gateway_ip_test.go

@@ -0,0 +1,41 @@
+package scaleway
+
+import (
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+)
+
+func TestAccScalewayDataSourceVPCPublicGatewayIP_Basic(t *testing.T) {
+	tt := NewTestTools(t)
+	defer tt.Cleanup()
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:          func() { testAccPreCheck(t) },
+		ProviderFactories: tt.ProviderFactories,
+		CheckDestroy:      testAccCheckScalewayVPCPublicGatewayIPDestroy(tt),
+		Steps: []resource.TestStep{
+			{
+				Config: `
+					resource "scaleway_vpc_public_gateway_ip" "main" {
+					}`,
+			},
+			{
+				Config: `
+					resource "scaleway_vpc_public_gateway_ip" "main" {
+					}
+
+					data "scaleway_vpc_public_gateway_ip" "ip_by_id" {
+						ip_id = "${scaleway_vpc_public_gateway_ip.main.id}"
+					}
+				`,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckScalewayVPCPublicGatewayIPExists(tt, "scaleway_vpc_public_gateway_ip.main"),
+					resource.TestCheckResourceAttrPair(
+						"data.scaleway_vpc_public_gateway_ip.ip_by_id", "ip_id",
+						"scaleway_vpc_public_gateway_ip.main", "id"),
+				),
+			},
+		},
+	})
+}

scaleway/provider.go

@@ -87,6 +87,7 @@ func Provider(config *ProviderConfig) plugin.ProviderFunc {
 				"scaleway_object_bucket":                 resourceScalewayObjectBucket(),
 				"scaleway_vpc_public_gateway":            resourceScalewayVPCPublicGateway(),
 				"scaleway_vpc_public_gateway_pat_rule":   resourceScalewayVPCPublicGatewayPATRule(),
+				"scaleway_vpc_public_gateway_ip":         resourceScalewayVPCPublicGatewayIP(),
 				"scaleway_vpc_private_network":           resourceScalewayVPCPrivateNetwork(),
 			},
 
@@ -108,6 +109,7 @@ func Provider(config *ProviderConfig) plugin.ProviderFunc {
 				"scaleway_registry_namespace":      dataSourceScalewayRegistryNamespace(),
 				"scaleway_registry_image":          dataSourceScalewayRegistryImage(),
 				"scaleway_vpc_public_gateway":      dataSourceScalewayVPCPublicGateway(),
+				"scaleway_vpc_public_gateway_ip":   dataSourceScalewayVPCPublicGatewayIP(),
 				"scaleway_vpc_private_network":     dataSourceScalewayVPCPrivateNetwork(),
 			},
 		}

scaleway/resource_vpc_public_gateway.go

@@ -42,10 +42,11 @@ func resourceScalewayVPCPublicGateway() *schema.Resource {
 				},
 			},
 			"ip_id": {
-				Type:        schema.TypeString,
-				Optional:    true,
-				Computed:    true,
-				Description: "attach an existing IP to the gateway",
+				Type:             schema.TypeString,
+				Computed:         true,
+				Optional:         true,
+				Description:      "attach an existing IP to the gateway",
+				DiffSuppressFunc: diffSuppressFuncLocality,
 			},
 			"tags": {
 				Type:        schema.TypeList,
@@ -84,11 +85,14 @@ func resourceScalewayVPCPublicGatewayCreate(ctx context.Context, d *schema.Resou
 		Type:               d.Get("type").(string),
 		Tags:               expandStrings(d.Get("tags")),
 		UpstreamDNSServers: expandStrings(d.Get("upstream_dns_servers")),
-		IPID:               expandStringPtr(d.Get("ip_id").(string)),
 		ProjectID:          d.Get("project_id").(string),
 		Zone:               zone,
 	}
 
+	if ipID, ok := d.GetOk("ip_id"); ok {
+		req.IPID = expandStringPtr(expandZonedID(ipID).ID)
+	}
+
 	res, err := vpcgwAPI.CreateGateway(req, scw.WithContext(ctx))
 	if err != nil {
 		return diag.FromErr(err)
@@ -136,7 +140,7 @@ func resourceScalewayVPCPublicGatewayRead(ctx context.Context, d *schema.Resourc
 	_ = d.Set("zone", zone)
 	_ = d.Set("tags", gateway.Tags)
 	_ = d.Set("upstream_dns_servers", gateway.UpstreamDNSServers)
-	_ = d.Set("ip_id", gateway.IP.ID)
+	_ = d.Set("ip_id", newZonedID(zone, gateway.IP.ID).String())
 
 	return nil
 }

scaleway/resource_vpc_public_gateway_ip.go

@@ -0,0 +1,150 @@
+package scaleway
+
+import (
+	"context"
+	"time"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	vpcgw "github.com/scaleway/scaleway-sdk-go/api/vpcgw/v1beta1"
+	"github.com/scaleway/scaleway-sdk-go/scw"
+)
+
+func resourceScalewayVPCPublicGatewayIP() *schema.Resource {
+	return &schema.Resource{
+		CreateContext: resourceScalewayVPCPublicGatewayIPCreate,
+		ReadContext:   resourceScalewayVPCPublicGatewayIPRead,
+		UpdateContext: resourceScalewayVPCPublicGatewayIPUpdate,
+		DeleteContext: resourceScalewayVPCPublicGatewayIPDelete,
+		Importer: &schema.ResourceImporter{
+			StateContext: schema.ImportStatePassthroughContext,
+		},
+		SchemaVersion: 0,
+		Schema: map[string]*schema.Schema{
+			"address": {
+				Type:        schema.TypeString,
+				Description: "the IP itself",
+				Computed:    true,
+			},
+			"tags": {
+				Type:        schema.TypeList,
+				Optional:    true,
+				Description: "The tags associated with public gateway IP",
+				Elem: &schema.Schema{
+					Type: schema.TypeString,
+				},
+			},
+			"reverse": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				Description: "reverse domain name for the IP address",
+			},
+			"project_id": projectIDSchema(),
+			"zone":       zoneSchema(),
+			// Computed elements
+			"organization_id": organizationIDSchema(),
+			"created_at": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "The date and time of the creation of the public gateway IP",
+			},
+			"updated_at": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "The date and time of the last update of the public gateway IP",
+			},
+		},
+	}
+}
+
+func resourceScalewayVPCPublicGatewayIPCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	vpcgwAPI, zone, err := vpcgwAPIWithZone(d, meta)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	req := &vpcgw.CreateIPRequest{
+		Tags:      expandStrings(d.Get("tags")),
+		ProjectID: d.Get("project_id").(string),
+		Zone:      zone,
+	}
+
+	res, err := vpcgwAPI.CreateIP(req, scw.WithContext(ctx))
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	d.SetId(newZonedIDString(zone, res.ID))
+
+	return resourceScalewayVPCPublicGatewayIPRead(ctx, d, meta)
+}
+
+func resourceScalewayVPCPublicGatewayIPRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	vpcgwAPI, zone, ID, err := vpcgwAPIWithZoneAndID(meta, d.Id())
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	ip, err := vpcgwAPI.GetIP(&vpcgw.GetIPRequest{
+		IPID: ID,
+		Zone: zone,
+	}, scw.WithContext(ctx))
+	if err != nil {
+		if is404Error(err) {
+			d.SetId("")
+			return nil
+		}
+		return diag.FromErr(err)
+	}
+
+	_ = d.Set("organization_id", ip.OrganizationID)
+	_ = d.Set("project_id", ip.ProjectID)
+	_ = d.Set("created_at", ip.CreatedAt.Format(time.RFC3339))
+	_ = d.Set("updated_at", ip.UpdatedAt.Format(time.RFC3339))
+	_ = d.Set("zone", zone)
+	_ = d.Set("tags", ip.Tags)
+	_ = d.Set("reverse", ip.Reverse)
+
+	return nil
+}
+
+func resourceScalewayVPCPublicGatewayIPUpdate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	vpcgwAPI, zone, ID, err := vpcgwAPIWithZoneAndID(meta, d.Id())
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	if d.HasChanges("tags", "reverse") {
+		updateRequest := &vpcgw.UpdateIPRequest{
+			IPID:    ID,
+			Zone:    zone,
+			Tags:    scw.StringsPtr(expandStrings(d.Get("tags"))),
+			Reverse: expandStringPtr(d.Get("reverse").(string)),
+		}
+
+		_, err = vpcgwAPI.UpdateIP(updateRequest, scw.WithContext(ctx))
+		if err != nil {
+			return diag.FromErr(err)
+		}
+	}
+
+	return resourceScalewayVPCPublicGatewayIPRead(ctx, d, meta)
+}
+
+func resourceScalewayVPCPublicGatewayIPDelete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	vpcgwAPI, zone, ID, err := vpcgwAPIWithZoneAndID(meta, d.Id())
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	err = vpcgwAPI.DeleteIP(&vpcgw.DeleteIPRequest{
+		IPID: ID,
+		Zone: zone,
+	}, scw.WithContext(ctx))
+
+	if err != nil && !is404Error(err) {
+		return diag.FromErr(err)
+	}
+
+	return nil
+}