feat(dhcp-reservation): add resource dhcp reservation

docs/resources/vpc_public_gateway_dhcp_reservation.md

@@ -0,0 +1,90 @@
+---
+page_title: "Scaleway: scaleway_vpc_public_gateway_dhcp_reservation"
+description: |-
+Manages Scaleway VPC Public Gateways DHCP Reservations.
+---
+
+# scaleway_vpc_public_gateway_dhcp_reservation
+
+Creates and manages the [Scaleway DHCP Reservations](https://www.scaleway.com/en/docs/network/vpc/concepts/#dhcp).
+
+The static associations are used to assign IP addresses based on the MAC addresses of the Instance.
+
+Statically assigned IP addresses should fall within the configured subnet, but be outside of the dynamic range.
+
+For more information, see [the documentation](https://developers.scaleway.com/en/products/vpc-gw/api/v1/#dhcp-c05544) and [configuration guide](https://www.scaleway.com/en/docs/network/vpc/how-to/configure-a-public-gateway/#how-to-review-and-configure-dhcp).
+
+[DHCP reservations](https://developers.scaleway.com/en/products/vpc-gw/api/v1/#dhcp-entries-e40fb6) hold both dynamic DHCP leases (IP addresses dynamically assigned by the gateway to instances) and static user-created DHCP reservations.
+
+## Example Usage
+
+```hcl
+resource scaleway_vpc_private_network main {
+    name = "your_private_network"
+}
+
+resource "scaleway_instance_server" "main" {
+    image = "ubuntu_focal"
+    type  = "DEV1-S"
+    zone = "fr-par-1"
+
+    private_network {
+        pn_id = scaleway_vpc_private_network.main.id
+    }
+}
+
+resource scaleway_vpc_public_gateway_ip main {
+}
+
+resource scaleway_vpc_public_gateway_dhcp main {
+    subnet = "192.168.1.0/24"
+}
+
+resource scaleway_vpc_public_gateway main {
+    name = "foobar"
+    type = "VPC-GW-S"
+    ip_id = scaleway_vpc_public_gateway_ip.main.id
+}
+
+resource scaleway_vpc_gateway_network main {
+    gateway_id = scaleway_vpc_public_gateway.main.id
+    private_network_id = scaleway_vpc_private_network.main.id
+    dhcp_id = scaleway_vpc_public_gateway_dhcp.main.id
+    cleanup_dhcp = true
+    enable_masquerade = true
+    depends_on = [scaleway_vpc_public_gateway_ip.main, scaleway_vpc_private_network.main]
+}
+
+resource scaleway_vpc_public_gateway_dhcp_reservation main {
+    gateway_network_id = scaleway_vpc_gateway_network.main.id
+    mac_address = scaleway_instance_server.main.private_network.0.mac_address
+    ip_address = "192.168.1.1"
+}
+```
+
+## Arguments Reference
+
+The following arguments are supported:
+
+- `gateway_network_id` - (Required) The ID of the owning GatewayNetwork.
+- `ip_address` - (Required) The IP address to give to the machine (IP address).
+- `mac_address` - (Required) The MAC address to give a static entry to.
+- `zone` - (Defaults to [provider](../index.md#zone) `zone`) The [zone](../guides/regions_and_zones.md#zones) in which the public gateway DHCP config should be created.
+
+## Attributes Reference
+
+In addition to all above arguments, the following attributes are exported:
+
+- `id` - The ID of the public gateway DHCP Reservation config.
+- `hostname` - The Hostname of the client machine.
+- `type` - The reservation type, either static (DHCP reservation) or dynamic (DHCP lease). Possible values are reservation and lease.
+- `created_at` - The date and time of the creation of the public gateway DHCP config.
+- `updated_at` - The date and time of the last update of the public gateway DHCP config.
+
+## Import
+
+Public gateway DHCP Reservation config can be imported using the `{zone}/{id}`, e.g.
+
+```bash
+$ terraform import scaleway_vpc_public_gateway_dhcp_reservation.main fr-par-1/11111111-1111-1111-1111-111111111111
+```

scaleway/provider.go

@@ -60,48 +60,49 @@ func Provider(config *ProviderConfig) plugin.ProviderFunc {
 			},
 
 			ResourcesMap: map[string]*schema.Resource{
-				"scaleway_account_ssh_key":               resourceScalewayAccountSSKKey(),
-				"scaleway_apple_silicon_server":          resourceScalewayAppleSiliconServer(),
-				"scaleway_baremetal_server":              resourceScalewayBaremetalServer(),
-				"scaleway_container_namespace":           resourceScalewayContainerNamespace(),
-				"scaleway_domain_record":                 resourceScalewayDomainRecord(),
-				"scaleway_domain_zone":                   resourceScalewayDomainZone(),
-				"scaleway_function_namespace":            resourceScalewayFunctionNamespace(),
-				"scaleway_instance_ip":                   resourceScalewayInstanceIP(),
-				"scaleway_instance_ip_reverse_dns":       resourceScalewayInstanceIPReverseDNS(),
-				"scaleway_instance_volume":               resourceScalewayInstanceVolume(),
-				"scaleway_instance_security_group":       resourceScalewayInstanceSecurityGroup(),
-				"scaleway_instance_security_group_rules": resourceScalewayInstanceSecurityGroupRules(),
-				"scaleway_instance_server":               resourceScalewayInstanceServer(),
-				"scaleway_instance_snapshot":             resourceScalewayInstanceSnapshot(),
-				"scaleway_instance_placement_group":      resourceScalewayInstancePlacementGroup(),
-				"scaleway_instance_private_nic":          resourceScalewayInstancePrivateNIC(),
-				"scaleway_iot_hub":                       resourceScalewayIotHub(),
-				"scaleway_iot_device":                    resourceScalewayIotDevice(),
-				"scaleway_iot_route":                     resourceScalewayIotRoute(),
-				"scaleway_iot_network":                   resourceScalewayIotNetwork(),
-				"scaleway_k8s_cluster":                   resourceScalewayK8SCluster(),
-				"scaleway_k8s_pool":                      resourceScalewayK8SPool(),
-				"scaleway_lb":                            resourceScalewayLb(),
-				"scaleway_lb_ip":                         resourceScalewayLbIP(),
-				"scaleway_lb_backend":                    resourceScalewayLbBackend(),
-				"scaleway_lb_certificate":                resourceScalewayLbCertificate(),
-				"scaleway_lb_frontend":                   resourceScalewayLbFrontend(),
-				"scaleway_lb_route":                      resourceScalewayLbRoute(),
-				"scaleway_registry_namespace":            resourceScalewayRegistryNamespace(),
-				"scaleway_container":                     resourceScalewayContainer(),
-				"scaleway_rdb_acl":                       resourceScalewayRdbACL(),
-				"scaleway_rdb_database":                  resourceScalewayRdbDatabase(),
-				"scaleway_rdb_instance":                  resourceScalewayRdbInstance(),
-				"scaleway_rdb_privilege":                 resourceScalewayRdbPrivilege(),
-				"scaleway_rdb_user":                      resourceScalewayRdbUser(),
-				"scaleway_object_bucket":                 resourceScalewayObjectBucket(),
-				"scaleway_vpc_public_gateway":            resourceScalewayVPCPublicGateway(),
-				"scaleway_vpc_gateway_network":           resourceScalewayVPCGatewayNetwork(),
-				"scaleway_vpc_public_gateway_dhcp":       resourceScalewayVPCPublicGatewayDHCP(),
-				"scaleway_vpc_public_gateway_ip":         resourceScalewayVPCPublicGatewayIP(),
-				"scaleway_vpc_public_gateway_pat_rule":   resourceScalewayVPCPublicGatewayPATRule(),
-				"scaleway_vpc_private_network":           resourceScalewayVPCPrivateNetwork(),
+				"scaleway_account_ssh_key":                     resourceScalewayAccountSSKKey(),
+				"scaleway_apple_silicon_server":                resourceScalewayAppleSiliconServer(),
+				"scaleway_baremetal_server":                    resourceScalewayBaremetalServer(),
+				"scaleway_container_namespace":                 resourceScalewayContainerNamespace(),
+				"scaleway_domain_record":                       resourceScalewayDomainRecord(),
+				"scaleway_domain_zone":                         resourceScalewayDomainZone(),
+				"scaleway_function_namespace":                  resourceScalewayFunctionNamespace(),
+				"scaleway_instance_ip":                         resourceScalewayInstanceIP(),
+				"scaleway_instance_ip_reverse_dns":             resourceScalewayInstanceIPReverseDNS(),
+				"scaleway_instance_volume":                     resourceScalewayInstanceVolume(),
+				"scaleway_instance_security_group":             resourceScalewayInstanceSecurityGroup(),
+				"scaleway_instance_security_group_rules":       resourceScalewayInstanceSecurityGroupRules(),
+				"scaleway_instance_server":                     resourceScalewayInstanceServer(),
+				"scaleway_instance_snapshot":                   resourceScalewayInstanceSnapshot(),
+				"scaleway_instance_placement_group":            resourceScalewayInstancePlacementGroup(),
+				"scaleway_instance_private_nic":                resourceScalewayInstancePrivateNIC(),
+				"scaleway_iot_hub":                             resourceScalewayIotHub(),
+				"scaleway_iot_device":                          resourceScalewayIotDevice(),
+				"scaleway_iot_route":                           resourceScalewayIotRoute(),
+				"scaleway_iot_network":                         resourceScalewayIotNetwork(),
+				"scaleway_k8s_cluster":                         resourceScalewayK8SCluster(),
+				"scaleway_k8s_pool":                            resourceScalewayK8SPool(),
+				"scaleway_lb":                                  resourceScalewayLb(),
+				"scaleway_lb_ip":                               resourceScalewayLbIP(),
+				"scaleway_lb_backend":                          resourceScalewayLbBackend(),
+				"scaleway_lb_certificate":                      resourceScalewayLbCertificate(),
+				"scaleway_lb_frontend":                         resourceScalewayLbFrontend(),
+				"scaleway_lb_route":                            resourceScalewayLbRoute(),
+				"scaleway_registry_namespace":                  resourceScalewayRegistryNamespace(),
+				"scaleway_container":                           resourceScalewayContainer(),
+				"scaleway_rdb_acl":                             resourceScalewayRdbACL(),
+				"scaleway_rdb_database":                        resourceScalewayRdbDatabase(),
+				"scaleway_rdb_instance":                        resourceScalewayRdbInstance(),
+				"scaleway_rdb_privilege":                       resourceScalewayRdbPrivilege(),
+				"scaleway_rdb_user":                            resourceScalewayRdbUser(),
+				"scaleway_object_bucket":                       resourceScalewayObjectBucket(),
+				"scaleway_vpc_public_gateway":                  resourceScalewayVPCPublicGateway(),
+				"scaleway_vpc_gateway_network":                 resourceScalewayVPCGatewayNetwork(),
+				"scaleway_vpc_public_gateway_dhcp":             resourceScalewayVPCPublicGatewayDHCP(),
+				"scaleway_vpc_public_gateway_dhcp_reservation": resourceScalewayVPCPublicGatewayDHCPReservation(),
+				"scaleway_vpc_public_gateway_ip":               resourceScalewayVPCPublicGatewayIP(),
+				"scaleway_vpc_public_gateway_pat_rule":         resourceScalewayVPCPublicGatewayPATRule(),
+				"scaleway_vpc_private_network":                 resourceScalewayVPCPrivateNetwork(),
 			},
 
 			DataSourcesMap: map[string]*schema.Resource{

scaleway/resource_vpc_public_gateway_dhcp_reservation.go

@@ -0,0 +1,206 @@
+package scaleway
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"time"
+
+	"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/vpcgw/v1"
+	"github.com/scaleway/scaleway-sdk-go/scw"
+)
+
+func resourceScalewayVPCPublicGatewayDHCPReservation() *schema.Resource {
+	return &schema.Resource{
+		CreateContext: resourceScalewayVPCPublicGatewayDHCPCReservationCreate,
+		ReadContext:   resourceScalewayVPCPublicGatewayDHCPReservationRead,
+		UpdateContext: resourceScalewayVPCPublicGatewayDHCPReservationUpdate,
+		DeleteContext: resourceScalewayVPCPublicGatewayDHCPReservationDelete,
+		Importer: &schema.ResourceImporter{
+			StateContext: schema.ImportStatePassthroughContext,
+		},
+		SchemaVersion: 0,
+		Schema: map[string]*schema.Schema{
+			"gateway_network_id": {
+				Type:        schema.TypeString,
+				Required:    true,
+				Description: "The ID of the owning GatewayNetwork (UUID format).",
+			},
+			"ip_address": {
+				Type:         schema.TypeString,
+				Required:     true,
+				Description:  "The IP address to give to the machine (IPv4 address).",
+				ValidateFunc: validation.IsIPAddress,
+			},
+			"mac_address": {
+				Type:         schema.TypeString,
+				Required:     true,
+				Description:  "The MAC address to give a static entry to.",
+				ValidateFunc: validation.IsMACAddress,
+			},
+			"hostname": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "The Hostname of the client machine.",
+			},
+			"type": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "The reservation type, either static (DHCP reservation) or dynamic (DHCP lease). Possible values are reservation and lease",
+			},
+			"created_at": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "The configuration creation date.",
+			},
+			"updated_at": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "The configuration last modification date.",
+			},
+			"zone": zoneSchema(),
+		},
+	}
+}
+
+func resourceScalewayVPCPublicGatewayDHCPCReservationCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	vpcgwAPI, zone, err := vpcgwAPIWithZone(d, meta)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	ip := net.ParseIP(d.Get("ip_address").(string))
+	if ip == nil {
+		return diag.FromErr(fmt.Errorf("could not parse ip_address"))
+	}
+
+	macAddress, err := net.ParseMAC(d.Get("mac_address").(string))
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	gatewayNetworkID := expandID(d.Get("gateway_network_id"))
+	_, err = vpcgwAPI.WaitForGatewayNetwork(&vpcgw.WaitForGatewayNetworkRequest{
+		GatewayNetworkID: gatewayNetworkID,
+		Zone:             zone,
+	}, scw.WithContext(ctx))
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	res, err := vpcgwAPI.CreateDHCPEntry(&vpcgw.CreateDHCPEntryRequest{
+		Zone:             zone,
+		MacAddress:       macAddress.String(),
+		IPAddress:        ip,
+		GatewayNetworkID: gatewayNetworkID,
+	}, scw.WithContext(ctx))
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	d.SetId(newZonedIDString(zone, res.ID))
+
+	_, err = vpcgwAPI.WaitForGatewayNetwork(&vpcgw.WaitForGatewayNetworkRequest{
+		Zone:             zone,
+		GatewayNetworkID: gatewayNetworkID,
+	}, scw.WithContext(ctx))
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	return resourceScalewayVPCPublicGatewayDHCPReservationRead(ctx, d, meta)
+}
+
+func resourceScalewayVPCPublicGatewayDHCPReservationRead(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)
+	}
+
+	entry, err := vpcgwAPI.GetDHCPEntry(&vpcgw.GetDHCPEntryRequest{
+		DHCPEntryID: ID,
+		Zone:        zone,
+	}, scw.WithContext(ctx))
+	if err != nil {
+		if is404Error(err) {
+			d.SetId("")
+			return nil
+		}
+		return diag.FromErr(err)
+	}
+
+	_ = d.Set("ip_address", entry.IPAddress.String())
+	_ = d.Set("mac_address", entry.MacAddress)
+	_ = d.Set("hostname", entry.Hostname)
+	_ = d.Set("type", entry.Type.String())
+	_ = d.Set("gateway_network_id", newZonedIDString(zone, entry.GatewayNetworkID))
+	_ = d.Set("created_at", entry.CreatedAt.Format(time.RFC3339))
+	_ = d.Set("updated_at", entry.UpdatedAt.Format(time.RFC3339))
+	_ = d.Set("zone", zone)
+
+	return nil
+}
+
+func resourceScalewayVPCPublicGatewayDHCPReservationUpdate(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.HasChangesExcept("ip_address") {
+		ip := net.ParseIP(d.Get("ip_address").(string))
+		if ip == nil {
+			return diag.FromErr(fmt.Errorf("could not parse ip_address"))
+		}
+		req := &vpcgw.UpdateDHCPEntryRequest{
+			DHCPEntryID: ID,
+			Zone:        zone,
+			IPAddress:   scw.IPPtr(ip),
+		}
+
+		_, err = vpcgwAPI.UpdateDHCPEntry(req, scw.WithContext(ctx))
+		if err != nil {
+			return diag.FromErr(err)
+		}
+	}
+
+	return resourceScalewayVPCPublicGatewayDHCPReservationRead(ctx, d, meta)
+}
+
+func resourceScalewayVPCPublicGatewayDHCPReservationDelete(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)
+	}
+
+	gatewayNetworkID := expandID(d.Get("gateway_network_id"))
+	_, err = vpcgwAPI.WaitForGatewayNetwork(&vpcgw.WaitForGatewayNetworkRequest{
+		GatewayNetworkID: gatewayNetworkID,
+		Zone:             zone,
+	}, scw.WithContext(ctx))
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	err = vpcgwAPI.DeleteDHCPEntry(&vpcgw.DeleteDHCPEntryRequest{
+		DHCPEntryID: ID,
+		Zone:        zone,
+	}, scw.WithContext(ctx))
+
+	if err != nil && !is404Error(err) {
+		return diag.FromErr(err)
+	}
+
+	_, err = vpcgwAPI.WaitForGatewayNetwork(&vpcgw.WaitForGatewayNetworkRequest{
+		GatewayNetworkID: gatewayNetworkID,
+		Zone:             zone,
+	}, scw.WithContext(ctx))
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	return nil
+}