feat: skip code upload if code hasn't changed

Author: cyclimse

internal/constants/constants.go

@@ -14,6 +14,10 @@ const (
 	// It's used as an extra safety measure to avoid deleting resources not created by this tool.
 	TagCreatedByScalewayMCP = "created_by=" + ProjectName
 
+	// TagCodeArchiveDigest is the tag key used to store the code archive digest.
+	// It's used to avoid redeploying the same code.
+	TagCodeArchiveDigest = "code_archive_digest="
+
 	// RequiredPermissionSets is the minimum permission sets required for the Scaleway API key.
 	RequiredPermissionSets = "FunctionsFullAccess, ObservabilityFullAccess"
 

internal/scaleway/create_deploy_function.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/cyclimse/mcp-scaleway-functions/internal/constants"
 	"github.com/modelcontextprotocol/go-sdk/mcp"
 	function "github.com/scaleway/scaleway-sdk-go/api/function/v1beta1"
 	"github.com/scaleway/scaleway-sdk-go/scw"
@@ -107,6 +108,8 @@ func (t *Tools) CreateAndDeployFunction(
 		return nil, Function{}, fmt.Errorf("converting to SDK request: %w", err)
 	}
 
+	// We always create the function first before zipping the code archive for
+	// faster feedback to the user in case of errors.
 	fun, err := t.functionsAPI.CreateFunction(createReq, scw.WithContext(ctx))
 	if err != nil {
 		return nil, Function{}, fmt.Errorf("creating function: %w", err)
@@ -119,6 +122,20 @@ func (t *Tools) CreateAndDeployFunction(
 		return nil, Function{}, fmt.Errorf("creating archive: %w", err)
 	}
 
+	tags := append(fun.Tags, constants.TagCodeArchiveDigest+archive.Digest)
+
+	// However, as a side-effect of doing creation first, we need to
+	// update the function to add the code archive digest tag (which helps
+	// avoid redeploying the same code in future updates).
+	fun, err = t.functionsAPI.UpdateFunction(&function.UpdateFunctionRequest{
+		FunctionID: fun.ID,
+		Redeploy:   scw.BoolPtr(false),
+		Tags:       scw.StringsPtr(tags),
+	}, scw.WithContext(ctx))
+	if err != nil {
+		return nil, Function{}, fmt.Errorf("updating function with code archive digest tag: %w", err)
+	}
+
 	presignedURLResp, err := t.functionsAPI.GetFunctionUploadURL(
 		&function.GetFunctionUploadURLRequest{
 			FunctionID:    fun.ID,

internal/scaleway/helpers.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"slices"
+	"strings"
 	"time"
 
 	"github.com/cyclimse/mcp-scaleway-functions/internal/constants"
@@ -95,6 +96,19 @@ func checkResourceOwnership(tags []string) error {
 	return nil
 }
 
+func getCodeArchiveDigestFromTags(tags []string) (string, bool) {
+	prefix := constants.TagCodeArchiveDigest
+
+	for _, tag := range tags {
+		after, found := strings.CutPrefix(tag, prefix)
+		if found {
+			return after, true
+		}
+	}
+
+	return "", false
+}
+
 type WaitForFunctionCallback func(fun *function.Function)
 
 // waitForFunction waits for a function to be in a terminal state (ready or error), running the

internal/scaleway/update_function.go

@@ -92,21 +92,29 @@ func (t *Tools) UpdateFunction(
 		return nil, Function{}, fmt.Errorf("creating archive: %w", err)
 	}
 
-	presignedURLResp, err := t.functionsAPI.GetFunctionUploadURL(
-		&function.GetFunctionUploadURLRequest{
-			FunctionID:    fun.ID,
-			ContentLength: archive.Size,
-		},
-		scw.WithContext(ctx),
-	)
-	if err != nil {
-		return nil, Function{}, fmt.Errorf("getting presigned URL: %w", err)
+	shouldSkipUpload := false
+	digest, found := getCodeArchiveDigestFromTags(fun.Tags)
+	if found && archive.CompareDigest(digest) {
+		shouldSkipUpload = true
 	}
 
-	progress.NotifyCodeUploading(ctx, req)
+	if !shouldSkipUpload {
+		presignedURLResp, err := t.functionsAPI.GetFunctionUploadURL(
+			&function.GetFunctionUploadURLRequest{
+				FunctionID:    fun.ID,
+				ContentLength: archive.Size,
+			},
+			scw.WithContext(ctx),
+		)
+		if err != nil {
+			return nil, Function{}, fmt.Errorf("getting presigned URL: %w", err)
+		}
 
-	if err := archive.Upload(ctx, presignedURLResp.URL); err != nil {
-		return nil, Function{}, fmt.Errorf("uploading archive: %w", err)
+		progress.NotifyCodeUploading(ctx, req)
+
+		if err := archive.Upload(ctx, presignedURLResp.URL); err != nil {
+			return nil, Function{}, fmt.Errorf("uploading archive: %w", err)
+		}
 	}
 
 	updateReq, err := in.ToSDK(fun.ID)

internal/scaleway/zip.go

@@ -3,6 +3,7 @@ package scaleway
 import (
 	"archive/zip"
 	"context"
+	"crypto/sha256"
 	"errors"
 	"fmt"
 	"io"
@@ -20,8 +21,9 @@ var (
 )
 
 type CodeArchive struct {
-	Path string
-	Size uint64
+	Path   string
+	Size   uint64
+	Digest string
 }
 
 func NewCodeArchive(from string) (*CodeArchive, error) {
@@ -49,12 +51,22 @@ func NewCodeArchive(from string) (*CodeArchive, error) {
 		return nil, fmt.Errorf("getting zip file stat: %w", err)
 	}
 
+	digest, err := computeFileDigest(zipFile)
+	if err != nil {
+		return nil, fmt.Errorf("computing zip file digest: %w", err)
+	}
+
 	return &CodeArchive{
-		Path: zipFile.Name(),
-		Size: safeConvertInt64ToUint64(stat.Size()),
+		Path:   zipFile.Name(),
+		Size:   safeConvertInt64ToUint64(stat.Size()),
+		Digest: digest,
 	}, nil
 }
 
+func (f *CodeArchive) CompareDigest(otherDigest string) bool {
+	return f.Digest == otherDigest
+}
+
 func (f *CodeArchive) Upload(ctx context.Context, preSignedURL string) error {
 	zipFile, err := os.Open(f.Path)
 	if err != nil {
@@ -187,6 +199,15 @@ func zipDirectory(zipFile *os.File, pathToDir string) error {
 	return nil
 }
 
+func computeFileDigest(file *os.File) (string, error) {
+	hash := sha256.New()
+	if _, err := io.Copy(hash, file); err != nil {
+		return "", fmt.Errorf("computing file digest: %w", err)
+	}
+
+	return fmt.Sprintf("%x", hash.Sum(nil)), nil
+}
+
 //nolint:revive,funlen
 func unzipDirectory(zipPath, toDir string) error {
 	root, err := os.OpenRoot(toDir)