Add Gzip request compression feature

[wty-Bryant]

Add Gzip request compression middleware and codegen logic in smithy go

[lucix-aws]

This needs a changelog entry, the tool we use works exactly as it does in the SDK.

[lucix-aws]

Don't we have to append if there's an existing header?

i.e. (pseudocode)

if (content-encoding exists on request)
    existing encoding header += ', algorithm'
else
    set header directly to algorithm

[lucix-aws]

There's no reason to microformat the list of algorithms like this, just generate it directly, e.g.

@requestCompression(
    encodings: ["gzip", "br"]
)

translates to list

[]string{"gzip", "br"}

[lucix-aws]

We have to generate this per-operation since the compression trait is applied there.

e.g. consider the following three modeled operations and their expected codegen:

@requestCompression{
    encodings: ["gzip"]
}
operation Foo {
  // ...
}
// should generate:
func addOperationFooRequestCompressionMiddleware(...) {
	return stack.Serialize.Add(&requestCompression{
                // ...
		compressAlgorithms: []string{"gzip"},
	}, middleware.After)
}
// and the operation stack setup should now include:
func (c *Client) addOperationFooMiddlewares(...) {
    // ...
    if err = addOperationFooRequestCompressionMiddleware(...); err != nil {
        return err
    }
    // ...
}

@requestCompression{
    encodings: ["br", "gzip"]
}
operation Bar {
  // ...
}
// should generate:
func addOperationBarRequestCompressionMiddleware(...) {
	return stack.Serialize.Add(&requestCompression{
                // ...
		compressAlgorithms: []string{"br", "gzip"},
	}, middleware.After)
}
// and the operation stack setup should now include:
func (c *Client) addOperationBarMiddlewares(...) {
    // ...
    if err = addOperationBarRequestCompressionMiddleware(...); err != nil {
        return err
    }
    // ...
}

// no request compression
operation Bar {
  // ...
}
// should not generate a middleware, and the operation stack setup shouldn't have anything new

See AwsHttpChecksumGenerator.java for an example of how this is done.

[wty-Bryant]

Okay I previously thought the SUPPORTED_COMPRESSION_ALGORITHMS of that trait is static so service level middleware is enough, but seems like we have multi-encodings for diff ops, I will change that

[lucix-aws]

lowercase the param names

[lucix-aws]

also it's in-context so e.g. DisableRequestCompression can become simply disabled etc

[wty-Bryant]

I agree, but I prefer to keep the naming in middleware fields in case of extra comment

[lucix-aws]

SmithyGoTypes was merged with the SRA auth refactor - you can convert wrote non-generated imports like this to SmithyGoTypes.Middleware.Stack etc.

(add static symbols to SmithyGoTypes as needed)

[lucix-aws]

SymbolUtils.buildPackageSymbol(funcName)

[lucix-aws]

SmithyGoTypes.Private.RequestCompression.AddRequestCompression (you'll have to create it)

[lucix-aws]

You're overcomplicating this - remember we can use $W to compose Writables in templates.

Something like the following:

private GoWriter.Writable generateAlgorithmList(List<String> algorithms) {
    return goTemplate("""
        []string{
            $W
        }
        """,
        GoWriter.ChainWritable.of( // compose a list of writables into a single one
            algorithms.stream()
                .map(it -> goTemplate("$S,", it))
                .toList()
        ).compose(false)); // compose(false) = don't write newlines between writables
}

then use that in the main template here:

$algorithms:W
// in your map
"algorithms", generateAlgorithmList(algorithms)

[lucix-aws]

This will be moot when you do the above but this substringing isn't necessary - gofmt handles the trailing comma in a single-line list

[lucix-aws]

GoUniverseTypes.bool?

[lucix-aws]

GoUniverseTypes.Int64?

[lucix-aws]

We prefer fmt.Sprintf for compositions like this:

fmt.Sprintf("%s, %s", val, algorithm)

[lucix-aws]

Minor but I'd give this it's own file in this package eg private/requestcompression/gzip.go

[syall]

Fix formatting for this line.

[wty-Bryant]

smithy go doesn't allow single line exceeding 120 chars, that's why there's a separate line

[syall]

Suggested change

	public static final GoDependency SMITHY_REQUEST_COMPRESSION =
	smithy("private/requestcompression", "smithyrequestcompression");
	public static final GoDependency SMITHY_REQUEST_COMPRESSION =
	smithy("private/requestcompression", "smithyrequestcompression");

[syall]

Keeping state in an integration is generally not best practice.

[syall]

nit overall: private fields should go below public fields, and private methods should go towards the bottom of the class below all the public methods.

[syall]

Use List.of() instead, and register all client plugins here immutably instead of using state.

[lucix-aws]

FYI he's doing this because of having to add per-operation middlewares elsewhere in processFinalizedModel. That's the only way I've ever seen it done unless there's something I'm not considering.

[lucix-aws]

getClientPlugins should probably accept the Model and service shape ID much like these other functions do long-term.

[wty-Bryant]

we have confirmed that in resolved comments, thx for clarification

[syall]

nit: remove extra line