feat(function): add support for function (#1109)

Co-authored-by: Jules Castéran <[email protected]>

Author: remyleone

docs/resources/function.md

@@ -0,0 +1,104 @@
+---
+page_title: "Scaleway: scaleway_function"
+description: |-
+Manages Scaleway Functions.
+---
+
+# scaleway_function
+
+Creates and manages Scaleway Functions.
+For more information see [the documentation](https://developers.scaleway.com/en/products/functions/api/).
+
+## Examples
+
+### Basic
+
+```hcl
+resource "scaleway_function_namespace" "main" {
+  name        = "main-function-namespace"
+  description = "Main function namespace"
+}
+
+resource scaleway_function main {
+  namespace_id = scaleway_function_namespace.main.id
+  runtime      = "go118"
+  handler      = "Handle"
+  privacy      = "private"
+}
+```
+
+### With sources and deploy
+
+You create a zip of your function (ex: `zip function.zip -r go.mod go.sum handler.go`)
+
+```hcl
+resource "scaleway_function_namespace" "main" {
+  name        = "main-function-namespace"
+  description = "Main function namespace"
+}
+
+resource scaleway_function main {
+  namespace_id = scaleway_function_namespace.main.id
+  runtime      = "go118"
+  handler      = "Handle"
+  privacy      = "private"
+  zip_file = "function.zip"
+  zip_hash = filesha256("function.zip")
+  deploy = true
+}
+```
+
+
+## Arguments Reference
+
+The following arguments are supported:
+
+- `name` - (Required) The unique name of the function.
+
+~> **Important** Updates to `name` will recreate the function.
+
+- `description` (Optional) The description of the function.
+
+- `environment_variables` - The environment variables of the function.
+
+- `privacy` - Privacy of the function. Can be either `private` or `public`. Read more on [authentication](https://developers.scaleway.com/en/products/functions/api/#authentication)
+
+- `runtime` - Runtime of the function. Runtimes can be fetched using [specific route](https://developers.scaleway.com/en/products/functions/api/#get-f7de6a)
+
+- `min_scale` - Minimum replicas for your function, defaults to 0, Note that a function is billed when it gets executed, and using a min_scale greater than 0 will cause your function container to run constantly.
+
+- `max_scale` - Maximum replicas for your function (defaults to 20), our system will scale your functions automatically based on incoming workload, but will never scale the number of replicas above the configured max_scale.
+
+- `memory_limit` - Memory limit in MB for your function, defaults to 128MB
+
+- `handler` - Handler of the function. Depends on the runtime ([function guide](https://developers.scaleway.com/en/products/functions/api/#create-a-function))
+
+- `timeout` - Holds the max duration (in seconds) the function is allowed for responding to a request
+
+- `zip_file` - Location of the zip file to upload containing your function sources
+
+- `zip_hash` - The hash of your source zip file, changing it will re-apply function. Can be any string, changing it will just trigger state change. You can use any terraform hash function to trigger a change on your zip change (see examples)
+
+- `deploy` - Define if the function should be deployed, terraform will wait for function to be deployed. Function will get deployed if you change source zip
+
+- `region` - (Defaults to [provider](../index.md#region) `region`). The [region](../guides/regions_and_zones.md#regions) in which the namespace should be created.
+
+- `project_id` - (Defaults to [provider](../index.md#project_id) `project_id`) The ID of the project the namespace is associated with.
+
+
+## Attributes Reference
+
+In addition to all arguments above, the following attributes are exported:
+
+- `id` - The ID of the function
+- `organization_id` - The organization ID the function is associated with.
+- `cpu_limit` - The CPU limit in mCPU for your function. More infos on resources [here](https://developers.scaleway.com/en/products/functions/api/#functions)
+
+
+## Import
+
+Functions can be imported using the `{region}/{id}`, e.g.
+
+```bash
+$ terraform import scaleway_function.main fr-par/11111111-1111-1111-1111-111111111111
+```

go.mod

@@ -13,7 +13,6 @@ require (
 	github.com/hashicorp/terraform-plugin-sdk/v2 v2.17.0
 	github.com/scaleway/scaleway-sdk-go v1.0.0-beta.9.0.20220519084803-2eb97e55dee8
 	github.com/stretchr/testify v1.7.1
-
 )
 
 require (

scaleway/data_source_function.go

@@ -0,0 +1,62 @@
+package scaleway
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	function "github.com/scaleway/scaleway-sdk-go/api/function/v1beta1"
+	"github.com/scaleway/scaleway-sdk-go/scw"
+)
+
+func dataSourceScalewayFunction() *schema.Resource {
+	// Generate datasource schema from resource
+	dsSchema := datasourceSchemaFromResourceSchema(resourceScalewayFunction().Schema)
+
+	dsSchema["function_id"] = &schema.Schema{
+		Type:        schema.TypeString,
+		Description: "The ID of the function",
+		Computed:    true,
+	}
+
+	addOptionalFieldsToSchema(dsSchema, "name", "function_id")
+	fixDatasourceSchemaFlags(dsSchema, true, "namespace_id")
+
+	return &schema.Resource{
+		ReadContext: dataSourceScalewayFunctionRead,
+		Schema:      dsSchema,
+	}
+}
+
+func dataSourceScalewayFunctionRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	api, region, err := functionAPIWithRegion(d, meta)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	functionID, ok := d.GetOk("function_id")
+	if !ok {
+		res, err := api.ListFunctions(&function.ListFunctionsRequest{
+			Region:      region,
+			NamespaceID: expandID(d.Get("namespace_id").(string)),
+			Name:        expandStringPtr(d.Get("name")),
+		}, scw.WithContext(ctx))
+		if err != nil {
+			return diag.FromErr(err)
+		}
+		if len(res.Functions) == 0 {
+			return diag.FromErr(fmt.Errorf("no functions found with the name %s", d.Get("name")))
+		}
+		if len(res.Functions) > 1 {
+			return diag.FromErr(fmt.Errorf("%d functions found with the same name %s", len(res.Functions), d.Get("name")))
+		}
+		functionID = res.Functions[0].ID
+	}
+
+	regionalID := datasourceNewRegionalizedID(functionID, region)
+	d.SetId(regionalID)
+	_ = d.Set("function_id", regionalID)
+
+	return resourceScalewayFunctionRead(ctx, d, meta)
+}

scaleway/data_source_function_test.go

@@ -0,0 +1,73 @@
+package scaleway
+
+import (
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+)
+
+func TestAccScalewayDataSourceFunction_Basic(t *testing.T) {
+	tt := NewTestTools(t)
+	defer tt.Cleanup()
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:          func() { testAccPreCheck(t) },
+		ProviderFactories: tt.ProviderFactories,
+		CheckDestroy:      testAccCheckScalewayFunctionDestroy(tt),
+		Steps: []resource.TestStep{
+			{
+				Config: `
+					resource "scaleway_function_namespace" "main" {
+						name = "tf-ds-function"
+					}
+
+					resource scaleway_function main {
+						name = "tf-ds-function"
+						namespace_id = scaleway_function_namespace.main.id
+						runtime = "node14"
+						privacy = "private"
+						handler = "handler.handle"
+					}
+				`,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckScalewayFunctionExists(tt, "scaleway_function.main"),
+					resource.TestCheckResourceAttr("scaleway_function.main", "name", "tf-ds-function"),
+				),
+			},
+			{
+				Config: `
+					resource "scaleway_function_namespace" "main" {
+						name = "tf-ds-function"
+					}
+
+					resource scaleway_function main {
+						name = "tf-ds-function"
+						namespace_id = scaleway_function_namespace.main.id
+						runtime = "node14"
+						privacy = "private"
+						handler = "handler.handle"
+					}					
+					
+					data "scaleway_function" "by_name" {
+						name = scaleway_function.main.name
+						namespace_id = scaleway_function_namespace.main.id
+					}
+					
+					data "scaleway_function" "by_id" {
+						function_id = scaleway_function.main.id
+						namespace_id = scaleway_function_namespace.main.id
+					}
+				`,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckScalewayFunctionExists(tt, "scaleway_function.main"),
+					resource.TestCheckResourceAttr("scaleway_function.main", "name", "tf-ds-function"),
+					resource.TestCheckResourceAttrSet("data.scaleway_function.by_name", "id"),
+
+					resource.TestCheckResourceAttr("data.scaleway_function.by_id", "name", "tf-ds-function"),
+					resource.TestCheckResourceAttrSet("data.scaleway_function.by_id", "id"),
+					resource.TestCheckResourceAttr("data.scaleway_function.by_id", "name", "tf-ds-function"),
+				),
+			},
+		},
+	})
+}

scaleway/helpers_function.go

@@ -2,16 +2,23 @@ package scaleway
 
 import (
 	"context"
+	"fmt"
+	"net/http"
+	"net/http/httputil"
+	"os"
 	"time"
 
+	"github.com/hashicorp/terraform-plugin-log/tflog"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 	function "github.com/scaleway/scaleway-sdk-go/api/function/v1beta1"
 	"github.com/scaleway/scaleway-sdk-go/scw"
 )
 
 const (
 	defaultFunctionNamespaceTimeout = 5 * time.Minute
+	defaultFunctionTimeout          = 15 * time.Minute
 	defaultFunctionRetryInterval    = 5 * time.Second
+	defaultFunctionAfterUpdateWait  = 1 * time.Second
 )
 
 // functionAPIWithRegion returns a new container registry API and the region.
@@ -53,3 +60,96 @@ func waitForFunctionNamespace(ctx context.Context, functionAPI *function.API, re
 
 	return ns, err
 }
+
+func waitForFunction(ctx context.Context, functionAPI *function.API, region scw.Region, id string, timeout time.Duration) (*function.Function, error) {
+	retryInterval := defaultFunctionRetryInterval
+	if DefaultWaitRetryInterval != nil {
+		retryInterval = *DefaultWaitRetryInterval
+	}
+
+	f, err := functionAPI.WaitForFunction(&function.WaitForFunctionRequest{
+		Region:        region,
+		FunctionID:    id,
+		RetryInterval: &retryInterval,
+		Timeout:       scw.TimeDurationPtr(timeout),
+	}, scw.WithContext(ctx))
+
+	return f, err
+}
+
+func functionUpload(ctx context.Context, m interface{}, functionAPI *function.API, region scw.Region, functionID string, zipFile string) error {
+	meta := m.(*Meta)
+	zipStat, err := os.Stat(zipFile)
+	if err != nil {
+		return fmt.Errorf("failed to stat zip file: %w", err)
+	}
+
+	uploadURL, err := functionAPI.GetFunctionUploadURL(&function.GetFunctionUploadURLRequest{
+		Region:        region,
+		FunctionID:    functionID,
+		ContentLength: uint64(zipStat.Size()),
+	}, scw.WithContext(ctx))
+	if err != nil {
+		return fmt.Errorf("failed to fetch upload url: %w", err)
+	}
+
+	zip, err := os.Open(zipFile)
+	if err != nil {
+		return fmt.Errorf("failed to read zip file: %w", err)
+	}
+	defer zip.Close()
+
+	req, err := http.NewRequest(http.MethodPut, uploadURL.URL, zip)
+	if err != nil {
+		return fmt.Errorf("failed to init request: %w", err)
+	}
+
+	req = req.WithContext(ctx)
+
+	for headerName, headerList := range uploadURL.Headers {
+		for _, header := range *headerList {
+			req.Header.Add(headerName, header)
+		}
+	}
+
+	secretKey, _ := meta.scwClient.GetSecretKey()
+	req.Header.Add("X-Auth-Token", secretKey)
+
+	resp, err := meta.httpClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("failed to send request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	respDump, err := httputil.DumpResponse(resp, true)
+	if err != nil {
+		return fmt.Errorf("failed to dump response: %w", err)
+	}
+
+	reqDump, err := httputil.DumpRequest(req, false)
+	if err != nil {
+		return fmt.Errorf("failed to dump request: %w", err)
+	}
+
+	tflog.Debug(ctx, "Request dump", map[string]interface{}{
+		"url":      uploadURL.URL,
+		"response": string(respDump),
+		"request":  string(reqDump),
+	})
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("failed to upload function (Status: %d)", resp.StatusCode)
+	}
+
+	return nil
+}
+
+func functionDeploy(ctx context.Context, functionAPI *function.API, region scw.Region, functionID string) error {
+	_, err := functionAPI.DeployFunction(&function.DeployFunctionRequest{
+		Region:     region,
+		FunctionID: functionID,
+	}, scw.WithContext(ctx))
+	if err != nil {
+		return fmt.Errorf("failed to deploy function")
+	}
+	return nil
+}

scaleway/provider.go

@@ -67,6 +67,7 @@ func Provider(config *ProviderConfig) plugin.ProviderFunc {
 				"scaleway_container_namespace":                 resourceScalewayContainerNamespace(),
 				"scaleway_domain_record":                       resourceScalewayDomainRecord(),
 				"scaleway_domain_zone":                         resourceScalewayDomainZone(),
+				"scaleway_function":                            resourceScalewayFunction(),
 				"scaleway_function_namespace":                  resourceScalewayFunctionNamespace(),
 				"scaleway_instance_ip":                         resourceScalewayInstanceIP(),
 				"scaleway_instance_ip_reverse_dns":             resourceScalewayInstanceIPReverseDNS(),
@@ -116,6 +117,7 @@ func Provider(config *ProviderConfig) plugin.ProviderFunc {
 				"scaleway_domain_zone":                 dataSourceScalewayDomainZone(),
 				"scaleway_container_namespace":         dataSourceScalewayContainerNamespace(),
 				"scaleway_container":                   dataSourceScalewayContainer(),
+				"scaleway_function":                    dataSourceScalewayFunction(),
 				"scaleway_function_namespace":          dataSourceScalewayFunctionNamespace(),
 				"scaleway_instance_ip":                 dataSourceScalewayInstanceIP(),
 				"scaleway_instance_security_group":     dataSourceScalewayInstanceSecurityGroup(),