Add Gzip request compression feature

.changelog/80ed28327bcd4301a264f318efaf8216.json

@@ -0,0 +1,8 @@
+{
+    "id": "80ed2832-7bcd-4301-a264-f318efaf8216",
+    "type": "feature",
+    "description": "Support modeled request compression.",
+    "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,128 @@
+/*
+ * 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 java.util.Set;
+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;
+        }
+
+        Set<String> algorithms = RequestCompressionTrait.SUPPORTED_COMPRESSION_ALGORITHMS;
+        goDelegator.useShapeWriter(service, writeMiddlewareHelper(algorithms));
+    }
+
+
+    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(Set<String> algorithms) {
+        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,
+                    $algorithms:L)
+                }
+                """,
+                MapUtils.of(
+                "add", ADD_REQUEST_COMPRESSION,
+                "stack", stackSymbol,
+                "addInternal", addInternalSymbol,
+                "algorithms", String.format("\"%s\"", String.join(",", algorithms))
+                ));
+    }
+
+    @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

@@ -8,6 +8,7 @@ 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
 
 # modeled auth schemes
 software.amazon.smithy.go.codegen.integration.auth.SigV4AuthScheme

private/requestcompression/request_compression.go

@@ -0,0 +1,122 @@
+// 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"
+	"strings"
+)
+
+const maxRequestMinCompressSizeBytes = 10485760
+
+// Enumeration values for supported compress Algorithms.
+const (
+	GZIP = "gzip"
+)
+
+type compressFunc func(io.Reader) ([]byte, error)
+
+var allowedAlgorithms = map[string]compressFunc{
+	GZIP: gzipCompress,
+}
+
+// AddRequestCompression add requestCompression middleware to op stack
+func AddRequestCompression(stack *middleware.Stack, DisableRequestCompression bool, RequestMinCompressSizeBytes int64, algorithms string) error {
+	return stack.Serialize.Add(&requestCompression{
+		disableRequestCompression:   DisableRequestCompression,
+		requestMinCompressSizeBytes: RequestMinCompressSizeBytes,
+		compressAlgorithms:          strings.Split(algorithms, ","),
+	}, middleware.After)
+}
+
+type requestCompression struct {
+	disableRequestCompression   bool
+	requestMinCompressSizeBytes int64
+	compressAlgorithms          []string
+}
+
+// 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 {
+				size, found, err := req.StreamLength()
+				if err != nil {
+					return out, metadata, fmt.Errorf("error while finding request stream length, %v", err)
+				} else if !found || size < m.requestMinCompressSizeBytes {
+					return next.HandleSerialize(ctx, in)
+				}
+
+				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
+				req.Header.Add("Content-Encoding", algorithm)
+			}
+			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
+}