Merge branch 'master' into timeout

Author: remyleone

.github/workflows/golangci-lint.yml

@@ -8,8 +8,8 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v1
+        uses: golangci/golangci-lint-action@v2
         with:
           # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
-          version: v1.27
-          args: "--timeout=1m"
+          version: v1.32.2
+          args: --timeout 5m

docs/data-sources/vpc_private_network.md

@@ -0,0 +1,22 @@
+---
+page_title: "Scaleway: scaleway_vpc_private_network"
+description: |-
+  Get information about Scaleway VPC Private Networks.
+---
+
+# scaleway_vpc_private_network
+
+Gets information about a private network.
+
+## Example Usage
+
+N/A, the usage will be meaningful in the next releases of VPC.
+
+## Argument Reference
+
+* `name` - (Required) Exact name of the private network.
+
+## Attributes Reference
+
+`id` is set to the ID of the found private network. Addition attributes are
+exported.

docs/resources/instance_private_nic.md

@@ -0,0 +1,40 @@
+---
+page_title: "Scaleway: scaleway_instance_private_nic"
+description: |-
+  Manages Scaleway Compute Instance Private NICs.
+---
+
+# scaleway_instance_private_nic
+
+Creates and manages Scaleway Instance Private NICs. For more information, see
+[the documentation](https://developers.scaleway.com/en/products/instance/api/#private-nics-a42eea).
+
+## Example
+
+```hcl
+resource "scaleway_instance_private_nic" "pnic01" {
+    server_id          = "fr-par-1/11111111-1111-1111-1111-111111111111"
+    private_network_id = "fr-par-1/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+}
+```
+
+## Arguments Reference
+
+The following arguments are required:
+
+- `server_id` - (Required) The ID of the server associated with.
+- `private_network_id` - (Required) The ID of the private network attached to.
+
+## Attributes Reference
+
+In addition to all above arguments, the following attributes are exported:
+
+- `id` - The ID of the private NIC.
+
+## Import
+
+Private NICs can be imported using the `{zone}/{server_id}/{private_nic_id}`, e.g.
+
+```bash
+$ terraform import scaleway_instance_volume.server_volume fr-par-1/11111111-1111-1111-1111-111111111111/22222222-2222-2222-2222-222222222222
+```

docs/resources/lb_backend.md

@@ -49,7 +49,7 @@ The following arguments are supported:
 - `forward_protocol`            - (Required) Backend protocol. Possible values are: `tcp` or `http`.
 - `name`                        - (Optional) The name of the load-balancer backend.
 - `forward_port`                - (Required) User sessions will be forwarded to this port of backend servers.
-- `forward_port_algorithm`      - (Default: `roundrobin`) Load balancing algorithm. Possible values are: `roundrobin` and `leastconn`.
+- `forward_port_algorithm`      - (Default: `roundrobin`) Load balancing algorithm. Possible values are: `roundrobin`, `leastconn` and `first`.
 - `sticky_sessions`             - (Default: `none`) Load balancing algorithm. Possible values are: `none`, `cookie` and `table`.
 - `sticky_sessions_cookie_name` - (Optional) Cookie name for for sticky sessions. Only applicable when sticky_sessions is set to `cookie`.
 - `server_ips`                  - (Optional) List of backend server IP addresses. Addresses can be either IPv4 or IPv6.

docs/resources/vpc_private_network.md

@@ -0,0 +1,43 @@
+---
+page_title: "Scaleway: scaleway_vpc_private_network"
+description: |-
+  Manages Scaleway VPC Private Networks.
+---
+
+# scaleway_vpc_private_network
+
+Creates and manages Scaleway VPC Private Networks. For more information, see
+[the documentation](https://developers.scaleway.com/en/products/vpc/api/#private-networks-ac2df4).
+
+## Example
+
+```hcl
+resource "scaleway_vpc_private_network" "pn_priv" {
+    name = "subnet_demo"
+    tags = ["demo", "tarraform"]
+}
+```
+
+## Arguments Reference
+
+The following arguments are supported:
+
+- `name` - (Optional) The name of the private network. If not provided it will be randomly generated.
+- `tags` - (Optional) The tags associated with the private network.
+- `zone` - (Defaults to [provider](../index.md#zone) `zone`) The [zone](../guides/regions_and_zones.md#zones) in which the private network should be created.
+- `project_id` - (Defaults to [provider](../index.md#project_id) `project_id`) The ID of the project the private network is associated with.
+
+## Attributes Reference
+
+In addition to all above arguments, the following attributes are exported:
+
+- `id` - The ID of the private network.
+- `organization_id` - (Defaults to [provider](../index.md#organization_id) `organization_id`) The ID of the organization the private network is associated with.
+
+## Import
+
+Private networks can be imported using the `{zone}/{id}`, e.g.
+
+```bash
+$ terraform import scaleway_vpc_private_network.vpc_demo fr-par-1/11111111-1111-1111-1111-111111111111
+```

scaleway/data_source_account_ssh_key.go

@@ -11,35 +11,25 @@ import (
 )
 
 func dataSourceScalewayAccountSSHKey() *schema.Resource {
+	dsSchema := datasourceSchemaFromResourceSchema(resourceScalewayAccountSSKKey().Schema)
+	addOptionalFieldsToSchema(dsSchema, "name")
+
+	dsSchema["name"].ConflictsWith = []string{"ssh_key_id"}
+	dsSchema["ssh_key_id"] = &schema.Schema{
+		Type:         schema.TypeString,
+		Optional:     true,
+		Description:  "The ID of the SSH key",
+		ValidateFunc: validationUUID(),
+	}
+
 	return &schema.Resource{
 		ReadContext: dataSourceScalewayAccountSSHKeyRead,
-		Schema: map[string]*schema.Schema{
-			"name": {
-				Type:        schema.TypeString,
-				Optional:    true,
-				Computed:    true,
-				Description: "The name of the SSH key",
-			},
-			"ssh_key_id": {
-				Type:         schema.TypeString,
-				Optional:     true,
-				Computed:     true,
-				Description:  "The ID of the SSH key",
-				ValidateFunc: validationUUIDorUUIDWithLocality(),
-			},
-			"public_key": {
-				Type:        schema.TypeString,
-				Computed:    true,
-				Description: "The public SSH key",
-			},
-			"organization_id": organizationIDSchema(),
-			"project_id":      projectIDSchema(),
-		},
+		Schema:      dsSchema,
 	}
 }
 
-func dataSourceScalewayAccountSSHKeyRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
-	accountAPI := accountAPI(m)
+func dataSourceScalewayAccountSSHKeyRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	accountAPI := accountAPI(meta)
 
 	var sshKey *account.SSHKey
 	sshKeyID, ok := d.GetOk("ssh_key_id")
@@ -67,11 +57,7 @@ func dataSourceScalewayAccountSSHKeyRead(ctx context.Context, d *schema.Resource
 	}
 
 	d.SetId(sshKey.ID)
-	_ = d.Set("name", sshKey.Name)
 	_ = d.Set("ssh_key_id", sshKey.ID)
-	_ = d.Set("public_key", sshKey.PublicKey)
-	_ = d.Set("organization_id", sshKey.OrganizationID)
-	_ = d.Set("project_id", sshKey.ProjectID)
 
-	return nil
+	return resourceScalewayAccountSSHKeyRead(ctx, d, meta)
 }

scaleway/data_source_vpc_private_network.go

@@ -0,0 +1,76 @@
+package scaleway
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/scaleway/scaleway-sdk-go/api/vpc/v1"
+	"github.com/scaleway/scaleway-sdk-go/scw"
+)
+
+func dataSourceScalewayVPCPrivateNetwork() *schema.Resource {
+	// Generate datasource schema from resource
+	dsSchema := datasourceSchemaFromResourceSchema(resourceScalewayVPCPrivateNetwork().Schema)
+
+	// Set 'Optional' schema elements
+	addOptionalFieldsToSchema(dsSchema, "name")
+
+	dsSchema["name"].ConflictsWith = []string{"private_network_id"}
+	dsSchema["private_network_id"] = &schema.Schema{
+		Type:          schema.TypeString,
+		Optional:      true,
+		Description:   "The ID of the private network",
+		ValidateFunc:  validationUUIDorUUIDWithLocality(),
+		ConflictsWith: []string{"name"},
+	}
+
+	return &schema.Resource{
+		Schema:      dsSchema,
+		ReadContext: dataSourceScalewayVPCPrivateNetworkRead,
+	}
+}
+
+func dataSourceScalewayVPCPrivateNetworkRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	meta := m.(*Meta)
+	vpcAPI, zone, err := vpcAPIWithZone(d, meta)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	privateNetworkID, ok := d.GetOk("private_network_id")
+	if !ok {
+		res, err := vpcAPI.ListPrivateNetworks(
+			&vpc.ListPrivateNetworksRequest{
+				Name: expandStringPtr(d.Get("name").(string)),
+				Zone: zone,
+			}, scw.WithContext(ctx))
+		if err != nil {
+			return diag.FromErr(err)
+		}
+		if res.TotalCount == 0 {
+			return diag.FromErr(
+				fmt.Errorf(
+					"no private network found with the name %s",
+					d.Get("name"),
+				),
+			)
+		}
+		if res.TotalCount > 1 {
+			return diag.FromErr(
+				fmt.Errorf(
+					"%d private networks found with the name %s",
+					res.TotalCount,
+					d.Get("name"),
+				),
+			)
+		}
+		privateNetworkID = res.PrivateNetworks[0].ID
+	}
+
+	zonedID := datasourceNewZonedID(privateNetworkID, zone)
+	d.SetId(zonedID)
+	_ = d.Set("private_network_id", zonedID)
+	return resourceScalewayVPCPrivateNetworkRead(ctx, d, m)
+}

scaleway/data_source_vpc_private_network_test.go

@@ -0,0 +1,51 @@
+package scaleway
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+)
+
+func TestAccScalewayDataSourceVPCPrivateNetwork_Basic(t *testing.T) {
+	tt := NewTestTools(t)
+	defer tt.Cleanup()
+	pnName := "TestAccScalewayDataSourceVPCPrivateNetwork_Basic"
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:          func() { testAccPreCheck(t) },
+		ProviderFactories: tt.ProviderFactories,
+		CheckDestroy:      testAccCheckScalewayVPCPrivateNetworkDestroy(tt),
+		Steps: []resource.TestStep{
+			{
+				Config: fmt.Sprintf(`
+					resource "scaleway_vpc_private_network" "pn_test" {
+					  name = "%s"
+					}`, pnName),
+			},
+			{
+				Config: fmt.Sprintf(`
+					resource "scaleway_vpc_private_network" "pn_test" {
+					  name = "%s"
+					}
+
+					data "scaleway_vpc_private_network" "pn_test_by_name" {
+						name = "${scaleway_vpc_private_network.pn_test.name}"
+					}
+
+					data "scaleway_vpc_private_network" "pn_test_by_id" {
+						private_network_id = "${scaleway_vpc_private_network.pn_test.id}"
+					}
+				`, pnName),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckScalewayVPCPrivateNetworkExists(tt, "scaleway_vpc_private_network.pn_test"),
+					resource.TestCheckResourceAttrPair(
+						"data.scaleway_vpc_private_network.pn_test_by_name", "name",
+						"scaleway_vpc_private_network.pn_test", "name"),
+					resource.TestCheckResourceAttrPair(
+						"data.scaleway_vpc_private_network.pn_test_by_id", "private_network_id",
+						"scaleway_vpc_private_network.pn_test", "id"),
+				),
+			},
+		},
+	})
+}

scaleway/helpers.go

@@ -90,6 +90,15 @@ func parseLocalizedID(localizedID string) (locality string, ID string, err error
 	return tab[0], tab[1], nil
 }
 
+// parseLocalizedNestedID parses a localizedNestedID and extracts the resource locality, the inner and outer id.
+func parseLocalizedNestedID(localizedID string) (locality string, innerID, outerID string, err error) {
+	tab := strings.SplitN(localizedID, "/", -1)
+	if len(tab) != 3 {
+		return "", "", localizedID, fmt.Errorf("cant parse localized id: %s", localizedID)
+	}
+	return tab[0], tab[1], tab[2], nil
+}
+
 // parseZonedID parses a zonedID and extracts the resource zone and id.
 func parseZonedID(zonedID string) (zone scw.Zone, id string, err error) {
 	locality, id, err := parseLocalizedID(zonedID)
@@ -101,6 +110,17 @@ func parseZonedID(zonedID string) (zone scw.Zone, id string, err error) {
 	return
 }
 
+// parseZonedNestedID parses a zonedNestedID and extracts the resource zone ,inner and outer ID.
+func parseZonedNestedID(zonedNestedID string) (zone scw.Zone, outerID, innerID string, err error) {
+	locality, innerID, outerID, err := parseLocalizedNestedID(zonedNestedID)
+	if err != nil {
+		return
+	}
+
+	zone, err = scw.ParseZone(locality)
+	return
+}
+
 // expandID returns the id whether it is a localizedID or a raw ID.
 func expandID(id interface{}) string {
 	_, ID, err := parseLocalizedID(id.(string))
@@ -126,6 +146,11 @@ func newZonedIDString(zone scw.Zone, id string) string {
 	return fmt.Sprintf("%s/%s", zone, id)
 }
 
+// newZonedNestedIDString constructs a unique identifier based on resource zone, inner and outer IDs
+func newZonedNestedIDString(zone scw.Zone, outerID, innerID string) string {
+	return fmt.Sprintf("%s/%s/%s", zone, outerID, innerID)
+}
+
 // newRegionalIDString constructs a unique identifier based on resource region and id
 func newRegionalIDString(region scw.Region, id string) string {
 	return fmt.Sprintf("%s/%s", region, id)

scaleway/helpers_instance.go

@@ -43,6 +43,15 @@ func instanceAPIWithZoneAndID(m interface{}, zonedID string) (*instance.API, scw
 	return instanceAPI, zone, ID, err
 }
 
+// instanceAPIWithZoneAndNestedID returns an instance API with zone and inner/outer ID extracted from the state
+func instanceAPIWithZoneAndNestedID(m interface{}, zonedNestedID string) (*instance.API, scw.Zone, string, string, error) {
+	meta := m.(*Meta)
+	instanceAPI := instance.NewAPI(meta.scwClient)
+
+	zone, innerID, outerID, err := parseZonedNestedID(zonedNestedID)
+	return instanceAPI, zone, innerID, outerID, err
+}
+
 // hash hashes a string to a unique hashcode.
 //
 // crc32 returns a uint32, but for our use we need