Add Gzip request compression feature

.changelog/80ed28327bcd4301a264f318efaf8216.json

@@ -0,0 +1,8 @@
+{
+    "id": "80ed2832-7bcd-4301-a264-f318efaf8216",
+    "type": "feature",
+    "description": "Modify and Merge request compression codegen",
+    "modules": [
+        "."
+    ]
+}

codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen/SmithyGoDependency.java

@@ -53,6 +53,8 @@ public final class SmithyGoDependency {
     public static final GoDependency SMITHY_HTTP_TRANSPORT = smithy("transport/http", "smithyhttp");
     public static final GoDependency SMITHY_MIDDLEWARE = smithy("middleware");
     public static final GoDependency SMITHY_PRIVATE_PROTOCOL = smithy("private/protocol", "smithyprivateprotocol");
+    public static final GoDependency SMITHY_REQUEST_COMPRESSION =
+    smithy("private/requestcompression", "smithyrequestcompression");
     public static final GoDependency SMITHY_TIME = smithy("time", "smithytime");
     public static final GoDependency SMITHY_HTTP_BINDING = smithy("encoding/httpbinding");
     public static final GoDependency SMITHY_JSON = smithy("encoding/json", "smithyjson");

codegen/smithy-go-codegen/src/main/java/software/amazon/smithy/go/codegen/requestcompression/RequestCompression.java

@@ -0,0 +1,124 @@
+/*
+ * Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package software.amazon.smithy.go.codegen.requestcompression;
+
+import static software.amazon.smithy.go.codegen.GoWriter.goTemplate;
+
+import java.util.List;
+import software.amazon.smithy.codegen.core.SymbolProvider;
+import software.amazon.smithy.go.codegen.GoDelegator;
+import software.amazon.smithy.go.codegen.GoSettings;
+import software.amazon.smithy.go.codegen.GoWriter;
+import software.amazon.smithy.go.codegen.SmithyGoDependency;
+import software.amazon.smithy.go.codegen.SymbolUtils;
+import software.amazon.smithy.go.codegen.integration.ConfigField;
+import software.amazon.smithy.go.codegen.integration.GoIntegration;
+import software.amazon.smithy.go.codegen.integration.MiddlewareRegistrar;
+import software.amazon.smithy.go.codegen.integration.RuntimeClientPlugin;
+import software.amazon.smithy.model.Model;
+import software.amazon.smithy.model.knowledge.TopDownIndex;
+import software.amazon.smithy.model.shapes.ServiceShape;
+import software.amazon.smithy.model.traits.RequestCompressionTrait;
+import software.amazon.smithy.utils.ListUtils;
+import software.amazon.smithy.utils.MapUtils;
+
+
+public final class RequestCompression implements GoIntegration {
+    private static final String ADD_REQUEST_COMPRESSION = "addRequestCompression";
+
+    private static final String ADD_REQUEST_COMPRESSION_INTERNAL = "AddRequestCompression";
+
+    private static final String DISABLE_REQUEST_COMPRESSION = "DisableRequestCompression";
+
+    private static final String REQUEST_MIN_COMPRESSION_SIZE_BYTES = "RequestMinCompressSizeBytes";
+
+    @Override
+    public void writeAdditionalFiles(
+            GoSettings settings,
+            Model model,
+            SymbolProvider symbolProvider,
+            GoDelegator goDelegator
+    ) {
+        ServiceShape service = settings.getService(model);
+        if (!isRequestCompressionService(model, service)) {
+            return;
+        }
+
+        goDelegator.useShapeWriter(service, writeMiddlewareHelper());
+    }
+
+
+    public static boolean isRequestCompressionService(Model model, ServiceShape service) {
+        return TopDownIndex.of(model)
+                .getContainedOperations(service).stream()
+                .anyMatch(it -> it.hasTrait(RequestCompressionTrait.class));
+    }
+
+    private GoWriter.Writable writeMiddlewareHelper() {
+        var stackSymbol = SymbolUtils
+                .createPointableSymbolBuilder("Stack", SmithyGoDependency.SMITHY_MIDDLEWARE)
+                .build();
+        var addInternalSymbol = SymbolUtils
+                .createValueSymbolBuilder(ADD_REQUEST_COMPRESSION_INTERNAL,
+                SmithyGoDependency.SMITHY_REQUEST_COMPRESSION)
+                .build();
+        return goTemplate("""
+                func $add:L(stack $stack:P, options Options) error {
+                    return $addInternal:T(stack, options.DisableRequestCompression, options.RequestMinCompressSizeBytes)
+                }
+                """,
+                MapUtils.of(
+                        "add", ADD_REQUEST_COMPRESSION,
+                        "stack", stackSymbol,
+                        "addInternal", addInternalSymbol
+                ));
+    }
+
+    @Override
+    public List<RuntimeClientPlugin> getClientPlugins() {
+        return ListUtils.of(
+                RuntimeClientPlugin.builder()
+                        .operationPredicate((model, service, operation) ->
+                        operation.hasTrait(RequestCompressionTrait.class))
+                        .registerMiddleware(MiddlewareRegistrar.builder()
+                                .resolvedFunction(SymbolUtils.createValueSymbolBuilder(ADD_REQUEST_COMPRESSION).build())
+                                .useClientOptions()
+                                .build())
+                        .build(),
+                RuntimeClientPlugin.builder()
+                        .servicePredicate(RequestCompression::isRequestCompressionService)
+                        .configFields(ListUtils.of(
+                                ConfigField.builder()
+                                        .name(DISABLE_REQUEST_COMPRESSION)
+                                        .type(SymbolUtils.createValueSymbolBuilder("bool")
+                                                .putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true)
+                                                .build())
+                                        .documentation(
+                                        "Whether to disable automatic request compression for supported operations.")
+                                        .build(),
+                                ConfigField.builder()
+                                        .name(REQUEST_MIN_COMPRESSION_SIZE_BYTES)
+                                        .type(SymbolUtils.createValueSymbolBuilder("int64")
+                                                .putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true)
+                                                .build())
+                                        .documentation("Inclusive threshold request body size to trigger compression, "
+                                         + "default to 10240 and must be within 0 and 10485760 bytes inclusively")
+                                        .build()
+                        ))
+                        .build()
+        );
+    }
+}

codegen/smithy-go-codegen/src/main/resources/META-INF/services/software.amazon.smithy.go.codegen.integration.GoIntegration

@@ -9,3 +9,4 @@ software.amazon.smithy.go.codegen.integration.Paginators
 software.amazon.smithy.go.codegen.integration.Waiters
 software.amazon.smithy.go.codegen.integration.ClientLogger
 software.amazon.smithy.go.codegen.endpoints.EndpointClientPluginsGenerator
+software.amazon.smithy.go.codegen.requestcompression.RequestCompression

private/requestcompression/request_compression.go

@@ -0,0 +1,137 @@
+// Package requestcompression implements runtime support for smithy-modeled
+// request compression.
+//
+// This package is designated as private and is intended for use only by the
+// smithy client runtime. The exported API therein is not considered stable and
+// is subject to breaking changes without notice.
+package requestcompression
+
+import (
+	"bytes"
+	"compress/gzip"
+	"context"
+	"fmt"
+	"github.com/aws/smithy-go/middleware"
+	"github.com/aws/smithy-go/transport/http"
+	"io"
+)
+
+// Algorithm represents the request compression algorithms supported
+type Algorithm string
+
+const maxRequestMinCompressSizeBytes = 10485760
+
+// Enumeration values for supported compress Algorithms.
+const (
+	GZIP Algorithm = "gzip"
+)
+
+type compressFunc func(io.Reader) ([]byte, error)
+
+var allowedAlgorithms = map[Algorithm]compressFunc{
+	GZIP: gzipCompress,
+}
+
+// AddRequestCompression add requestCompression middleware to op stack
+func AddRequestCompression(stack *middleware.Stack, DisableRequestCompression bool, RequestMinCompressSizeBytes int64) error {
+	return stack.Serialize.Add(&requestCompression{
+		disableRequestCompression:   DisableRequestCompression,
+		requestMinCompressSizeBytes: RequestMinCompressSizeBytes,
+		compressAlgorithms:          []Algorithm{GZIP},
+	}, middleware.After)
+}
+
+type requestCompression struct {
+	disableRequestCompression   bool
+	requestMinCompressSizeBytes int64
+	compressAlgorithms          []Algorithm
+}
+
+// ID returns the ID of the middleware
+func (m requestCompression) ID() string {
+	return "RequestCompression"
+}
+
+// HandleSerialize gzip compress the request's stream/body if enabled by config fields
+func (m requestCompression) HandleSerialize(
+	ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler,
+) (
+	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
+) {
+	if m.disableRequestCompression {
+		return next.HandleSerialize(ctx, in)
+	}
+	// still need to check requestMinCompressSizeBytes in case it is out of range after service client config
+	if m.requestMinCompressSizeBytes < 0 || m.requestMinCompressSizeBytes > maxRequestMinCompressSizeBytes {
+		return out, metadata, fmt.Errorf("invalid range for min request compression size bytes %d, must be within 0 and 10485760 inclusively", m.requestMinCompressSizeBytes)
+	}
+
+	req, ok := in.Request.(*http.Request)
+	if !ok {
+		return out, metadata, fmt.Errorf("unknown request type %T", req)
+	}
+
+	for _, algorithm := range m.compressAlgorithms {
+		compressFunc := allowedAlgorithms[algorithm]
+		if compressFunc != nil {
+			if stream := req.GetStream(); stream != nil {
+				compressedBytes, err := compressFunc(stream)
+				if err != nil {
+					return out, metadata, fmt.Errorf("failed to compress request stream, %v", err)
+				}
+
+				var newReq *http.Request
+				if newReq, err = req.SetStream(bytes.NewReader(compressedBytes)); err != nil {
+					return out, metadata, fmt.Errorf("failed to set request stream, %v", err)
+				}
+				*req = *newReq
+			} else {
+				if req.Body == nil {
+					break
+				}
+				body, err := io.ReadAll(req.Body)
+				if err != nil {
+					return out, metadata, fmt.Errorf("failed to read request body")
+				}
+				if int64(len(body)) < m.requestMinCompressSizeBytes {
+					req.Body = io.NopCloser(bytes.NewReader(body))
+					break
+				}
+				compressedBytes, err := compressFunc(bytes.NewReader(body))
+				if err != nil {
+					return out, metadata, fmt.Errorf("failed to compress request body, %v", err)
+				}
+
+				req.Body = io.NopCloser(bytes.NewReader(compressedBytes))
+			}
+
+			req.Header.Add("Content-Encoding", "gzip")
+
+			break
+		}
+	}
+
+	return next.HandleSerialize(ctx, in)
+}
+
+func gzipCompress(input io.Reader) ([]byte, error) {
+	var b bytes.Buffer
+	w, err := gzip.NewWriterLevel(&b, gzip.DefaultCompression)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create gzip writer, %v", err)
+	}
+
+	inBytes, err := io.ReadAll(input)
+	if err != nil {
+		return nil, fmt.Errorf("failed read payload to compress, %v", err)
+	}
+
+	if _, err = w.Write(inBytes); err != nil {
+		return nil, fmt.Errorf("failed to write payload to be compressed, %v", err)
+	}
+	if err = w.Close(); err != nil {
+		return nil, fmt.Errorf("failed to flush payload being compressed, %v", err)
+	}
+
+	return b.Bytes(), nil
+}