Merge pull request #21 from cyclimse/feat/skip-code-uploads

feat: skip code uploads when code hasn't changed

Author: cyclimse

.golangci.yml

@@ -47,7 +47,7 @@ linters:
             - 15
         - name: cognitive-complexity
           arguments:
-            - 15 # Yes, I'm aware this is insane, but whatever, this is a pet project
+            - 16 # Yes, I'm aware this is insane, but whatever, this is a pet project
         - name: max-public-structs
           arguments:
             - 10 # Up from 5

README.md

@@ -14,7 +14,7 @@ Download the latest release from the [releases page](https://github.com/cyclimse
 
 Run the MCP server:
 
-```console
+```bash
 ./mcp-scaleway-functions
 ```
 
@@ -97,7 +97,7 @@ Further configuration can be done via the
 
 For instance, you can set a region to work in via the `SCW_DEFAULT_REGION` environment variable.
 
-```console
+```bash
 SCW_DEFAULT_REGION=nl-ams ./mcp-scaleway-functions
 ```
 
@@ -129,13 +129,12 @@ Logs are stored in the `$XDG_STATE_HOME/mcp-scaleway-functions` directory (usual
 
 Running tests:
 
-```console
+```bash
 go tool gotestsum --format testdox
 ```
 
 Generating mocks:
 
-```console
+```bash
 go tool mockery
 ```
-

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
 
+	// TagCodeArchiveDigestPrefix is the tag key used to store the code archive digest.
+	// It's used to avoid redeploying the same code.
+	TagCodeArchiveDigestPrefix = "code_archive_digest="
+
 	// RequiredPermissionSets is the minimum permission sets required for the Scaleway API key.
 	RequiredPermissionSets = "FunctionsFullAccess, ObservabilityFullAccess"
 

internal/middlewares/middlewares.go

@@ -47,9 +47,12 @@ func NewLogging() mcp.Middleware {
 			logger = logger.With(slog.Duration("duration", duration))
 			logger = logger.With(slogAttrFromResult(result)...)
 
-			if err != nil {
+			switch {
+			case err != nil:
 				logger.Error("Request failed", slog.String("error", err.Error()))
-			} else {
+			case isErrorResult(result):
+				logger.Error("Request errored")
+			default:
 				logger.Info("Request succeeded")
 			}
 
@@ -73,11 +76,28 @@ func slogAttrFromRequest(method string, req mcp.Request) []any {
 	return attrs
 }
 
+func isErrorResult(result mcp.Result) bool {
+	if callResult, ok := result.(*mcp.CallToolResult); ok {
+		return callResult.IsError
+	}
+
+	return false
+}
+
 func slogAttrFromResult(result mcp.Result) []any {
 	attrs := []any{}
 
 	if callResult, ok := result.(*mcp.CallToolResult); ok {
 		attrs = append(attrs, slogJSON("tool_result", callResult.StructuredContent))
+
+		if callResult.IsError {
+			attrs = append(attrs, slog.Bool("tool_error", true))
+
+			if len(callResult.Content) > 0 {
+				firstLines := callResult.Content[0]
+				attrs = append(attrs, slogJSON("tool_error_content", firstLines))
+			}
+		}
 	}
 
 	return attrs

internal/scaleway/cockpit/entry.go

@@ -21,14 +21,11 @@ func (e *Entry) UnmarshalJSON(data []byte) error {
 	_, err := jsonparser.ArrayEach(
 		data,
 		func(value []byte, t jsonparser.ValueType, _ int, _ error) {
-			// assert that both items in array are of type string
+			// Assert that both items in array are of type string
 			switch i {
 			case 0: // timestamp
 				if t != jsonparser.String {
-					parseError = fmt.Errorf(
-						"%w: expected string timestamp",
-						jsonparser.MalformedStringError,
-					)
+					parseError = jsonparser.MalformedStringError
 
 					return
 				}
@@ -41,7 +38,7 @@ func (e *Entry) UnmarshalJSON(data []byte) error {
 				}
 
 				e.Timestamp = time.Unix(0, ts)
-			case 1: // value
+			case 1: // log line
 				if t != jsonparser.String {
 					parseError = jsonparser.MalformedStringError
 
@@ -57,8 +54,7 @@ func (e *Entry) UnmarshalJSON(data []byte) error {
 
 				e.Line = v
 			default:
-				// Ignore extra values
-				return
+				return // no-op
 			}
 
 			i++
@@ -69,5 +65,9 @@ func (e *Entry) UnmarshalJSON(data []byte) error {
 		return parseError
 	}
 
-	return fmt.Errorf("parsing log entry array: %w", err)
+	if err != nil {
+		return fmt.Errorf("parsing log entry array: %w", err)
+	}
+
+	return nil
 }

internal/scaleway/create_and_deploy_function_namespace.go

@@ -26,7 +26,7 @@ type CreateAndDeployFunctionNamespace struct {
 func (in CreateAndDeployFunctionNamespace) ToSDK() *function.CreateNamespaceRequest {
 	return &function.CreateNamespaceRequest{
 		Name: in.Name,
-		Tags: setCreatedByTagIfAbsent(in.Tags),
+		Tags: setCreatedByTag(in.Tags),
 	}
 }
 

internal/scaleway/create_deploy_function.go

@@ -81,7 +81,7 @@ func (req CreateAndDeployFunctionRequest) ToSDK(
 			Seconds: int64(timeout.Seconds()),
 		},
 		Description:                &req.Description,
-		Tags:                       setCreatedByTagIfAbsent(req.Tags),
+		Tags:                       setCreatedByTag(req.Tags),
 		EnvironmentVariables:       &req.EnvironmentVariables,
 		SecretEnvironmentVariables: secrets,
 		MinScale:                   req.MinScale,
@@ -90,6 +90,7 @@ func (req CreateAndDeployFunctionRequest) ToSDK(
 	}, nil
 }
 
+//nolint:funlen
 func (t *Tools) CreateAndDeployFunction(
 	ctx context.Context,
 	req *mcp.CallToolRequest,
@@ -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,23 @@ func (t *Tools) CreateAndDeployFunction(
 		return nil, Function{}, fmt.Errorf("creating archive: %w", err)
 	}
 
+	tags := setCodeArchiveDigestTag(fun.Tags, 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/fetch_function_logs.go

@@ -4,11 +4,11 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"log/slog"
 	"strings"
 	"time"
 
 	"github.com/cyclimse/mcp-scaleway-functions/internal/scaleway/cockpit"
+	"github.com/cyclimse/mcp-scaleway-functions/pkg/slogctx"
 	"github.com/modelcontextprotocol/go-sdk/mcp"
 )
 
@@ -37,6 +37,8 @@ func (t *Tools) FetchFunctionLogs(
 	_ *mcp.CallToolRequest,
 	req FetchFunctionLogsRequest,
 ) (*mcp.CallToolResult, FetchFunctionLogsResponse, error) {
+	logger := slogctx.FromContext(ctx)
+
 	function, ns, err := getFunctionAndNamespaceByFunctionName(
 		ctx,
 		t.functionsAPI,
@@ -47,7 +49,7 @@ func (t *Tools) FetchFunctionLogs(
 	}
 
 	if ns.ProjectID != t.projectID {
-		slog.WarnContext(
+		logger.WarnContext(
 			ctx,
 			"fetching logs across multiple Scaleway projects is not supported yet",
 			"function_project_id", ns.ProjectID,

internal/scaleway/helpers.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"slices"
+	"strings"
 	"time"
 
 	"github.com/cyclimse/mcp-scaleway-functions/internal/constants"
@@ -79,14 +80,36 @@ func getFunctionAndNamespaceByFunctionName(
 	return fun, ns, nil
 }
 
-func setCreatedByTagIfAbsent(tags []string) []string {
-	if !slices.Contains(tags, constants.TagCreatedByScalewayMCP) {
-		tags = append(tags, constants.TagCreatedByScalewayMCP)
+func setTag(tags []string, tag string) []string {
+	if !slices.Contains(tags, tag) {
+		tags = append(tags, tag)
 	}
 
 	return tags
 }
 
+func setCreatedByTag(tags []string) []string {
+	return setTag(tags, constants.TagCreatedByScalewayMCP)
+}
+
+func setCodeArchiveDigestTag(tags []string, digest string) []string {
+	prefix := constants.TagCodeArchiveDigestPrefix
+
+	// Remove any existing digest tag.
+	filtered := make([]string, 0, len(tags))
+
+	for _, tag := range tags {
+		if !strings.HasPrefix(tag, prefix) {
+			filtered = append(filtered, tag)
+		}
+	}
+
+	// Add the new digest tag.
+	filtered = append(filtered, prefix+digest)
+
+	return filtered
+}
+
 func checkResourceOwnership(tags []string) error {
 	if !slices.Contains(tags, constants.TagCreatedByScalewayMCP) {
 		return fmt.Errorf("%w: resource does not belong to this tool", ErrResourceNotOwnedByTool)
@@ -95,6 +118,19 @@ func checkResourceOwnership(tags []string) error {
 	return nil
 }
 
+func getCodeArchiveDigestFromTags(tags []string) (string, bool) {
+	prefix := constants.TagCodeArchiveDigestPrefix
+
+	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