index int64 0 0 | repo_id stringlengths 9 205 | file_path stringlengths 31 246 | content stringlengths 1 12.2M | __index_level_0__ int64 0 10k |
|---|---|---|---|---|
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AddAwsConfigFields.java | /*
* 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.aws.go.codegen;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.function.BiPredicate;
import java.util.logging.Logger;
import software.amazon.smithy.codegen.core.Symbol;
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.ConfigFieldResolver;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.go.codegen.integration.RuntimeClientPlugin;
import software.amazon.smithy.go.codegen.integration.auth.HttpBearerAuth;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.utils.ListUtils;
/**
* Registers additional AWS specific client configuration fields
*/
public class AddAwsConfigFields implements GoIntegration {
private static final Logger LOGGER = Logger.getLogger(AddAwsConfigFields.class.getName());
public static final String REGION_CONFIG_NAME = "Region";
public static final String CREDENTIALS_CONFIG_NAME = "Credentials";
public static final String BEARER_AUTH_TOKEN_CONFIG_NAME = "TokenProvider";
public static final String ENDPOINT_RESOLVER_CONFIG_NAME = "EndpointResolver";
public static final String AWS_ENDPOINT_RESOLVER_WITH_OPTIONS = "EndpointResolverWithOptions";
public static final String HTTP_CLIENT_CONFIG_NAME = "HTTPClient";
public static final String RETRY_MAX_ATTEMPTS_CONFIG_NAME = "RetryMaxAttempts";
public static final String RETRY_MODE_CONFIG_NAME = "RetryMode";
public static final String RETRYER_CONFIG_NAME = "Retryer";
public static final String API_OPTIONS_CONFIG_NAME = "APIOptions";
public static final String LOGGER_CONFIG_NAME = "Logger";
public static final String LOG_MODE_CONFIG_NAME = "ClientLogMode";
public static final String DEFAULTS_MODE_CONFIG_NAME = "DefaultsMode";
public static final String RUNTIME_ENVIRONMENT_CONFIG_NAME = "RuntimeEnvironment";
private static final String RESOLVE_HTTP_CLIENT = "resolveHTTPClient";
private static final String RESOLVE_RETRYER = "resolveRetryer";
private static final String RESOLVE_AWS_CONFIG_ENDPOINT_RESOLVER = "resolveAWSEndpointResolver";
private static final String RESOLVE_AWS_CONFIG_RETRY_MAX_ATTEMPTS = "resolveAWSRetryMaxAttempts";
private static final String RESOLVE_AWS_CONFIG_RETRY_MODE = "resolveAWSRetryMode";
private static final String RESOLVE_AWS_CONFIG_RETRYER_PROVIDER = "resolveAWSRetryerProvider";
private static final String FINALIZE_RETRY_MAX_ATTEMPTS_OPTIONS = "finalizeRetryMaxAttemptOptions";
private static final String SDK_APP_ID = "AppID";
private static final List<AwsConfigField> AWS_CONFIG_FIELDS = ListUtils.of(
AwsConfigField.builder()
.name(REGION_CONFIG_NAME)
.type(getUniversalSymbol("string"))
.documentation("The region to send requests to. (Required)")
.build(),
AwsConfigField.builder()
.name(DEFAULTS_MODE_CONFIG_NAME)
.type(getAwsCoreSymbol("DefaultsMode"))
.documentation("""
The configuration DefaultsMode that the SDK should use when constructing
the clients initial default settings.
""")
.build(),
AwsConfigField.builder()
.name(RUNTIME_ENVIRONMENT_CONFIG_NAME)
.type(getAwsCoreSymbol("RuntimeEnvironment"))
.documentation("""
The RuntimeEnvironment configuration, only populated if the DefaultsMode is set to
DefaultsModeAuto and is initialized using `config.LoadDefaultConfig`. You should not
populate this structure programmatically, or rely on the values here within your
applications.
""")
.build(),
AwsConfigField.builder()
.name(RETRYER_CONFIG_NAME)
.type(getAwsCoreSymbol("Retryer"))
.documentation("""
Retryer guides how HTTP requests should be retried in case of recoverable failures.
When nil the API client will use a default retryer. The kind of default retry created
by the API client can be changed with the RetryMode option.
""")
.addConfigFieldResolvers(getClientInitializationResolver(
SymbolUtils.createValueSymbolBuilder(RESOLVE_RETRYER).build())
.build()
)
.awsResolveFunction(SymbolUtils.createValueSymbolBuilder(RESOLVE_AWS_CONFIG_RETRYER_PROVIDER)
.build())
.build(),
AwsConfigField.builder()
.name(RETRY_MAX_ATTEMPTS_CONFIG_NAME)
.type(getUniversalSymbol("int"))
.documentation("""
RetryMaxAttempts specifies the maximum number attempts an API client
will call an operation that fails with a retryable error. A value of 0 is ignored,
and will not be used to configure the API client created default retryer, or modify
per operation call's retry max attempts.
When creating a new API Clients this member will only be used if the
Retryer Options member is nil. This value will be ignored if
Retryer is not nil.
If specified in an operation call's functional options with a value that
is different than the constructed client's Options, the Client's Retryer
will be wrapped to use the operation's specific RetryMaxAttempts value.
""")
.awsResolveFunction(SymbolUtils.createValueSymbolBuilder(RESOLVE_AWS_CONFIG_RETRY_MAX_ATTEMPTS)
.build())
.addConfigFieldResolvers(ConfigFieldResolver.builder()
.location(ConfigFieldResolver.Location.OPERATION)
.target(ConfigFieldResolver.Target.FINALIZATION)
.withClientInput(true)
.resolver(SymbolUtils.createValueSymbolBuilder(
FINALIZE_RETRY_MAX_ATTEMPTS_OPTIONS).build())
.build())
.build(),
AwsConfigField.builder()
.name(RETRY_MODE_CONFIG_NAME)
.type(getAwsCoreSymbol("RetryMode"))
.documentation("""
RetryMode specifies the retry mode the API client will be created with,
if Retryer option is not also specified.
When creating a new API Clients this member will only be used if the
Retryer Options member is nil. This value will be ignored if
Retryer is not nil.
Currently does not support per operation call overrides, may in the future.
""")
.awsResolveFunction(SymbolUtils.createValueSymbolBuilder(RESOLVE_AWS_CONFIG_RETRY_MODE)
.build())
.build(),
AwsConfigField.builder()
.name(HTTP_CLIENT_CONFIG_NAME)
.type(SymbolUtils.createValueSymbolBuilder("HTTPClient").build())
.generatedOnClient(false)
.addConfigFieldResolvers(getClientInitializationResolver(
SymbolUtils.createValueSymbolBuilder(RESOLVE_HTTP_CLIENT).build())
.build())
.build(),
AwsConfigField.builder()
.name(CREDENTIALS_CONFIG_NAME)
.type(getAwsCoreSymbol("CredentialsProvider"))
.documentation("The credentials object to use when signing requests.")
.servicePredicate(AwsSignatureVersion4::isSupportedAuthentication)
.build(),
AwsConfigField.builder()
// TOKEN_PROVIDER_OPTION_NAME added API Client's Options by HttpBearerAuth. Only
// need to add NewFromConfig resolver from aws#Config type.
.name(HttpBearerAuth.TOKEN_PROVIDER_OPTION_NAME)
.type(SymbolUtils.createValueSymbolBuilder("TokenProvider",
SmithyGoDependency.SMITHY_AUTH_BEARER).build())
.documentation("The bearer authentication token provider for authentication requests.")
.servicePredicate(HttpBearerAuth::isSupportedAuthentication)
.generatedOnClient(false)
.build(),
AwsConfigField.builder()
.name(API_OPTIONS_CONFIG_NAME)
.type(SymbolUtils.createValueSymbolBuilder("[]func(*middleware.Stack) error")
.addDependency(SmithyGoDependency.SMITHY_MIDDLEWARE).build())
.documentation("API stack mutators")
.generatedOnClient(false)
.build(),
AwsConfigField.builder()
.name(ENDPOINT_RESOLVER_CONFIG_NAME)
.type(getAwsCoreSymbol("EndpointResolver"))
.generatedOnClient(false)
.awsResolveFunction(SymbolUtils.createValueSymbolBuilder(RESOLVE_AWS_CONFIG_ENDPOINT_RESOLVER)
.build())
.build(),
AwsConfigField.builder()
.name(LOGGER_CONFIG_NAME)
.type(getAwsCoreSymbol("Logger"))
.generatedOnClient(false)
.build(),
AwsConfigField.builder()
.name(LOG_MODE_CONFIG_NAME)
.type(getAwsCoreSymbol("ClientLogMode"))
.documentation("Configures the events that will be sent to the configured logger.")
.build(),
AwsConfigField.builder()
.name(SDK_APP_ID)
.type(getUniversalSymbol("string"))
.documentation("The optional application specific identifier appended to the User-Agent header.")
.generatedOnClient(false)
.build()
);
private static Symbol getAwsCoreSymbol(String symbolName) {
return SymbolUtils.createValueSymbolBuilder(symbolName,
AwsGoDependency.AWS_CORE).build();
}
private static Symbol getAwsSignerV4Symbol(String symbolName) {
return SymbolUtils.createValueSymbolBuilder(symbolName,
AwsGoDependency.AWS_SIGNER_V4).build();
}
private static Symbol getUniversalSymbol(String symbolName) {
return SymbolUtils.createValueSymbolBuilder(symbolName)
.putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true).build();
}
private static Symbol getAwsRetrySymbol(String symbolName) {
return SymbolUtils.createValueSymbolBuilder(symbolName,
AwsGoDependency.AWS_RETRY).build();
}
/**
* Gets the sort order of the customization from -128 to 127, with lowest
* executed first.
*
* @return Returns the sort order, defaults to -50.
*/
@Override
public byte getOrder() {
return -50;
}
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
LOGGER.info("generating aws.Config based client constructor");
ServiceShape serviceShape = settings.getService(model);
goDelegator.useShapeWriter(serviceShape, w -> {
writeAwsConfigConstructor(model, serviceShape, w);
writeAwsDefaultResolvers(w);
});
goDelegator.useShapeTestWriter(serviceShape, w -> {
writerAwsDefaultResolversTests(w);
});
}
private static ConfigFieldResolver.Builder getClientInitializationResolver(Symbol resolver) {
return ConfigFieldResolver.builder()
.location(ConfigFieldResolver.Location.CLIENT)
.target(ConfigFieldResolver.Target.INITIALIZATION)
.resolver(resolver);
}
private void writeAwsDefaultResolvers(GoWriter writer) {
writeHttpClientResolver(writer);
writeRetryerResolvers(writer);
writeRetryMaxAttemptsFinalizeResolver(writer);
writeAwsConfigEndpointResolver(writer);
}
private void writerAwsDefaultResolversTests(GoWriter writer) {
writeRetryResolverTests(writer);
}
private void writeRetryerResolvers(GoWriter writer) {
writer.pushState();
writer.putContext("resolvedDefaultsMode",
ClientResolvedDefaultsMode.RESOLVED_DEFAULTS_MODE_CONFIG_NAME);
writer.putContext("getConfig", SymbolUtils.createValueSymbolBuilder("GetModeConfiguration",
AwsGoDependency.AWS_DEFAULTS).build());
writer.putContext("resolverName", RESOLVE_RETRYER);
writer.putContext("retryerOption", RETRYER_CONFIG_NAME);
writer.putContext("retryModeOption", RETRY_MODE_CONFIG_NAME);
writer.putContext("retryMaxAttemptsOption", RETRY_MAX_ATTEMPTS_CONFIG_NAME);
writer.putContext("retryerResolveAwsConfig", RESOLVE_AWS_CONFIG_RETRYER_PROVIDER);
writer.putContext("retryModeResolveAwsConfig", RESOLVE_AWS_CONFIG_RETRY_MODE);
writer.putContext("retryMaxAttemptsResolveAwsConfig", RESOLVE_AWS_CONFIG_RETRY_MAX_ATTEMPTS);
writer.putContext("retryModeAdaptive", getAwsCoreSymbol("RetryModeAdaptive"));
writer.putContext("retryModeStandard", getAwsCoreSymbol("RetryModeStandard"));
writer.putContext("newStandard", SymbolUtils.createValueSymbolBuilder("NewStandard",
AwsGoDependency.AWS_RETRY).build());
writer.putContext("standardOptions", SymbolUtils.createPointableSymbolBuilder("StandardOptions",
AwsGoDependency.AWS_RETRY).build());
writer.putContext("newAdaptiveMode", SymbolUtils.createPointableSymbolBuilder("NewAdaptiveMode",
AwsGoDependency.AWS_RETRY).build());
writer.putContext("adaptiveModeOptions", SymbolUtils.createValueSymbolBuilder("AdaptiveModeOptions",
AwsGoDependency.AWS_RETRY).build());
writer.write("""
func $resolverName:L(o *Options) {
if o.$retryerOption:L != nil {
return
}
if len(o.$retryModeOption:L) == 0 {
modeConfig, err := $getConfig:T(o.$resolvedDefaultsMode:L)
if err == nil {
o.$retryModeOption:L = modeConfig.RetryMode
}
}
if len(o.$retryModeOption:L) == 0 {
o.$retryModeOption:L = $retryModeStandard:T
}
var standardOptions []func(*$standardOptions:T)
if v := o.$retryMaxAttemptsOption:L; v != 0 {
standardOptions = append(standardOptions, func(so *$standardOptions:T) {
so.MaxAttempts = v
})
}
switch o.$retryModeOption:L {
case $retryModeAdaptive:T:
var adaptiveOptions []func(*$adaptiveModeOptions:T)
if len(standardOptions) != 0 {
adaptiveOptions = append(adaptiveOptions, func(ao *$adaptiveModeOptions:T) {
ao.StandardOptions = append(ao.StandardOptions, standardOptions...)
})
}
o.$retryerOption:L = $newAdaptiveMode:T(adaptiveOptions...)
default:
o.$retryerOption:L = $newStandard:T(standardOptions...)
}
}
func $retryerResolveAwsConfig:L(cfg aws.Config, o *Options) {
if cfg.$retryerOption:L == nil {
return
}
o.$retryerOption:L = cfg.$retryerOption:L()
}
func $retryModeResolveAwsConfig:L(cfg aws.Config, o *Options) {
if len(cfg.$retryModeOption:L) == 0 {
return
}
o.$retryModeOption:L = cfg.$retryModeOption:L
}
func $retryMaxAttemptsResolveAwsConfig:L(cfg aws.Config, o *Options) {
if cfg.$retryMaxAttemptsOption:L == 0 {
return
}
o.$retryMaxAttemptsOption:L = cfg.$retryMaxAttemptsOption:L
}
""");
writer.popState();
}
private void writeRetryMaxAttemptsFinalizeResolver(GoWriter writer) {
writer.pushState();
writer.putContext("finalizeResolveName", FINALIZE_RETRY_MAX_ATTEMPTS_OPTIONS);
writer.putContext("withMaxAttempts", SymbolUtils.createValueSymbolBuilder("AddWithMaxAttempts",
AwsGoDependency.AWS_RETRY).build());
writer.write("""
func $finalizeResolveName:L(o *Options, client Client) {
if v := o.RetryMaxAttempts; v == 0 || v == client.options.RetryMaxAttempts {
return
}
o.Retryer = $withMaxAttempts:T(o.Retryer, o.RetryMaxAttempts)
}
""");
writer.popState();
}
private void writeRetryResolverTests(GoWriter writer) {
writer.pushState();
writer.putContext("retryModeOptions", "Client_resolveRetryOptions");
writer.putContext("retryerType", getAwsCoreSymbol("Retryer"));
writer.putContext("retryModeType", getAwsCoreSymbol("RetryMode"));
writer.putContext("retryModeStandard", getAwsCoreSymbol("RetryModeStandard"));
writer.putContext("retryModeAdaptive", getAwsCoreSymbol("RetryModeAdaptive"));
writer.putContext("defaultsModeType", getAwsCoreSymbol("DefaultsMode"));
writer.putContext("defaultsModeStandard", getAwsCoreSymbol("DefaultsModeStandard"));
writer.putContext("ctxBackground", SymbolUtils.createValueSymbolBuilder("Background",
SmithyGoDependency.CONTEXT).build());
writer.putContext("stack", SymbolUtils.createValueSymbolBuilder("Stack",
SmithyGoDependency.SMITHY_MIDDLEWARE).build());
writer.putContext("smithyClientDoFunc", SymbolUtils.createValueSymbolBuilder("ClientDoFunc",
SmithyGoDependency.SMITHY_HTTP_TRANSPORT).build());
writer.putContext("httpRequest", SymbolUtils.createValueSymbolBuilder("Request",
SmithyGoDependency.NET_HTTP).build());
writer.putContext("httpResponse", SymbolUtils.createValueSymbolBuilder("Response",
SmithyGoDependency.NET_HTTP).build());
writer.putContext("httpHeader", SymbolUtils.createValueSymbolBuilder("Header",
SmithyGoDependency.NET_HTTP).build());
writer.putContext("newStringReader", SymbolUtils.createValueSymbolBuilder("NewReader",
SmithyGoDependency.STRINGS).build());
writer.putContext("nopCloser", SymbolUtils.createValueSymbolBuilder("NopCloser",
SmithyGoDependency.IOUTIL).build());
writer.addUseImports(SmithyGoDependency.TESTING);
writer.write("""
func Test$retryModeOptions:L(t *testing.T) {
nopClient := $smithyClientDoFunc:T(func(_ *$httpRequest:T) (*$httpResponse:T, error) {
return &$httpResponse:T{
StatusCode: 200,
Header: $httpHeader:T{},
Body: $nopCloser:T($newStringReader:T("")),
}, nil
})
cases := map[string]struct{
defaultsMode $defaultsModeType:T
retryer $retryerType:T
retryMaxAttempts int
opRetryMaxAttempts *int
retryMode $retryModeType:T
expectClientRetryMode $retryModeType:T
expectClientMaxAttempts int
expectOpMaxAttempts int
}{
"defaults": {
defaultsMode: $defaultsModeStandard:T,
expectClientRetryMode: $retryModeStandard:T,
expectClientMaxAttempts: 3,
expectOpMaxAttempts: 3,
},
"custom default retry": {
retryMode: $retryModeAdaptive:T,
retryMaxAttempts: 10,
expectClientRetryMode: $retryModeAdaptive:T,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op max attempts": {
retryMode: $retryModeAdaptive:T,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(2),
expectClientRetryMode: $retryModeAdaptive:T,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 2,
},
"custom op no change max attempts": {
retryMode: $retryModeAdaptive:T,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(10),
expectClientRetryMode: $retryModeAdaptive:T,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op 0 max attempts": {
retryMode: $retryModeAdaptive:T,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(0),
expectClientRetryMode: $retryModeAdaptive:T,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
client := NewFromConfig(aws.Config{
DefaultsMode: c.defaultsMode,
Retryer: func() func() $retryerType:T {
if c.retryer == nil { return nil }
return func() $retryerType:T { return c.retryer }
}(),
HTTPClient: nopClient,
RetryMaxAttempts: c.retryMaxAttempts,
RetryMode: c.retryMode,
})
if e, a := c.expectClientRetryMode, client.options.RetryMode; e != a {
t.Errorf("expect %v retry mode, got %v", e, a)
}
if e, a := c.expectClientMaxAttempts, client.options.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v max attempts, got %v", e, a)
}
_, _, err := client.invokeOperation($ctxBackground:T(), "mockOperation", struct{}{},
[]func(*Options){
func(o *Options) {
if c.opRetryMaxAttempts == nil {
return
}
o.RetryMaxAttempts = *c.opRetryMaxAttempts
},
},
func(s *$stack:T, o Options) error {
s.Initialize.Clear()
s.Serialize.Clear()
s.Build.Clear()
s.Finalize.Clear()
s.Deserialize.Clear()
if e, a := c.expectOpMaxAttempts, o.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v op max attempts, got %v", e, a)
}
return nil
})
if err != nil {
t.Fatalf("expect no operation error, got %v", err)
}
})
}
}
""");
writer.popState();
}
private void writeHttpClientResolver(GoWriter writer) {
writer.pushState();
writer.putContext("resolverName", RESOLVE_HTTP_CLIENT);
writer.putContext("resolvedDefaultsMode", ClientResolvedDefaultsMode.RESOLVED_DEFAULTS_MODE_CONFIG_NAME);
writer.putContext("optionName", HTTP_CLIENT_CONFIG_NAME);
writer.putContext("newClient", SymbolUtils.createValueSymbolBuilder("NewBuildableClient",
AwsGoDependency.AWS_HTTP_TRANSPORT).build());
writer.putContext("buildableType", SymbolUtils.createPointableSymbolBuilder("BuildableClient",
AwsGoDependency.AWS_HTTP_TRANSPORT).build());
writer.putContext("legacyModeType", SymbolUtils.createValueSymbolBuilder("DefaultsModeLegacy",
AwsGoDependency.AWS_CORE).build());
writer.putContext("getConfig", SymbolUtils.createValueSymbolBuilder("GetModeConfiguration",
AwsGoDependency.AWS_DEFAULTS).build());
writer.putContext("dialer", SymbolUtils.createPointableSymbolBuilder("Dialer",
SmithyGoDependency.NET).build());
writer.putContext("transport", SymbolUtils.createPointableSymbolBuilder("Transport",
SmithyGoDependency.NET_HTTP).build());
writer.putContext("errorf", SymbolUtils.createPointableSymbolBuilder("Errorf",
SmithyGoDependency.FMT).build());
writer.write("""
func $resolverName:L(o *Options) {
var buildable $buildableType:P
if o.$optionName:L != nil {
var ok bool
buildable, ok = o.$optionName:L.($buildableType:P)
if !ok {
return
}
} else {
buildable = $newClient:T()
}
modeConfig, err := $getConfig:T(o.$resolvedDefaultsMode:L)
if err == nil {
buildable = buildable.WithDialerOptions(func(dialer $dialer:P) {
if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok {
dialer.Timeout = dialerTimeout
}
})
buildable = buildable.WithTransportOptions(func(transport $transport:P) {
if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok {
transport.TLSHandshakeTimeout = tlsHandshakeTimeout
}
})
}
o.$optionName:L = buildable
}
""");
writer.popState();
}
private void writeAwsConfigEndpointResolver(GoWriter writer) {
writer.pushState();
writer.putContext("resolverName", RESOLVE_AWS_CONFIG_ENDPOINT_RESOLVER);
writer.putContext("clientOption", ENDPOINT_RESOLVER_CONFIG_NAME);
writer.putContext("wrapperHelper", EndpointGenerator.AWS_ENDPOINT_RESOLVER_HELPER);
writer.putContext("awsResolver", ENDPOINT_RESOLVER_CONFIG_NAME);
writer.putContext("awsResolverWithOptions", AWS_ENDPOINT_RESOLVER_WITH_OPTIONS);
writer.write("""
func $resolverName:L(cfg aws.Config, o *Options) {
if cfg.$awsResolver:L == nil && cfg.$awsResolverWithOptions:L == nil {
return
}
o.$clientOption:L = $wrapperHelper:L(cfg.$awsResolver:L, cfg.$awsResolverWithOptions:L)
}
""");
writer.popState();
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
List<RuntimeClientPlugin> plugins = new ArrayList<>();
AWS_CONFIG_FIELDS.forEach(awsConfigField -> {
RuntimeClientPlugin.Builder builder = RuntimeClientPlugin.builder();
awsConfigField.getServicePredicate().ifPresent(
builder::servicePredicate);
if (awsConfigField.isGeneratedOnClient()) {
builder.addConfigField(awsConfigField);
}
builder.configFieldResolvers(awsConfigField.getConfigFieldResolvers());
plugins.add(builder.build());
});
return plugins;
}
private void writeAwsConfigConstructor(Model model, ServiceShape service, GoWriter writer) {
writer.writeDocs("NewFromConfig returns a new client from the provided config.");
writer.openBlock("func NewFromConfig(cfg $T, optFns ... func(*Options)) *Client {", "}",
getAwsCoreSymbol("Config"), () -> {
writer.openBlock("opts := Options{", "}", () -> {
for (AwsConfigField field : AWS_CONFIG_FIELDS) {
if (field.getServicePredicate().isPresent()) {
if (!field.getServicePredicate().get().test(model, service)) {
continue;
}
}
if (field.getAwsResolverFunction().isPresent()) {
continue;
}
writer.write("$L: cfg.$L,", field.getName(), field.getName());
}
});
List<AwsConfigField> configFields = new ArrayList<>(AWS_CONFIG_FIELDS);
// add client specific config fields
for (AwsConfigField cfgField : ResolveClientConfigFromSources.AWS_CONFIG_FIELDS) {
configFields.add(cfgField);
}
for (AwsConfigField field : configFields) {
Optional<Symbol> awsResolverFunction = field.getAwsResolverFunction();
if (!awsResolverFunction.isPresent()) {
continue;
}
if (field.getServicePredicate().isPresent()) {
if (!field.getServicePredicate().get().test(model, service)) {
continue;
}
}
writer.write("$L(cfg, &opts)", awsResolverFunction.get());
}
writer.write("return New(opts, optFns...)");
});
writer.write("");
}
/**
* Provides configuration field for AWS client.
*/
public static class AwsConfigField extends ConfigField {
private final boolean generatedOnClient;
private final BiPredicate<Model, ServiceShape> servicePredicate;
private final Set<ConfigFieldResolver> configFieldResolvers;
private final Symbol awsResolveFunction;
private AwsConfigField(Builder builder) {
super(builder);
this.generatedOnClient = builder.generatedOnClient;
this.servicePredicate = builder.servicePredicate;
this.configFieldResolvers = builder.configFieldResolvers;
this.awsResolveFunction = builder.awsResolveFunction;
}
public boolean isGeneratedOnClient() {
return generatedOnClient;
}
public Optional<BiPredicate<Model, ServiceShape>> getServicePredicate() {
return Optional.ofNullable(servicePredicate);
}
public Set<ConfigFieldResolver> getConfigFieldResolvers() {
return this.configFieldResolvers;
}
public Optional<Symbol> getAwsResolverFunction() {
return Optional.ofNullable(awsResolveFunction);
}
public static Builder builder() {
return new Builder();
}
/**
* Provides builder for AWSConfigFile values.
*/
public static class Builder extends ConfigField.Builder {
private boolean generatedOnClient = true;
private BiPredicate<Model, ServiceShape> servicePredicate = null;
private Set<ConfigFieldResolver> configFieldResolvers = new HashSet<>();
private Symbol awsResolveFunction = null;
private Builder() {
super();
}
/**
* This sets the Config field on Client Options structure. By default this is true.
* If set to false, this field won't be generated on the Client options, but will be used by
* the NewFromConfig (to copy values from the aws config to client options).
*
* @param generatedOnClient bool indicating config field generation on client option structure
* @return
*/
public Builder generatedOnClient(boolean generatedOnClient) {
this.generatedOnClient = generatedOnClient;
return this;
}
public Builder servicePredicate(BiPredicate<Model, ServiceShape> servicePredicate) {
this.servicePredicate = servicePredicate;
return this;
}
public Builder configFieldResolvers(Collection<ConfigFieldResolver> configFieldResolvers) {
this.configFieldResolvers = new HashSet<>(configFieldResolvers);
return this;
}
public Builder addConfigFieldResolvers(ConfigFieldResolver configFieldResolver) {
this.configFieldResolvers.add(configFieldResolver);
return this;
}
public Builder awsResolveFunction(Symbol awsResolveFunction) {
this.awsResolveFunction = awsResolveFunction;
return this;
}
@Override
public AwsConfigField build() {
return new AwsConfigField(this);
}
@Override
public Builder name(String name) {
super.name(name);
return this;
}
@Override
public Builder type(Symbol type) {
super.type(type);
return this;
}
@Override
public Builder documentation(String documentation) {
super.documentation(documentation);
return this;
}
@Override
public Builder withHelper(Boolean withHelper) {
super.withHelper(withHelper);
return this;
}
@Override
public Builder withHelper() {
super.withHelper();
return this;
}
}
}
}
| 8,300 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsQuery.java | package software.amazon.smithy.aws.go.codegen;
import static software.amazon.smithy.go.codegen.integration.HttpProtocolGeneratorUtils.isShapeWithResponseBindings;
import static software.amazon.smithy.aws.go.codegen.AwsProtocolUtils.handleDecodeError;
import static software.amazon.smithy.aws.go.codegen.XmlProtocolUtils.initializeXmlDecoder;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.TreeMap;
import software.amazon.smithy.aws.traits.protocols.AwsQueryErrorTrait;
import software.amazon.smithy.aws.traits.protocols.AwsQueryTrait;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.codegen.core.Symbol;
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.HttpRpcProtocolGenerator;
import software.amazon.smithy.go.codegen.integration.ProtocolGenerator;
import software.amazon.smithy.go.codegen.integration.ProtocolUtils;
import software.amazon.smithy.model.knowledge.EventStreamInfo;
import software.amazon.smithy.model.knowledge.HttpBinding;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.model.shapes.UnionShape;
import software.amazon.smithy.model.traits.ErrorTrait;
import software.amazon.smithy.go.codegen.endpoints.EndpointResolutionGenerator;
import software.amazon.smithy.go.codegen.endpoints.FnGenerator;
/**
* Handles generating the aws query protocol for services.
*
* @inheritDoc
* @see HttpRpcProtocolGenerator
*/
class AwsQuery extends HttpRpcProtocolGenerator {
@Override
public ShapeId getProtocol() {
return AwsQueryTrait.ID;
}
@Override
protected String getOperationPath(GenerationContext context, OperationShape operation) {
return "/";
}
@Override
protected String getDocumentContentType() {
return "application/x-www-form-urlencoded";
}
@Override
protected void generateDocumentBodyShapeSerializers(GenerationContext context, Set<Shape> shapes) {
QueryShapeSerVisitor visitor = new QueryShapeSerVisitor(context);
shapes.forEach(shape -> shape.accept(visitor));
}
@Override
protected void serializeInputDocument(GenerationContext context, OperationShape operation) {
GoWriter writer = context.getWriter().get();
ServiceShape service = context.getService();
StructureShape input = ProtocolUtils.expectInput(context.getModel(), operation);
String functionName = ProtocolGenerator.getDocumentSerializerFunctionName(
input, context.getService(), getProtocolName());
writer.addUseImports(AwsGoDependency.AWS_QUERY_PROTOCOL);
writer.addUseImports(SmithyGoDependency.BYTES);
writer.write("bodyWriter := bytes.NewBuffer(nil)");
writer.write("bodyEncoder := query.NewEncoder(bodyWriter)");
writer.write("body := bodyEncoder.Object()");
writer.write("body.Key(\"Action\").String($S)", operation.getId().getName(service));
writer.write("body.Key(\"Version\").String($S)", service.getVersion());
writer.write("");
if (!input.members().isEmpty()) {
writer.openBlock("if err := $L(input, bodyEncoder.Value); err != nil {", "}", functionName, () -> {
writer.write("return out, metadata, &smithy.SerializationError{Err: err}");
}).write("");
}
writer.write("err = bodyEncoder.Encode()");
writer.openBlock("if err != nil {", "}", () -> {
writer.write("return out, metadata, &smithy.SerializationError{Err: err}");
}).write("");
writer.openBlock("if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {",
"}", () -> {
writer.write("return out, metadata, &smithy.SerializationError{Err: err}");
});
}
@Override
protected void generateDocumentBodyShapeDeserializers(GenerationContext context, Set<Shape> shapes) {
XmlShapeDeserVisitor visitor = new XmlShapeDeserVisitor(context);
shapes.forEach(shape -> shape.accept(visitor));
}
@Override
protected void deserializeOutputDocument(GenerationContext context, OperationShape operation) {
GoWriter writer = context.getWriter().get();
StructureShape output = ProtocolUtils.expectOutput(context.getModel(), operation);
String functionName = ProtocolGenerator.getDocumentDeserializerFunctionName(
output, context.getService(), getProtocolName());
initializeXmlDecoder(writer, "response.Body", "out, metadata, ", "nil");
unwrapOutputDocument(context, operation);
writer.write("err = $L(&output, decoder)", functionName);
handleDecodeError(writer, "out, metadata, ");
}
@Override
protected void deserializeError(GenerationContext context, StructureShape shape) {
GoWriter writer = context.getWriter().get();
Symbol symbol = context.getSymbolProvider().toSymbol(shape);
writer.write("output := &$T{}", symbol);
writer.insertTrailingNewline();
if (isShapeWithResponseBindings(context.getModel(), shape, HttpBinding.Location.DOCUMENT)) {
String functionName = ProtocolGenerator.getDocumentDeserializerFunctionName(
shape, context.getService(), context.getProtocolName());
writer.addUseImports(SmithyGoDependency.IO);
initializeXmlDecoder(writer, "errorBody", "output");
unwrapErrorElement(context);
writer.write("err = $L(&output, decoder)", functionName);
XmlProtocolUtils.handleDecodeError(writer, "");
writer.insertTrailingNewline();
}
writer.write("return output");
}
protected void unwrapOutputDocument(GenerationContext context, OperationShape shape) {
GoWriter writer = context.getWriter().get();
ServiceShape service = context.getService();
writer.write("t, err = decoder.GetElement(\"$LResult\")", shape.getId().getName(service));
handleDecodeError(writer, "out, metadata, ");
Symbol wrapNodeDecoder = SymbolUtils.createValueSymbolBuilder("WrapNodeDecoder",
SmithyGoDependency.SMITHY_XML).build();
writer.write("decoder = $T(decoder.Decoder, t)", wrapNodeDecoder);
}
protected void unwrapErrorElement(GenerationContext context) {
GoWriter writer = context.getWriter().get();
writer.write("t, err = decoder.GetElement(\"Error\")");
XmlProtocolUtils.handleDecodeError(writer, "");
Symbol wrapNodeDecoder = SymbolUtils.createValueSymbolBuilder("WrapNodeDecoder",
SmithyGoDependency.SMITHY_XML).build();
writer.write("decoder = $T(decoder.Decoder, t)", wrapNodeDecoder);
}
@Override
protected void writeErrorMessageCodeDeserializer(GenerationContext context) {
XmlProtocolUtils.writeXmlErrorMessageCodeDeserializer(context);
}
@Override
public void generateProtocolTests(GenerationContext context) {
AwsProtocolUtils.generateHttpProtocolTests(context);
}
@Override
public Map<String, ShapeId> getOperationErrors(GenerationContext context, OperationShape operation) {
Map<String, ShapeId> errors = new TreeMap<>();
operation.getErrors().forEach(shapeId -> {
Shape errorShape = context.getModel().expectShape(shapeId);
String errorName = shapeId.getName(context.getService());
Optional<AwsQueryErrorTrait> errorShapeTrait = errorShape.getTrait(AwsQueryErrorTrait.class);
if (errorShapeTrait.isPresent()) {
errors.put(errorShapeTrait.get().getCode(), shapeId);
} else {
errors.put(errorName, shapeId);
}
});
return errors;
}
@Override
public String getErrorCode(ServiceShape service, StructureShape errorShape) {
Optional<AwsQueryErrorTrait> trait = errorShape.getTrait(AwsQueryErrorTrait.class);
if (trait.isPresent()) {
return trait.get().getCode();
}
return super.getErrorCode(service, errorShape);
}
@Override
protected void generateEventStreamSerializers(
GenerationContext context,
UnionShape eventUnion,
Set<EventStreamInfo> eventStreamInfos) {
throw new CodegenException("event streams not supported with AWS QUERY protocol.");
}
@Override
protected void generateEventStreamDeserializers(
GenerationContext context,
UnionShape eventUnion,
Set<EventStreamInfo> eventStreamInfos) {
throw new CodegenException("event streams not supported with AWS QUERY protocol.");
}
@Override
public void generateEventStreamComponents(GenerationContext context) {
throw new CodegenException("event streams not supported with AWS QUERY protocol.");
}
@Override
public void generateEndpointResolution(GenerationContext context) {
var generator = new EndpointResolutionGenerator(new AwsFnProvider());
generator.generate(context);
}
@Override
protected void writeOperationSerializerMiddlewareEventStreamSetup(GenerationContext context, EventStreamInfo info) {
throw new CodegenException("event streams not supported with AWS QUERY protocol.");
}
}
| 8,301 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/EndpointDiscoveryGenerator.java | package software.amazon.smithy.aws.go.codegen;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import software.amazon.smithy.aws.traits.ServiceTrait;
import software.amazon.smithy.aws.traits.clientendpointdiscovery.ClientDiscoveredEndpointTrait;
import software.amazon.smithy.aws.traits.clientendpointdiscovery.ClientEndpointDiscoveryIdTrait;
import software.amazon.smithy.aws.traits.clientendpointdiscovery.ClientEndpointDiscoveryTrait;
import software.amazon.smithy.codegen.core.Symbol;
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.ClientMember;
import software.amazon.smithy.go.codegen.integration.ClientMemberResolver;
import software.amazon.smithy.go.codegen.integration.ConfigField;
import software.amazon.smithy.go.codegen.integration.ConfigFieldResolver;
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.MemberShape;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.model.traits.EnumTrait;
import software.amazon.smithy.utils.ListUtils;
import software.amazon.smithy.utils.SetUtils;
public class EndpointDiscoveryGenerator implements GoIntegration {
// endpoint cache
private static final String CLIENT_MEMBER_ENDPOINT_CACHE = "endpointCache";
private static final Integer DEFAULT_ENDPOINT_CACHE_SIZE = 10;
private static final Symbol CLIENT_MEMBER_ENDPOINT_CACHE_TYPE = SymbolUtils.createPointableSymbolBuilder(
"EndpointCache", AwsGoDependency.SERVICE_INTERNAL_ENDPOINT_DISCOVERY).build();
private static final Symbol ENDPOINT_CACHE_RESOLVER = SymbolUtils.createValueSymbolBuilder(
"resolveEndpointCache").build();
private static final Symbol NEW_ENDPOINT_CACHE = SymbolUtils.createValueSymbolBuilder(
"NewEndpointCache", AwsGoDependency.SERVICE_INTERNAL_ENDPOINT_DISCOVERY).build();
// middleware
private static final String ADD_DISCOVER_ENDPOINT_MIDDLEWARE_FUNC_NAME_FORMAT = "addOp%sDiscoverEndpointMiddleware";
private static final Symbol DISCOVERY_MIDDLEWARE = SymbolUtils.createValueSymbolBuilder("DiscoverEndpoint",
AwsGoDependency.SERVICE_INTERNAL_ENDPOINT_DISCOVERY).build();
// internal endpoint discovery members
private static final Symbol DISCOVERY_ENDPOINT_OPTIONS = SymbolUtils.createPointableSymbolBuilder(
"DiscoverEndpointOptions", AwsGoDependency.SERVICE_INTERNAL_ENDPOINT_DISCOVERY).build();
private static final Symbol DISCOVERY_ENDPOINT_WEIGHTED_ADDRESS = SymbolUtils.createPointableSymbolBuilder(
"WeightedAddress", AwsGoDependency.SERVICE_INTERNAL_ENDPOINT_DISCOVERY).build();
private static final Symbol DISCOVERY_ENDPOINT_TYPE = SymbolUtils.createValueSymbolBuilder(
"Endpoint", AwsGoDependency.SERVICE_INTERNAL_ENDPOINT_DISCOVERY).build();
// operation specific discovery function to fetch Endpoint
private static final String FETCH_DISCOVERED_ENDPOINT_FUNC_NAME_FORMAT = "fetchOp%sDiscoverEndpoint";
// client specific endpoint discovery handler function name
private static final String DISCOVERY_ENDPOINT_HANDLER_NAME = "handleEndpointDiscoveryFromService";
// Symbol for Endpoint resolver interface specific to the client.
private static Symbol ENDPOINT_RESOLVER_INTERFACE_NAME= SymbolUtils.createValueSymbolBuilder(
"EndpointResolver").build();
// EndpointDiscovery options
private static final String ENDPOINT_DISCOVERY_OPTION = "EndpointDiscovery";
private static final Symbol ENDPOINT_DISCOVERY_OPTION_TYPE = SymbolUtils.createValueSymbolBuilder(
"EndpointDiscoveryOptions").build();
// enable endpoint discovery
private static final String ENABLE_ENDPOINT_DISCOVERY_OPTION = "EnableEndpointDiscovery";
private static final String ENDPOINT_RESOLVER_USED_FOR_DISCOVERY = "EndpointResolverUsedForDiscovery";
private static final Symbol ENDPOINT_DISCOVERY_ENABLE_STATE_TYPE = SymbolUtils.createValueSymbolBuilder(
"EndpointDiscoveryEnableState", AwsGoDependency.AWS_CORE).build();
private static final Symbol ENDPOINT_DISCOVERY_ENABLE_STATE_UNSET = SymbolUtils.createValueSymbolBuilder(
"EndpointDiscoveryUnset", AwsGoDependency.AWS_CORE).build();
private static final Symbol ENDPOINT_DISCOVERY_ENABLE_STATE_AUTO = SymbolUtils.createValueSymbolBuilder(
"EndpointDiscoveryAuto", AwsGoDependency.AWS_CORE).build();
// disable-https option for endpoint discovery middleware option
private static final String DISABLE_HTTPS = "DisableHTTPS";
// resolver for enable endpoint discovery
private static final String ENABLE_ENDPOINT_DISCOVERY_OPTION_RESOLVER = "resolveEnableEndpointDiscovery";
List<RuntimeClientPlugin> runtimeClientPlugins = new ArrayList<>();
/**
* Generates endpoint discovery options struct that contains options used to configure endpoint discovery.
*
* @param model is the generation model
* @param writer is the GoWriter
* @param service is the service for which endpoint discovery is performed.
*/
private static void generateEndpointDiscoveryOptions(Model model, GoWriter writer, ServiceShape service) {
if (!serviceSupportsEndpointDiscovery(model, service)) {
return;
}
writer.write("// $T used to configure endpoint discovery", ENDPOINT_DISCOVERY_OPTION_TYPE);
writer.openBlock("type $T struct {", "}", ENDPOINT_DISCOVERY_OPTION_TYPE, () -> {
writer.writeDocs("Enables endpoint discovery");
writer.write("$L $T", ENABLE_ENDPOINT_DISCOVERY_OPTION, ENDPOINT_DISCOVERY_ENABLE_STATE_TYPE);
if (serviceSupportsCustomDiscoveryEndpoint(model, service)) {
writer.write("");
writer.writeDocs("Allows configuring an endpoint resolver to use when attempting an endpoint discovery "
+ "api request.");
writer.write("$L $T", ENDPOINT_RESOLVER_USED_FOR_DISCOVERY, ENDPOINT_RESOLVER_INTERFACE_NAME);
}
});
writer.write("");
}
/**
* Generates resolver function to default EnableEndpointDiscovery to AUTO.
*
* @param model is the generation model
* @param writer is the GoWriter
* @param service is the service for which endpoint discovery is performed.
*/
private static void generateEnableEndpointDiscoveryResolver(Model model, GoWriter writer, ServiceShape service) {
if (!serviceSupportsEndpointDiscovery(model, service)) {
return;
}
writer.openBlock("func $L(o *Options) {", "}",
ENABLE_ENDPOINT_DISCOVERY_OPTION_RESOLVER, () -> {
writer.write("if o.$L.$L != $T { return }", ENDPOINT_DISCOVERY_OPTION,
ENABLE_ENDPOINT_DISCOVERY_OPTION, ENDPOINT_DISCOVERY_ENABLE_STATE_UNSET);
writer.write("o.$L.$L = $T", ENDPOINT_DISCOVERY_OPTION,
ENABLE_ENDPOINT_DISCOVERY_OPTION, ENDPOINT_DISCOVERY_ENABLE_STATE_AUTO);
});
writer.write("");
}
/**
* Generates a helper method to add DiscoverEndpoint middleware into the middleware stack.
*
* @param model is the generation model
* @param symbolProvider is the symbol provider used in generation context
* @param writer is the GoWriter
* @param service is the service for which endpoint discovery is performed.
* @param operation is the operation for which discover endpoint middleware is added.
*/
private static void generateAddDiscoverEndpointMiddleware(
Model model, SymbolProvider symbolProvider, GoWriter writer, ServiceShape service, OperationShape operation
) {
if (!operationUsesEndpointDiscovery(model, service, operation)) {
return;
}
Symbol stackSymbol = SymbolUtils.createPointableSymbolBuilder("Stack", SmithyGoDependency.SMITHY_MIDDLEWARE)
.build();
String helperName = generateAddDiscoverEndpointMiddlewareName(service, operation);
String discoverOperationName = generateFetchDiscoverEndpointFuncName(service, operation);
// Generate Middleware Adder Helper
writer.openBlock("func $L(stack $P, o Options, c *Client) error {", "}", helperName, stackSymbol,
() -> {
writer.addUseImports(SmithyGoDependency.SMITHY_MIDDLEWARE);
String closeBlock = String.format("}, \"%s\", middleware.After)",
EndpointGenerator.MIDDLEWARE_NAME);
writer.openBlock("return stack.Serialize.Insert(&$T{", closeBlock, DISCOVERY_MIDDLEWARE, () -> {
writer.openBlock("Options: []func($P){", "},", DISCOVERY_ENDPOINT_OPTIONS, () -> {
writer.openBlock("func (opt $P) {", "},", DISCOVERY_ENDPOINT_OPTIONS, () -> {
writer.write("opt.$L = o.EndpointOptions.$L", DISABLE_HTTPS, DISABLE_HTTPS);
writer.write("opt.Logger = o.Logger");
if (serviceSupportsCustomDiscoveryEndpoint(model, service)) {
writer.write("opt.$L = o.$L.$L", ENDPOINT_RESOLVER_USED_FOR_DISCOVERY,
ENDPOINT_DISCOVERY_OPTION, ENDPOINT_RESOLVER_USED_FOR_DISCOVERY);
}
});
});
writer.write("DiscoverOperation: c.$L,", discoverOperationName);
writer.write("EndpointDiscoveryEnableState: o.$L.$L,", ENDPOINT_DISCOVERY_OPTION, ENABLE_ENDPOINT_DISCOVERY_OPTION);
writer.write("EndpointDiscoveryRequired: $L,",
operationRequiresEndpointDiscovery(model, service, operation));
});
});
writer.write("");
}
/**
* Generates client scoped handler that attempts endpoint discovery from the service.
*
* @param model is the generation model
* @param symbolProvider is the symbol provider used in generation context
* @param writer is the GoWriter
* @param service is the service for which endpoint discovery is performed.
*/
private static void generateEndpointDiscoveryHandler(
Model model, SymbolProvider symbolProvider, GoWriter writer, ServiceShape service
) {
if (!serviceSupportsEndpointDiscovery(model, service)) {
return;
}
OperationShape discoveryOperation = model.expectShape(getEndpointDiscoveryOperationId(model, service),
OperationShape.class);
Symbol discoveryOperationSymbol = symbolProvider.toSymbol(discoveryOperation);
Shape discoveryOperationInput = model.expectShape(discoveryOperation.getInput().get());
Symbol discoveryOperationInputSymbol = symbolProvider.toSymbol(discoveryOperationInput);
writer.addUseImports(SmithyGoDependency.CONTEXT);
writer.openBlock("func (c *Client) $L(ctx context.Context, input $P, key string, opt $T) ($T, error) {", "}",
DISCOVERY_ENDPOINT_HANDLER_NAME, discoveryOperationInputSymbol, DISCOVERY_ENDPOINT_OPTIONS,
DISCOVERY_ENDPOINT_TYPE, () -> {
if (serviceSupportsCustomDiscoveryEndpoint(model, service)) {
// check if endpoint resolver for endpoint discovery is of service-specific endpoint resolver type
writer.writeDocs("assert endpoint resolver interface is of expected type.");
writer.write("endpointResolver, ok := opt.$L.($T)", ENDPOINT_RESOLVER_USED_FOR_DISCOVERY,
ENDPOINT_RESOLVER_INTERFACE_NAME);
writer.openBlock("if opt.$L != nil && !ok { return $T{},", "}",
ENDPOINT_RESOLVER_USED_FOR_DISCOVERY, DISCOVERY_ENDPOINT_TYPE, () -> {
writer.addUseImports(SmithyGoDependency.FMT);
writer.write("fmt.Errorf(\"Unexpected endpoint resolver type %T provided for endpoint "
+ "discovery api call\", opt.$L)",
ENDPOINT_RESOLVER_USED_FOR_DISCOVERY);
});
writer.write("");
}
// fetch endpoint via making discovery call
writer.openBlock("output, err := c.$T(ctx, input, func(o *Options) {", "})",
discoveryOperationSymbol, () -> {
writer.write("o.EndpointOptions.$L = opt.$L", DISABLE_HTTPS, DISABLE_HTTPS);
writer.write("o.Logger = opt.Logger");
// if service supports custom discovery endpoint
if (serviceSupportsCustomDiscoveryEndpoint(model, service)) {
writer.openBlock("if endpointResolver != nil {", "}", () -> {
writer.write("o.EndpointResolver = endpointResolver");
});
}
});
writer.write("if err != nil { return $T{}, err }", DISCOVERY_ENDPOINT_TYPE);
writer.write("");
// create an endpoint
writer.write("endpoint := $T{}", DISCOVERY_ENDPOINT_TYPE);
writer.write("endpoint.Key = key");
writer.write("");
writer.openBlock("for _, e := range output.Endpoints {", "}", () -> {
writer.write("if e.Address == nil { continue }");
writer.write("address := *e.Address");
writer.write("");
writer.write("var scheme string");
writer.addUseImports(SmithyGoDependency.STRINGS);
writer.openBlock("if idx := strings.Index(address, \"://\"); idx != -1 {", "}", () -> {
writer.write("scheme = address[:idx]");
});
writer.openBlock("if len(scheme) == 0 {", "}", () -> {
writer.write("scheme = \"https\"");
writer.openBlock("if opt.$L {", "}", DISABLE_HTTPS, () -> {
writer.write("scheme = \"http\"");
});
writer.addUseImports(SmithyGoDependency.FMT);
writer.write("address = fmt.Sprintf(\"%s://%s\", scheme, address)");
});
writer.write("");
writer.write("cachedInMinutes := e.CachePeriodInMinutes");
writer.addUseImports(SmithyGoDependency.NET_URL);
writer.write("u, err := url.Parse(address)");
writer.write("if err != nil { continue }");
writer.write("");
writer.openBlock("addr := $T {", "}", DISCOVERY_ENDPOINT_WEIGHTED_ADDRESS, () -> {
writer.write("URL: u,");
writer.addUseImports(SmithyGoDependency.TIME);
writer.write(
"Expired: time.Now().Add(time.Duration(cachedInMinutes) * time.Minute).Round(0),");
});
writer.write("endpoint.Add(addr)");
});
writer.write("");
writer.write("c.$L.Add(endpoint)", CLIENT_MEMBER_ENDPOINT_CACHE);
writer.write("return endpoint, nil");
});
}
//========================= Generation function ==============
/**
* Generates a function to fetch a discovered endpoint.
*
* @param model is the generation model
* @param symbolProvider is the symbol provider used in generation context
* @param writer is the GoWriter
* @param service is the service for which endpoint discovery is performed.
* @param operation is the operation for which discover endpoint middleware is added.
*/
private static void generateFetchDiscoveredEndpointFunction(
Model model, SymbolProvider symbolProvider, GoWriter writer, ServiceShape service, OperationShape operation
) {
if (!operationUsesEndpointDiscovery(model, service, operation)) {
return;
}
// Generate operation specific fetch discovered endpoint function
String fetchDiscoveredEndpointFuncName = generateFetchDiscoverEndpointFuncName(service, operation);
String operationName = operation.getId().getName(service);
String sdkId = service.expectTrait(ServiceTrait.class).getSdkId();
Shape inputShape = model.expectShape(operation.getInput().get());
OperationShape discoveryOperation = model.expectShape(getEndpointDiscoveryOperationId(model, service),
OperationShape.class);
Shape discoveryOperationInput = model.expectShape(discoveryOperation.getInput().get());
Symbol discoveryOperationInputSymbol = symbolProvider.toSymbol(discoveryOperationInput);
String DISCOVERY_OPERATION_INPUT_NAME = "discoveryOperationInput";
writer.addUseImports(SmithyGoDependency.CONTEXT);
writer.openBlock(
"func (c *Client) $L(ctx context.Context, input interface{}, optFns ...func($P)) ($T, error) {", "}",
fetchDiscoveredEndpointFuncName, DISCOVERY_ENDPOINT_OPTIONS, DISCOVERY_ENDPOINT_WEIGHTED_ADDRESS,
() -> {
writer.write("in, ok := input.($P)", symbolProvider.toSymbol(inputShape));
writer.openBlock("if !ok {", "}", () -> {
writer.addUseImports(SmithyGoDependency.FMT);
writer.write("return $T{}, fmt.Errorf(\"unknown input type %T\", input)",
DISCOVERY_ENDPOINT_WEIGHTED_ADDRESS);
});
writer.write("_ = in");
writer.write("");
// build identifier map
String IDENTIFIER_MAP = "identifierMap";
writer.write("$L := make(map[string]string, 0)", IDENTIFIER_MAP);
for (MemberShape member : getMembersUsedAsIdForDiscovery(model, service, operation)) {
String memberName = member.getMemberName();
Shape targetShape = model.expectShape(member.getTarget());
String assignFormat = String.format("$L[$S] = %s",
targetShape.hasTrait(EnumTrait.class) ? "string(in.$L)" : "in.$L");
writer.write(assignFormat, IDENTIFIER_MAP, memberName, memberName);
}
writer.write("");
writer.write("key := fmt.Sprintf(\"$L.%v\", $L)", sdkId, IDENTIFIER_MAP);
writer.write("");
writer.openBlock("if v, ok := c.$L.Get(key); ok {", "}", CLIENT_MEMBER_ENDPOINT_CACHE, () -> {
writer.write("return v, nil");
}).write("");
// build input for endpoint discovery call
writer.openBlock("$L := &$T{", "}", DISCOVERY_OPERATION_INPUT_NAME,
discoveryOperationInputSymbol, () -> {
for (MemberShape member : discoveryOperationInput.members()) {
String memberName = member.getMemberName();
if (memberName.equalsIgnoreCase("Operation")) {
writer.write("$T : $S", member, operationName);
}
if (memberName.equalsIgnoreCase("Identifiers")) {
writer.write("$T : $L", member, IDENTIFIER_MAP);
}
}
}).write("");
// resolve options
writer.write("opt := $T{}", DISCOVERY_ENDPOINT_OPTIONS);
writer.openBlock("for _, fn := range optFns {", "}", () -> {
writer.write("fn(&opt)");
}).write("");
// if discovery not required, then spin up a unblocking go routine
if (!operationRequiresEndpointDiscovery(model, service, operation)) {
writer.write("go c.$L(ctx, $L, key, opt)", DISCOVERY_ENDPOINT_HANDLER_NAME,
DISCOVERY_OPERATION_INPUT_NAME);
writer.write("return $T{}, nil", DISCOVERY_ENDPOINT_WEIGHTED_ADDRESS);
return;
}
writer.write("endpoint, err := c.$L(ctx, $L, key, opt)", DISCOVERY_ENDPOINT_HANDLER_NAME,
DISCOVERY_OPERATION_INPUT_NAME);
writer.write("if err != nil { return $T{}, err }", DISCOVERY_ENDPOINT_WEIGHTED_ADDRESS);
writer.write("");
writer.write("weighted, ok := endpoint.GetValidAddress()");
writer.write(
"if !ok { return $T{}, fmt.Errorf(\"no valid endpoint address returned by the endpoint discovery api\")}",
DISCOVERY_ENDPOINT_WEIGHTED_ADDRESS);
writer.write("return weighted, nil");
});
}
// generates an endpoint cache resolver function
private static void generateEndpointCacheResolver(Model model, GoWriter writer, ServiceShape serviceShape) {
if (!serviceSupportsEndpointDiscovery(model, serviceShape)) {
return;
}
writer.writeDocs("resolves endpoint cache on client");
writer.openBlock("func $T(c *Client) {", "}", ENDPOINT_CACHE_RESOLVER, () -> {
writer.write("c.$L = $T($L)", CLIENT_MEMBER_ENDPOINT_CACHE, NEW_ENDPOINT_CACHE,
DEFAULT_ENDPOINT_CACHE_SIZE);
});
writer.write("");
}
// Returns name for operation specific function that fetches a discovered endpoint.
private static final String generateFetchDiscoverEndpointFuncName(ServiceShape service, OperationShape operation) {
return String.format(FETCH_DISCOVERED_ENDPOINT_FUNC_NAME_FORMAT, operation.getId().getName(service));
}
private static String generateAddDiscoverEndpointMiddlewareName(ServiceShape service, OperationShape operation) {
return String.format(ADD_DISCOVER_ENDPOINT_MIDDLEWARE_FUNC_NAME_FORMAT, operation.getId().getName(service));
}
// Returns true if service supports endpoint discovery. This may or may not be true for each operation.
public static boolean serviceSupportsEndpointDiscovery(Model model, ServiceShape service) {
return service.hasTrait(ClientEndpointDiscoveryTrait.class);
}
// Returns true if operation may use endpoint discovery internally
private static boolean operationUsesEndpointDiscovery(Model model, ServiceShape service, OperationShape operation) {
return operation.hasTrait(ClientDiscoveredEndpointTrait.class);
}
// Returns true if operation requires endpoint discovery
private static boolean operationRequiresEndpointDiscovery(
Model model, ServiceShape service, OperationShape operation
) {
if (!operation.hasTrait(ClientDiscoveredEndpointTrait.class)) return false;
return operation.expectTrait(ClientDiscoveredEndpointTrait.class).isRequired();
}
// ============================Trait info retriever/analyzer==============
// Return operation shape id of the operation to use for making endpoint discovery call.
// eg. DescribeEndpoints
private static ShapeId getEndpointDiscoveryOperationId(Model model, ServiceShape service) {
return service.expectTrait(ClientEndpointDiscoveryTrait.class).getOperation();
}
// Returns input member shapes marked with clientEndpointDiscoveryId trait.
private static Set<MemberShape> getMembersUsedAsIdForDiscovery(
Model model, ServiceShape service, OperationShape operation
) {
Set<MemberShape> shapes = new HashSet<>();
StructureShape input = model.expectShape(operation.getInput().get(), StructureShape.class);
for (MemberShape member : input.members()) {
if (member.hasTrait(ClientEndpointDiscoveryIdTrait.class)) shapes.add(member);
}
return shapes;
}
// Returns true if service supports providing custom endpoint used with the endpoint discovery api call
private static boolean serviceSupportsCustomDiscoveryEndpoint(Model model, ServiceShape service) {
Set<String> ServicesSupportingCustomDiscoveryEndpoint = SetUtils.of(
"Timestream Query", "Timestream Write");
String sdkId = service.expectTrait(ServiceTrait.class).getSdkId();
for (String id : ServicesSupportingCustomDiscoveryEndpoint) {
if (sdkId.equalsIgnoreCase(id)) return true;
}
return false;
}
@Override
public void processFinalizedModel(GoSettings settings, Model model) {
ServiceShape service = settings.getService(model);
// add client member field and resolver for endpoint cache
runtimeClientPlugins.add(RuntimeClientPlugin.builder()
.servicePredicate(EndpointDiscoveryGenerator::serviceSupportsEndpointDiscovery)
.addClientMember(ClientMember.builder()
.name(CLIENT_MEMBER_ENDPOINT_CACHE)
.type(CLIENT_MEMBER_ENDPOINT_CACHE_TYPE)
.documentation("cache used to store discovered endpoints")
.build())
.addClientMemberResolver(ClientMemberResolver.builder()
.resolver(ENDPOINT_CACHE_RESOLVER)
.build())
.build());
for (OperationShape operation : TopDownIndex.of(model).getContainedOperations(service)) {
String helperFuncName = generateAddDiscoverEndpointMiddlewareName(service, operation);
Collection<Symbol> middlewareArgs = ListUtils.of(
SymbolUtils.createValueSymbolBuilder("options").build(),
SymbolUtils.createValueSymbolBuilder("c").build());
runtimeClientPlugins.add(
RuntimeClientPlugin.builder()
.operationPredicate((m, s, o) -> operation.equals(o)
&& EndpointDiscoveryGenerator.operationUsesEndpointDiscovery(m, s, o))
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(helperFuncName).build())
.functionArguments(middlewareArgs)
.build())
.build());
}
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
// Add enable endpoint discovery config option and resolver.
runtimeClientPlugins.add(
RuntimeClientPlugin.builder()
.servicePredicate(EndpointDiscoveryGenerator::serviceSupportsEndpointDiscovery)
.addConfigField(ConfigField.builder()
.name(ENDPOINT_DISCOVERY_OPTION)
.type(ENDPOINT_DISCOVERY_OPTION_TYPE)
.documentation("Allows configuring endpoint discovery")
.build())
.addConfigFieldResolver(ConfigFieldResolver.builder()
.location(ConfigFieldResolver.Location.CLIENT)
.target(ConfigFieldResolver.Target.INITIALIZATION)
.resolver(
SymbolUtils.createValueSymbolBuilder(ENABLE_ENDPOINT_DISCOVERY_OPTION_RESOLVER)
.build())
.build())
.build()
);
return runtimeClientPlugins;
}
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
ServiceShape service = settings.getService(model);
// generate code specific to service client
goDelegator.useShapeWriter(service, writer -> {
generateEndpointCacheResolver(model, writer, service);
generateEndpointDiscoveryOptions(model, writer, service);
generateEnableEndpointDiscoveryResolver(model, writer, service);
generateEndpointDiscoveryHandler(model, symbolProvider, writer, service);
});
// generate code specific to the operation
for (OperationShape operation : TopDownIndex.of(model).getContainedOperations(service)) {
goDelegator.useShapeWriter(operation, writer -> {
generateAddDiscoverEndpointMiddleware(model, symbolProvider, writer, service, operation);
generateFetchDiscoveredEndpointFunction(model, symbolProvider, writer, service, operation);
});
}
}
}
| 8,302 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/ServiceIdUtils.java | /*
* 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.aws.go.codegen;
/**
* Provides utilities for normalizing a ServiceId.
*/
public final class ServiceIdUtils {
/**
* Converts beginning of words to title case with spaces removed.
*
* @param id service id
* @return the title cased string
*/
public static String toTitleCase(String id) {
return toTitleCase(id, true);
}
/**
* Converts begining of words to title case with or without the space separator removed.
* Does not modify the case of characters used within a word.
*
* @param id service id
* @param removeSeparator whether the separator character should be removed between words
* @return the title cases string
*/
public static String toTitleCase(String id, boolean removeSeparator) {
StringBuilder builder = new StringBuilder();
char[] charArray = id.toCharArray();
char prev = ' ';
for (int i = 0; i < charArray.length; i++) {
char c = charArray[i];
if (isSeparator(prev)) {
c = Character.toTitleCase(c);
}
if (!removeSeparator || !isSeparator(c)) {
builder.append(c);
}
prev = c;
}
return builder.toString();
}
private static boolean isSeparator(char c) {
return c == ' ';
}
}
| 8,303 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsEndpointResolverBuiltInGenerator.java | package software.amazon.smithy.aws.go.codegen;
import static software.amazon.smithy.go.codegen.GoWriter.goTemplate;
import static software.amazon.smithy.go.codegen.GoWriter.goDocTemplate;
import static software.amazon.smithy.aws.go.codegen.EndpointGenerator.USE_FIPS_ENDPOINT_OPTION;
import static software.amazon.smithy.aws.go.codegen.EndpointGenerator.DUAL_STACK_ENDPOINT_OPTION;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.go.codegen.GoSettings;
import software.amazon.smithy.go.codegen.GoWriter;
import software.amazon.smithy.go.codegen.SymbolUtils;
import software.amazon.smithy.go.codegen.TriConsumer;
import software.amazon.smithy.go.codegen.endpoints.EndpointBuiltInHandler;
import software.amazon.smithy.go.codegen.endpoints.EndpointParametersGenerator;
import software.amazon.smithy.go.codegen.endpoints.EndpointResolutionGenerator;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.utils.MapUtils;
import software.amazon.smithy.rulesengine.language.EndpointRuleSet;
import software.amazon.smithy.rulesengine.traits.EndpointRuleSetTrait;
import software.amazon.smithy.rulesengine.language.syntax.parameters.Parameter;
import software.amazon.smithy.rulesengine.language.syntax.parameters.ParameterType;
import software.amazon.smithy.rulesengine.language.syntax.parameters.Parameters;
import software.amazon.smithy.utils.StringUtils;
import java.util.Iterator;
import java.util.Map;
import java.util.Optional;
import java.util.function.Consumer;
public class AwsEndpointResolverBuiltInGenerator implements GoIntegration {
public static final String BUILTIN_RESOLVER_INTERFACE_TYPE = "builtInParameterResolver";
public static final String BUILTIN_RESOLVER_IMPLEMENTATION_TYPE = "builtInResolver";
private Map<String, Object> commonCodegenArgs;
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
TriConsumer<String, String, Consumer<GoWriter>> writerFactory) {
this.commonCodegenArgs = MapUtils.of(
"resolverInterface", SymbolUtils.createValueSymbolBuilder(BUILTIN_RESOLVER_INTERFACE_TYPE).build(),
"resolverImpl", SymbolUtils.createValueSymbolBuilder(BUILTIN_RESOLVER_IMPLEMENTATION_TYPE).build(),
"endpointParametersType", EndpointResolutionGenerator.PARAMETERS_TYPE_NAME);
var serviceShape = settings.getService(model);
Optional<EndpointRuleSet> ruleset = Optional.empty();
var rulesetTrait = serviceShape.getTrait(EndpointRuleSetTrait.class);
if (rulesetTrait.isPresent()) {
ruleset = Optional.of(EndpointRuleSet.fromNode(rulesetTrait.get().getRuleSet()));
} else {
return;
}
Parameters parameters = ruleset.get().getParameters();
var content = new GoWriter.ChainWritable()
.add(generatePseudoRegionUtility())
.add(generateBuiltInInterfaceType())
.add(generateBuiltInImplementationType(parameters))
.add(generateBuiltInResolverMethod(parameters))
.compose();
for(Iterator<Parameter> iter = parameters.iterator(); iter.hasNext();){
if (iter.next().getBuiltIn().isPresent()) {
writerFactory.accept("endpoints.go", settings.getModuleName(), writer -> {
writer.write("$W", content);
});
break;
}
}
}
private GoWriter.Writable generatePseudoRegionUtility() {
return goTemplate(
"""
// Utility function to aid with translating pseudo-regions to classical regions
// with the appropriate setting indicated by the pseudo-region
func mapPseudoRegion(pr string) (region string, fips $awsFipsEndpointStateType:T) {
const fipsInfix = \"-fips-\"
const fipsPrefix = \"fips-\"
const fipsSuffix = \"-fips\"
if strings.Contains(pr, fipsInfix) ||
strings.Contains(pr, fipsPrefix) ||
strings.Contains(pr, fipsSuffix) {
region = strings.ReplaceAll(strings.ReplaceAll(strings.ReplaceAll(
pr, fipsInfix, "-"), fipsPrefix, ""), fipsSuffix, "")
fips = $awsFipsEndpointStateEnabledType:T
} else {
region = pr
}
return region, fips
}
""",
MapUtils.of(
"awsFipsEndpointStateEnabledType", SymbolUtils.createValueSymbolBuilder("FIPSEndpointStateEnabled", AwsGoDependency.AWS_CORE).build(),
"awsFipsEndpointStateType", SymbolUtils.createValueSymbolBuilder("FIPSEndpointState", AwsGoDependency.AWS_CORE).build()
));
}
private GoWriter.Writable generateBuiltInInterfaceType() {
return goTemplate(
"""
$interfaceDoc:W
type $resolverInterface:T interface {
ResolveBuiltIns(*$endpointParametersType:L) error
}
""",
commonCodegenArgs,
MapUtils.of(
"interfaceDoc", goDocTemplate(
"""
$resolverInterface:T is the interface responsible for resolving BuiltIn values during the sourcing of $endpointParametersType:L
""",
commonCodegenArgs)));
}
private GoWriter.Writable generateBuiltInImplementationType(Parameters parameters) {
return goTemplate(
"""
$structDoc:W
type $resolverImpl:T struct {
$members:W
}
""",
commonCodegenArgs,
MapUtils.of(
"structDoc", goDocTemplate(
"""
$resolverImpl:T resolves modeled BuiltIn values using only the members defined below.
""",
commonCodegenArgs),
"members", generateBuiltInResolverMembers(parameters)));
}
private GoWriter.Writable generateBuiltInResolverMembers(Parameters parameters) {
return (GoWriter w) -> {
for(Iterator<Parameter> iter = parameters.iterator(); iter.hasNext();){
Parameter parameter = iter.next();
if (!parameter.getBuiltIn().isPresent()) {
continue;
}
String template = """
$W
$L $T
""";
GoWriter.Writable docs;
Symbol paramSymbol;
if (parameter.getBuiltIn().get().equals("SDK::Endpoint")) {
template = """
$W
$L $P
""";
docs = goDocTemplate(
"Base endpoint that can potentially be modified during Endpoint resolution.");
paramSymbol = parameterAsSymbol(parameter);
} else if (parameter.getBuiltIn().get().equals("AWS::UseFIPS")) {
docs = goDocTemplate("Sourced BuiltIn value in a historical enabled or disabled state.");
paramSymbol = SymbolUtils
.createValueSymbolBuilder("FIPSEndpointState", AwsGoDependency.AWS_CORE).build();
} else if (parameter.getBuiltIn().get().equals("AWS::UseDualStack")) {
docs = goDocTemplate("Sourced BuiltIn value in a historical enabled or disabled state.");
paramSymbol = SymbolUtils
.createValueSymbolBuilder("DualStackEndpointState", AwsGoDependency.AWS_CORE)
.build();
} else {
docs = parameter.getDocumentation().isPresent()
? goDocTemplate(parameter.getDocumentation().get())
: goDocTemplate("");
paramSymbol = parameterAsSymbol(parameter);
}
w.write(template, docs, getExportedParameterName(parameter), paramSymbol);
w.insertTrailingNewline();
}
};
}
private GoWriter.Writable generateBuiltInResolverMethod(Parameters parameters) {
return (GoWriter writer) -> {
writer.write(
"""
$W
func (b *$L) ResolveBuiltIns(params *$L) error {
""",
goDocTemplate(
"""
Invoked at runtime to resolve BuiltIn Values. Only resolution code specific to each BuiltIn value is generated.
"""),
AwsEndpointResolverBuiltInGenerator.BUILTIN_RESOLVER_IMPLEMENTATION_TYPE,
EndpointResolutionGenerator.PARAMETERS_TYPE_NAME);
for(Iterator<Parameter> iter = parameters.iterator(); iter.hasNext();){
Parameter parameter = iter.next();
if (!parameter.getBuiltIn().isPresent()) {
continue;
}
if (parameter.getBuiltIn().get().equals("SDK::Endpoint")) {
writer.write("$W", generateSdkEndpointBuiltInResolver(parameter));
} else if (parameter.getBuiltIn().get().equals("AWS::Region")) {
writer.write("$W", generateAwsRegionBuiltInResolver(parameter));
} else if (parameter.getBuiltIn().get().equals("AWS::UseFIPS")) {
writer.write("$W", generateAwsFipsBuiltInResolver(parameter));
} else if (parameter.getBuiltIn().get().equals("AWS::UseDualStack")) {
writer.write("$W", generateAwsDualStackBuiltInResolver(parameter));
} else if (parameter.getType() == ParameterType.STRING) {
writer.write(
"params.$L = $T(b.$L)",
parameter.getName().getName().getValue(),
SymbolUtils.createValueSymbolBuilder("String", AwsGoDependency.AWS_CORE).build(),
getExportedParameterName(parameter));
} else if (parameter.getType() == ParameterType.BOOLEAN) {
writer.write(
"params.$L = $T(b.$L)",
parameter.getName().getName().getValue(),
SymbolUtils.createValueSymbolBuilder("Bool", AwsGoDependency.AWS_CORE).build(),
getExportedParameterName(parameter));
} else {
throw new CodegenException(
String.format("Invalid Builtin %s", parameter.getBuiltIn().get()));
}
}
writer.write(
"""
return nil
}
""");
};
}
private GoWriter.Writable generateSdkEndpointBuiltInResolver(Parameter parameter) {
return (GoWriter writer) -> {
writer.write(
"""
params.$L = b.Endpoint
""",
parameter.getName().getName().getValue());
};
}
private GoWriter.Writable generateAwsRegionBuiltInResolver(Parameter parameter) {
return (GoWriter writer) -> {
writer.write(
"""
region, _ := mapPseudoRegion(b.Region)
if len(region) == 0 {
return fmt.Errorf(\"Could not resolve AWS::Region\")
} else {
params.$L = $T(region)
}
""",
parameter.getName().getName().getValue(),
SymbolUtils.createValueSymbolBuilder("String", AwsGoDependency.AWS_CORE).build());
};
}
private GoWriter.Writable generateAwsFipsBuiltInResolver(Parameter parameter) {
return (GoWriter writer) -> {
String paramName = parameter.getName().getName().getValue();
writer.write(
"""
if b.UseFIPS == $T {
params.$L = $T(true)
} else {
params.$L = $T(false)
}
""",
SymbolUtils.createValueSymbolBuilder("FIPSEndpointStateEnabled", AwsGoDependency.AWS_CORE).build(),
paramName,
SymbolUtils.createValueSymbolBuilder("Bool", AwsGoDependency.AWS_CORE).build(),
paramName,
SymbolUtils.createValueSymbolBuilder("Bool", AwsGoDependency.AWS_CORE).build());
};
}
private GoWriter.Writable generateAwsDualStackBuiltInResolver(Parameter parameter) {
return (GoWriter writer) -> {
String paramName = parameter.getName().getName().getValue();
writer.write(
"""
if b.UseDualStack == $T {
params.$L = $T(true)
} else {
params.$L = $T(false)
}
""",
SymbolUtils.createValueSymbolBuilder("DualStackEndpointStateEnabled", AwsGoDependency.AWS_CORE)
.build(),
paramName,
SymbolUtils.createValueSymbolBuilder("Bool", AwsGoDependency.AWS_CORE).build(),
paramName,
SymbolUtils.createValueSymbolBuilder("Bool", AwsGoDependency.AWS_CORE).build());
};
}
@Override
public Optional<EndpointBuiltInHandler> getEndpointBuiltinHandler() {
return Optional.of(new AwsEndpointBuiltInHandler());
}
private class AwsEndpointBuiltInHandler implements EndpointBuiltInHandler {
AwsEndpointBuiltInHandler() {
}
@Override
public void renderEndpointBuiltInField(GoWriter writer) {
writer.write("BuiltInResolver $T",
SymbolUtils.createValueSymbolBuilder(BUILTIN_RESOLVER_INTERFACE_TYPE).build());
}
@Override
public void renderEndpointBuiltInInvocation(GoWriter writer) {
writer.write("m.BuiltInResolver.ResolveBuiltIns(¶ms)");
}
@Override
public void renderEndpointBuiltInInitialization(GoWriter writer, Parameters parameters) {
writer.write(
"""
BuiltInResolver: &$T{
$W
},
""",
SymbolUtils.createValueSymbolBuilder(BUILTIN_RESOLVER_IMPLEMENTATION_TYPE).build(),
generateBuiltInInitializeFieldMembers(parameters));
}
private GoWriter.Writable generateBuiltInInitializeFieldMembers(Parameters parameters) {
return (GoWriter writer) -> {
for(Iterator<Parameter> iter = parameters.iterator(); iter.hasNext();){
Parameter parameter = iter.next();
if (!parameter.getBuiltIn().isPresent()) {
continue;
}
if (parameter.getBuiltIn().get().equals("SDK::Endpoint")) {
writer.write("$L: options.BaseEndpoint,", getExportedParameterName(parameter));
writer.insertTrailingNewline();
}
if (parameter.getBuiltIn().get().equals("AWS::Region")) {
writer.write("$L: options.Region,", getExportedParameterName(parameter));
writer.insertTrailingNewline();
}
if (parameter.getBuiltIn().get().equals("AWS::UseFIPS")) {
writer.write("$L: options.$L.$L,", getExportedParameterName(parameter),
"EndpointOptions", USE_FIPS_ENDPOINT_OPTION);
writer.insertTrailingNewline();
}
if (parameter.getBuiltIn().get().equals("AWS::UseDualStack")) {
writer.write("$L: options.$L.$L,", getExportedParameterName(parameter),
"EndpointOptions", DUAL_STACK_ENDPOINT_OPTION);
writer.insertTrailingNewline();
}
if (parameter.getBuiltIn().get().equals("AWS::S3::ForcePathStyle")) {
writer.write("$L: options.UsePathStyle,", getExportedParameterName(parameter));
writer.insertTrailingNewline();
}
if (parameter.getBuiltIn().get().equals("AWS::S3::Accelerate")) {
writer.write("$L: options.UseAccelerate,", getExportedParameterName(parameter));
writer.insertTrailingNewline();
}
if (parameter.getBuiltIn().get().equals("AWS::S3::UseArnRegion")) {
writer.write("$L: options.UseARNRegion,", getExportedParameterName(parameter));
writer.insertTrailingNewline();
}
if (parameter.getBuiltIn().get().equals("AWS::S3::DisableMultiRegionAccessPoints")) {
writer.write("$L: options.DisableMultiRegionAccessPoints,",
getExportedParameterName(parameter));
writer.insertTrailingNewline();
}
if (parameter.getBuiltIn().get().equals("AWS::S3Control::UseArnRegion")) {
writer.write("$L: options.UseARNRegion,", getExportedParameterName(parameter));
writer.insertTrailingNewline();
}
}
};
}
}
public static String getExportedParameterName(Parameter parameter) {
return StringUtils.capitalize(parameter.getName().getName().getValue());
}
public static Symbol parameterAsSymbol(Parameter parameter) {
return switch (parameter.getType()) {
case STRING -> SymbolUtils.createPointableSymbolBuilder("string")
.putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true).build();
case BOOLEAN -> SymbolUtils.createPointableSymbolBuilder("bool")
.putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true).build();
};
}
}
| 8,304 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/RestJsonProtocolGenerator.java | /*
* Copyright 2019 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.aws.go.codegen;
import static software.amazon.smithy.go.codegen.integration.HttpProtocolGeneratorUtils.isShapeWithResponseBindings;
import static software.amazon.smithy.aws.go.codegen.AwsProtocolUtils.handleDecodeError;
import static software.amazon.smithy.aws.go.codegen.AwsProtocolUtils.initializeJsonDecoder;
import static software.amazon.smithy.aws.go.codegen.AwsProtocolUtils.writeJsonErrorMessageCodeDeserializer;
import java.util.HashSet;
import java.util.Optional;
import java.util.Set;
import java.util.TreeSet;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.go.codegen.GoStackStepMiddlewareGenerator;
import software.amazon.smithy.go.codegen.GoValueAccessUtils;
import software.amazon.smithy.go.codegen.GoWriter;
import software.amazon.smithy.go.codegen.SmithyGoDependency;
import software.amazon.smithy.go.codegen.Synthetic;
import software.amazon.smithy.go.codegen.integration.HttpBindingProtocolGenerator;
import software.amazon.smithy.go.codegen.integration.ProtocolGenerator;
import software.amazon.smithy.go.codegen.integration.ProtocolUtils;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.knowledge.EventStreamInfo;
import software.amazon.smithy.model.knowledge.HttpBinding;
import software.amazon.smithy.model.knowledge.HttpBinding.Location;
import software.amazon.smithy.model.knowledge.HttpBindingIndex;
import software.amazon.smithy.model.shapes.MemberShape;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.shapes.ShapeType;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.model.shapes.UnionShape;
import software.amazon.smithy.model.traits.EnumTrait;
import software.amazon.smithy.model.traits.ErrorTrait;
import software.amazon.smithy.model.traits.EventHeaderTrait;
import software.amazon.smithy.model.traits.EventPayloadTrait;
import software.amazon.smithy.model.traits.MediaTypeTrait;
import software.amazon.smithy.model.traits.StreamingTrait;
import software.amazon.smithy.model.traits.TimestampFormatTrait;
import software.amazon.smithy.model.traits.XmlNamespaceTrait;
import software.amazon.smithy.go.codegen.endpoints.EndpointResolutionGenerator;
import software.amazon.smithy.go.codegen.endpoints.FnGenerator;
/**
* Handles general components across the AWS JSON protocols that have HTTP
* bindings.
* It handles reading and writing from document bodies, including generating any
* functions needed for performing serde.
*
* @see <a href="https://smithy.io/2.0/spec/http-bindings.html">Smithy HTTP
* protocol bindings.</a>
*/
abstract class RestJsonProtocolGenerator extends HttpBindingProtocolGenerator {
private final Set<ShapeId> generatedDocumentBodyShapeSerializers = new HashSet<>();
private final Set<ShapeId> generatedEventMessageSerializers = new HashSet<>();
private final Set<ShapeId> generatedDocumentBodyShapeDeserializers = new HashSet<>();
private final Set<ShapeId> generatedEventMessageDeserializers = new HashSet<>();
/**
* Creates a AWS JSON RPC protocol generator.
*/
RestJsonProtocolGenerator() {
super(true);
}
@Override
protected TimestampFormatTrait.Format getDocumentTimestampFormat() {
return TimestampFormatTrait.Format.EPOCH_SECONDS;
}
@Override
protected void generateOperationDocumentSerializer(
GenerationContext context,
OperationShape operation) {
Model model = context.getModel();
HttpBindingIndex bindingIndex = HttpBindingIndex.of(model);
Set<MemberShape> documentBindings = bindingIndex.getRequestBindings(operation, HttpBinding.Location.DOCUMENT)
.stream()
.map(HttpBinding::getMember)
.collect(Collectors.toSet());
if (documentBindings.size() == 0) {
return;
}
Shape inputShape = ProtocolUtils.expectInput(model, operation);
inputShape.accept(JsonShapeSerVisitor.builder()
.context(context)
.memberFilter(documentBindings::contains)
.supportJsonName(true)
.build());
}
@Override
public void generateEndpointResolution(GenerationContext context) {
var generator = new EndpointResolutionGenerator(new AwsFnProvider());
generator.generate(context);
}
@Override
protected void writeMiddlewarePayloadAsDocumentSerializerDelegator(
GenerationContext context,
MemberShape memberShape,
String operand) {
GoWriter writer = context.getWriter().get();
Model model = context.getModel();
Shape payloadShape = model.expectShape(memberShape.getTarget());
String functionName;
if (payloadShape.hasTrait(Synthetic.class)) {
functionName = ProtocolGenerator.getDocumentSerializerFunctionName(
payloadShape, context.getService(), context.getProtocolName());
} else {
functionName = ProtocolGenerator.getDocumentSerializerFunctionName(
payloadShape, context.getService(), context.getProtocolName());
}
writeSetPayloadShapeHeader(writer, payloadShape);
GoValueAccessUtils.writeIfNonZeroValueMember(context.getModel(), context.getSymbolProvider(), writer,
memberShape, operand, (s) -> {
writer.addUseImports(SmithyGoDependency.SMITHY_JSON);
writer.addUseImports(SmithyGoDependency.BYTES);
writer.write("""
jsonEncoder := smithyjson.NewEncoder()
if err := $L($L, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
payload := bytes.NewReader(jsonEncoder.Bytes())""", functionName, s);
writeSetStream(writer, "payload");
if (payloadShape.getType() == ShapeType.STRUCTURE) {
writer.openBlock("} else {", "", () -> {
writer.write("""
jsonEncoder := smithyjson.NewEncoder()
jsonEncoder.Value.Object().Close()
payload := bytes.NewReader(jsonEncoder.Bytes())""");
writeSetStream(writer, "payload");
});
}
});
}
/**
* Retruns the MediaType for the payload shape derived from the MediaTypeTrait,
* shape type, or document content type.
*
* @param payloadShape shape bound to the payload.
* @return string for media type.
*/
private String getPayloadShapeMediaType(Shape payloadShape) {
Optional<MediaTypeTrait> mediaTypeTrait = payloadShape.getTrait(MediaTypeTrait.class);
if (mediaTypeTrait.isPresent()) {
return mediaTypeTrait.get().getValue();
}
if (payloadShape.isBlobShape()) {
return "application/octet-stream";
}
if (payloadShape.isStringShape()) {
return "text/plain";
}
return getDocumentContentType();
}
@Override
protected void writeMiddlewareDocumentSerializerDelegator(
GenerationContext context,
OperationShape operation,
GoStackStepMiddlewareGenerator generator) {
GoWriter writer = context.getWriter().get();
writer.addUseImports(SmithyGoDependency.SMITHY);
writer.addUseImports(SmithyGoDependency.SMITHY_JSON);
writer.write("restEncoder.SetHeader(\"Content-Type\").String($S)", getDocumentContentType());
writer.write("");
Shape inputShape = ProtocolUtils.expectInput(context.getModel(), operation);
String functionName = ProtocolGenerator.getDocumentSerializerFunctionName(inputShape, context.getService(),
getProtocolName());
writer.addUseImports(SmithyGoDependency.SMITHY_JSON);
writer.write("jsonEncoder := smithyjson.NewEncoder()");
writer.openBlock("if err := $L(input, jsonEncoder.Value); err != nil {", "}", functionName, () -> {
writer.write("return out, metadata, &smithy.SerializationError{Err: err}");
});
writer.write("");
writer.addUseImports(SmithyGoDependency.BYTES);
writer.openBlock("if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {", "}",
() -> {
writer.write("return out, metadata, &smithy.SerializationError{Err: err}");
});
}
@Override
protected void generateDocumentBodyShapeSerializers(GenerationContext context, Set<Shape> shapes) {
JsonShapeSerVisitor visitor = JsonShapeSerVisitor.builder()
.context(context)
.supportJsonName(true)
.build();
shapes.forEach(shape -> {
if (generatedDocumentBodyShapeSerializers.contains(shape.toShapeId())) {
return;
}
shape.accept(visitor);
generatedDocumentBodyShapeSerializers.add(shape.toShapeId());
});
}
@Override
protected void writeMiddlewareDocumentDeserializerDelegator(
GenerationContext context,
OperationShape operation,
GoStackStepMiddlewareGenerator generator) {
Model model = context.getModel();
GoWriter writer = context.getWriter().get();
Shape targetShape = ProtocolUtils.expectOutput(model, operation);
String operand = "output";
boolean isShapeWithPayloadBinding = isShapeWithResponseBindings(model, operation, HttpBinding.Location.PAYLOAD);
if (isShapeWithPayloadBinding) {
// since payload trait can only be applied to a single member in a output shape
MemberShape memberShape = HttpBindingIndex.of(model)
.getResponseBindings(operation, HttpBinding.Location.PAYLOAD).stream()
.findFirst()
.orElseThrow(() -> new CodegenException("Expected payload binding member"))
.getMember();
Shape payloadShape = model.expectShape(memberShape.getTarget());
// if target shape is of type String or type Blob, then delegate deserializers
// for explicit payload shapes
if (payloadShape.isStringShape() || payloadShape.isBlobShape()) {
writeMiddlewarePayloadBindingDeserializerDelegator(writer, context.getService(), targetShape,
payloadShape);
return;
}
// for other payload target types we should deserialize using the appropriate
// document deserializer
targetShape = payloadShape;
operand += "." + context.getSymbolProvider().toMemberName(memberShape);
}
writer.addUseImports(SmithyGoDependency.SMITHY_IO);
writer.write("var buff [1024]byte");
writer.write("ringBuffer := smithyio.NewRingBuffer(buff[:])");
writer.write("");
writer.addUseImports(SmithyGoDependency.IO);
writer.write("body := io.TeeReader(response.Body, ringBuffer)");
writer.write("");
writer.addUseImports(SmithyGoDependency.JSON);
writer.write("decoder := json.NewDecoder(body)");
writer.write("decoder.UseNumber()");
AwsProtocolUtils.decodeJsonIntoInterface(writer, "out, metadata, ");
writer.write("");
writeMiddlewareDocumentBindingDeserializerDelegator(context, writer, targetShape, operand);
}
// Writes middleware that delegates to deserializers for shapes that have
// explicit payload.
private void writeMiddlewarePayloadBindingDeserializerDelegator(
GoWriter writer, ServiceShape service, Shape outputShape, Shape payloadShape) {
String deserFuncName = ProtocolGenerator.getDocumentDeserializerFunctionName(outputShape, service,
getProtocolName());
String contentLengthParam = "";
if (!payloadShape.hasTrait(StreamingTrait.class)) {
contentLengthParam = "response.ContentLength";
}
writer.write("err = $L(output, response.Body, $L)", deserFuncName, contentLengthParam);
writer.openBlock("if err != nil {", "}", () -> {
writer.addUseImports(SmithyGoDependency.SMITHY);
writer.write(String.format("return out, metadata, &smithy.DeserializationError{Err:%s}",
"fmt.Errorf(\"failed to deserialize response payload, %w\", err)"));
});
}
// Write middleware that delegates to deserializers for shapes that have
// implicit payload and deserializer
private void writeMiddlewareDocumentBindingDeserializerDelegator(
GenerationContext context,
GoWriter writer,
Shape shape,
String operand) {
String functionName = ProtocolGenerator.getDocumentDeserializerFunctionName(
shape, context.getService(), context.getProtocolName());
writer.write("err = $L(&$L, shape)", functionName, operand);
writer.openBlock("if err != nil {", "}", () -> {
writer.addUseImports(SmithyGoDependency.BYTES);
writer.addUseImports(SmithyGoDependency.SMITHY);
writer.write("var snapshot bytes.Buffer");
writer.write("io.Copy(&snapshot, ringBuffer)");
writer.openBlock("return out, metadata, &smithy.DeserializationError {", "}", () -> {
writer.write("Err: fmt.Errorf(\"failed to decode response body with invalid JSON, %w\", err),");
writer.write("Snapshot: snapshot.Bytes(),");
});
});
}
@Override
protected void generateOperationDocumentDeserializer(
GenerationContext context,
OperationShape operation) {
Model model = context.getModel();
HttpBindingIndex bindingIndex = HttpBindingIndex.of(model);
Set<MemberShape> documentBindings = bindingIndex.getResponseBindings(operation, HttpBinding.Location.DOCUMENT)
.stream()
.map(HttpBinding::getMember)
.collect(Collectors.toSet());
Shape outputShape = ProtocolUtils.expectOutput(model, operation);
GoWriter writer = context.getWriter().get();
if (documentBindings.size() != 0) {
outputShape.accept(JsonShapeDeserVisitor.builder()
.context(context)
.memberFilter(documentBindings::contains)
.supportJsonName(true)
.build());
}
Set<MemberShape> payloadBindings = bindingIndex.getResponseBindings(operation, HttpBinding.Location.PAYLOAD)
.stream()
.map(HttpBinding::getMember)
.collect(Collectors.toSet());
if (payloadBindings.size() == 0) {
return;
}
writePayloadBindingDeserializer(context, outputShape, payloadBindings::contains);
writer.write("");
}
@Override
protected void writeErrorMessageCodeDeserializer(GenerationContext context) {
writeJsonErrorMessageCodeDeserializer(context);
}
@Override
protected void deserializeError(GenerationContext context, StructureShape shape) {
GoWriter writer = context.getWriter().get();
Symbol symbol = context.getSymbolProvider().toSymbol(shape);
ServiceShape service = context.getService();
writer.write("output := &$T{}", symbol);
writer.insertTrailingNewline();
// TODO: filter on error document body contains
if (isShapeWithResponseBindings(context.getModel(), shape, Location.DOCUMENT)) {
String documentDeserFunctionName = ProtocolGenerator.getDocumentDeserializerFunctionName(
shape, service, getProtocolName());
initializeJsonDecoder(writer, "errorBody");
AwsProtocolUtils.decodeJsonIntoInterface(writer, "");
writer.write("err := $L(&output, shape)", documentDeserFunctionName);
writer.write("");
handleDecodeError(writer);
writer.write("errorBody.Seek(0, io.SeekStart)");
writer.write("");
}
if (isShapeWithRestResponseBindings(context.getModel(), shape)) {
String bindingDeserFunctionName = ProtocolGenerator.getOperationHttpBindingsDeserFunctionName(
shape, service, getProtocolName());
writer.openBlock("if err := $L(output, response); err != nil {", "}", bindingDeserFunctionName, () -> {
writer.addUseImports(SmithyGoDependency.SMITHY);
writer.write(String.format("return &smithy.DeserializationError{Err: %s}",
"fmt.Errorf(\"failed to decode response error with invalid HTTP bindings, %w\", err)"));
});
writer.write("");
}
writer.write("return output");
}
@Override
protected void generateDocumentBodyShapeDeserializers(GenerationContext context, Set<Shape> shapes) {
JsonShapeDeserVisitor visitor = JsonShapeDeserVisitor.builder()
.context(context)
.supportJsonName(true)
.build();
shapes.forEach(shape -> {
if (generatedDocumentBodyShapeDeserializers.contains(shape.toShapeId())) {
return;
}
shape.accept(visitor);
generatedDocumentBodyShapeDeserializers.add(shape.toShapeId());
});
}
// Generate deserializers for shapes with payload binding
private void writePayloadBindingDeserializer(
GenerationContext context,
Shape shape,
Predicate<MemberShape> filterMemberShapes) {
var writer = context.getWriter().get();
var symbolProvider = context.getSymbolProvider();
var shapeSymbol = symbolProvider.toSymbol(shape);
var funcName = ProtocolGenerator.getDocumentDeserializerFunctionName(shape, context.getService(),
getProtocolName());
for (var memberShape : new TreeSet<>(shape.members())) {
if (!filterMemberShapes.test(memberShape)) {
continue;
}
var memberName = symbolProvider.toMemberName(memberShape);
var targetShape = context.getModel().expectShape(memberShape.getTarget());
if (targetShape.isStringShape() || targetShape.isBlobShape()) {
String contentLengthParam = "";
if (!targetShape.hasTrait(StreamingTrait.class)) {
contentLengthParam = "contentLength int64";
}
writer.openBlock("func $L(v $P, body io.ReadCloser, $L) error {", "}",
funcName, shapeSymbol, contentLengthParam, () -> {
writer.openBlock("if v == nil {", "}", () -> {
writer.write("return fmt.Errorf(\"unsupported deserialization of nil %T\", v)");
});
writer.write("");
if (!targetShape.hasTrait(StreamingTrait.class)) {
writer.addUseImports(SmithyGoDependency.BYTES);
writer.write("var buf bytes.Buffer");
writer.openBlock("if contentLength > 0 {", "", () -> {
writer.write("buf.Grow(int(contentLength))");
writer.openBlock("} else {", "}", () -> {
writer.write("buf.Grow(512)");
});
});
writer.write("_, err := buf.ReadFrom(body)");
writer.write("if err != nil { return err }");
writer.openBlock("if buf.Len() > 0 {", "}", () -> {
if (targetShape.isBlobShape()) {
writer.write("v.$L = buf.Bytes()", memberName);
} else { // string
writer.addUseImports(SmithyGoDependency.SMITHY_PTR);
if (targetShape.hasTrait(EnumTrait.class)) {
writer.write("v.$L = $T(buf.Bytes())", memberName,
symbolProvider.toSymbol(targetShape));
} else {
writer.write("v.$L = ptr.String(buf.String())", memberName);
}
}
});
} else {
writer.write("v.$L = body", memberName);
}
writer.write("return nil");
});
} else {
shape.accept(JsonShapeDeserVisitor.builder()
.context(context)
.memberFilter(filterMemberShapes)
.supportJsonName(true)
.build());
}
}
}
@Override
public void generateSharedDeserializerComponents(GenerationContext context) {
super.generateSharedDeserializerComponents(context);
}
@Override
public void generateProtocolTests(GenerationContext context) {
AwsProtocolUtils.generateHttpProtocolTests(context);
}
@Override
public void generateProtocolDocumentMarshalerUnmarshalDocument(GenerationContext context) {
JsonProtocolDocumentUtils.generateProtocolDocumentMarshalerUnmarshalDocument(context);
}
@Override
public void generateProtocolDocumentMarshalerMarshalDocument(GenerationContext context) {
JsonProtocolDocumentUtils.generateProtocolDocumentMarshalerMarshalDocument(context);
}
@Override
public void generateProtocolDocumentUnmarshalerUnmarshalDocument(GenerationContext context) {
JsonProtocolDocumentUtils.generateProtocolDocumentUnmarshalerUnmarshalDocument(context);
}
@Override
public void generateProtocolDocumentUnmarshalerMarshalDocument(GenerationContext context) {
JsonProtocolDocumentUtils.generateProtocolDocumentUnmarshalerMarshalDocument(context);
}
@Override
public void generateEventStreamComponents(GenerationContext context) {
AwsEventStreamUtils.generateEventStreamComponents(context);
}
@Override
protected void writeOperationSerializerMiddlewareEventStreamSetup(GenerationContext context, EventStreamInfo info) {
AwsEventStreamUtils.writeOperationSerializerMiddlewareEventStreamSetup(context, info, "restEncoder");
}
@Override
protected void generateEventStreamSerializers(
GenerationContext context,
UnionShape eventUnion,
Set<EventStreamInfo> eventStreamInfos) {
Model model = context.getModel();
AwsEventStreamUtils.generateEventStreamSerializer(context, eventUnion);
var memberShapes = eventUnion.members().stream()
.filter(ms -> ms.getMemberTrait(model, ErrorTrait.class).isEmpty())
.collect(Collectors.toCollection(TreeSet::new));
final var eventDocumentShapes = new TreeSet<Shape>();
for (MemberShape member : memberShapes) {
var targetShape = model.expectShape(member.getTarget());
if (generatedEventMessageSerializers.contains(targetShape.toShapeId())) {
continue;
}
AwsEventStreamUtils.generateEventMessageSerializer(context, targetShape, (ctx, payloadTarget, operand) -> {
var functionName = ProtocolGenerator.getDocumentSerializerFunctionName(payloadTarget,
ctx.getService(), ctx.getProtocolName());
AwsProtocolUtils.writeJsonEventMessageSerializerDelegator(ctx, functionName, operand,
getDocumentContentType());
});
generatedEventMessageSerializers.add(targetShape.toShapeId());
var hasBindings = targetShape.members().stream()
.filter(ms -> ms.getTrait(EventHeaderTrait.class).isPresent()
|| ms.getTrait(EventPayloadTrait.class).isPresent())
.findAny();
if (hasBindings.isPresent()) {
var payload = targetShape.members().stream()
.filter(ms -> ms.getTrait(EventPayloadTrait.class).isPresent())
.map(ms -> model.expectShape(ms.getTarget()))
.filter(ProtocolUtils::requiresDocumentSerdeFunction)
.findAny();
payload.ifPresent(eventDocumentShapes::add);
continue;
}
eventDocumentShapes.add(targetShape);
}
eventDocumentShapes.addAll(ProtocolUtils.resolveRequiredDocumentShapeSerde(model, eventDocumentShapes));
generateDocumentBodyShapeSerializers(context, eventDocumentShapes);
}
@Override
protected void generateEventStreamDeserializers(
GenerationContext context,
UnionShape eventUnion,
Set<EventStreamInfo> eventStreamInfos) {
var model = context.getModel();
AwsEventStreamUtils.generateEventStreamDeserializer(context, eventUnion);
AwsEventStreamUtils.generateEventStreamExceptionDeserializer(context, eventUnion,
AwsProtocolUtils::writeJsonEventStreamUnknownExceptionDeserializer);
final var eventDocumentShapes = new TreeSet<Shape>();
for (MemberShape shape : eventUnion.members()) {
var targetShape = model.expectShape(shape.getTarget());
if (generatedEventMessageDeserializers.contains(targetShape.toShapeId())) {
continue;
}
generatedEventMessageDeserializers.add(targetShape.toShapeId());
if (shape.getMemberTrait(model, ErrorTrait.class).isPresent()) {
AwsEventStreamUtils.generateEventMessageExceptionDeserializer(context, targetShape,
(ctx, payloadTarget) -> {
AwsProtocolUtils.initializeJsonEventMessageDeserializer(ctx);
var functionName = ProtocolGenerator.getDocumentDeserializerFunctionName(
payloadTarget, ctx.getService(), getProtocolName());
var ctxWriter = ctx.getWriter().get();
ctxWriter.write("v := &$T{}", ctx.getSymbolProvider().toSymbol(payloadTarget))
.openBlock("if err := $L(&v, shape); err != nil {", "}", functionName,
() -> handleDecodeError(ctxWriter))
.write("return v");
});
eventDocumentShapes.add(targetShape);
} else {
AwsEventStreamUtils.generateEventMessageDeserializer(context, targetShape,
(ctx, payloadTarget, operand) -> {
AwsProtocolUtils.initializeJsonEventMessageDeserializer(ctx);
var functionName = ProtocolGenerator.getDocumentDeserializerFunctionName(
payloadTarget, ctx.getService(), ctx.getProtocolName());
var ctxWriter = ctx.getWriter().get();
ctxWriter.openBlock("if err := $L(&$L, shape); err != nil {", "}", functionName, operand,
() -> handleDecodeError(ctxWriter))
.write("return nil");
});
var hasBindings = targetShape.members().stream()
.filter(ms -> ms.getTrait(EventHeaderTrait.class).isPresent()
|| ms.getTrait(EventPayloadTrait.class).isPresent())
.findAny();
if (hasBindings.isPresent()) {
var payload = targetShape.members().stream()
.filter(ms -> ms.getTrait(EventPayloadTrait.class).isPresent())
.map(ms -> model.expectShape(ms.getTarget()))
.filter(ProtocolUtils::requiresDocumentSerdeFunction)
.findAny();
payload.ifPresent(eventDocumentShapes::add);
continue;
}
eventDocumentShapes.add(targetShape);
}
}
eventDocumentShapes.addAll(ProtocolUtils.resolveRequiredDocumentShapeSerde(model, eventDocumentShapes));
generateDocumentBodyShapeDeserializers(context, eventDocumentShapes);
}
}
| 8,305 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsHttpPresignURLClientGenerator.java | /*
* 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.aws.go.codegen;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import software.amazon.smithy.aws.go.codegen.customization.AwsCustomGoDependency;
import software.amazon.smithy.aws.go.codegen.customization.PresignURLAutoFill;
import software.amazon.smithy.aws.traits.ServiceTrait;
import software.amazon.smithy.aws.traits.protocols.AwsQueryTrait;
import software.amazon.smithy.aws.traits.protocols.Ec2QueryTrait;
import software.amazon.smithy.codegen.core.Symbol;
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.OperationGenerator;
import software.amazon.smithy.go.codegen.SmithyGoDependency;
import software.amazon.smithy.go.codegen.SymbolUtils;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.knowledge.TopDownIndex;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.traits.StreamingTrait;
import software.amazon.smithy.utils.MapUtils;
import software.amazon.smithy.utils.SetUtils;
/**
* AwsHttpPresignURLClientGenerator class is a runtime plugin integration class
* that generates code for presign URL clients and associated presign operations.
* <p>
* This class pulls in a static list from PresignURLAutofill customization which
* rely on the generated presigned url client and operation. This is done to
* deduplicate the listing but make this class dependent on presence of PresignURLAutofill
* class as a composition.
*/
public class AwsHttpPresignURLClientGenerator implements GoIntegration {
// constants
private static final String CONVERT_TO_PRESIGN_MIDDLEWARE_NAME = "convertToPresignMiddleware";
private static final String CONVERT_TO_PRESIGN_TYPE_NAME = "presignConverter";
private static final String NOP_HTTP_CLIENT_OPTION_FUNC_NAME = "withNopHTTPClientAPIOption";
private static final String PRESIGN_CLIENT = "PresignClient";
private static final Symbol presignClientSymbol = buildSymbol(PRESIGN_CLIENT, true);
private static final String NEW_CLIENT = "NewPresignClient";
private static final String PRESIGN_OPTIONS = "PresignOptions";
private static final Symbol presignOptionsSymbol = buildSymbol(PRESIGN_OPTIONS, true);
private static final String PRESIGN_OPTIONS_FROM_CLIENT_OPTIONS = "WithPresignClientFromClientOptions";
private static final String PRESIGN_OPTIONS_FROM_EXPIRES = "WithPresignExpires";
private static final Symbol presignerInterfaceSymbol = SymbolUtils.createPointableSymbolBuilder(
"HTTPPresignerV4"
).build();
private static final Symbol presignerV4aInterfaceSymbol = SymbolUtils.createPointableSymbolBuilder(
"httpPresignerV4a"
).build();
private static final Symbol v4NewPresignerSymbol = SymbolUtils.createPointableSymbolBuilder(
"NewSigner", AwsGoDependency.AWS_SIGNER_V4
).build();
private static final Symbol v4PresignedHTTPRequestSymbol = SymbolUtils.createPointableSymbolBuilder(
"PresignedHTTPRequest", AwsGoDependency.AWS_SIGNER_V4
).build();
// constant map with service to list of operation for which presignedURL client and operation must be generated.
private static final Map<ShapeId, Set<ShapeId>> presignedClientMap = MapUtils.of(
ShapeId.from("com.amazonaws.s3#AmazonS3"), SetUtils.of(
ShapeId.from("com.amazonaws.s3#GetObject"),
ShapeId.from("com.amazonaws.s3#PutObject"),
ShapeId.from("com.amazonaws.s3#UploadPart"),
ShapeId.from("com.amazonaws.s3#HeadObject"),
ShapeId.from("com.amazonaws.s3#HeadBucket"),
ShapeId.from("com.amazonaws.s3#DeleteObject"),
ShapeId.from("com.amazonaws.s3#DeleteBucket")
),
ShapeId.from("com.amazonaws.sts#AWSSecurityTokenServiceV20110615"), SetUtils.of(
ShapeId.from("com.amazonaws.sts#GetCallerIdentity"),
ShapeId.from("com.amazonaws.sts#AssumeRole")
),
ShapeId.from("com.amazonaws.polly#Parrot_v1"), SetUtils.of(
ShapeId.from("com.amazonaws.polly#SynthesizeSpeech")
)
);
// map of service to list of operations for which presignedURL client and operation should
// be generated.
private final Map<ShapeId, Set<ShapeId>> PRESIGNER_MAP = new TreeMap<>();
private static final String addAsUnsignedPayloadName(String operationName) {
return String.format("add%sPayloadAsUnsigned", operationName);
}
// build pointable symbols
private static Symbol buildSymbol(String name, boolean exported) {
if (!exported) {
name = Character.toLowerCase(name.charAt(0)) + name.substring(1);
}
return SymbolUtils.createPointableSymbolBuilder(name).build();
}
/**
* generates code to iterate thru func optionals and assign value into the dest variable
*
* @param writer GoWriter to write the code to
* @param src variable name that denotes functional options
* @param dest variable in which result of processed functional options are stored
*/
private static final void processFunctionalOptions(
GoWriter writer,
String src,
String dest
) {
writer.openBlock("for _, fn := range $L {", "}", src, () -> {
writer.write("fn(&$L)", dest);
}).insertTrailingNewline();
}
@Override
public void processFinalizedModel(GoSettings settings, Model model) {
PRESIGNER_MAP.putAll(presignedClientMap);
// update map for presign client/operation generation to include
// service/operations that use PresignURLAutoFill customization class.
Map<ShapeId, Set<ShapeId>> autofillMap = PresignURLAutoFill.SERVICE_TO_OPERATION_MAP;
for (ShapeId service : autofillMap.keySet()) {
if (!PRESIGNER_MAP.containsKey(service)) {
PRESIGNER_MAP.put(service, autofillMap.get(service));
} else {
Set<ShapeId> operations = new TreeSet<>();
for (ShapeId operation : PRESIGNER_MAP.get(service)) {
operations.add(operation);
}
for (ShapeId operation : autofillMap.get(service)) {
operations.add(operation);
}
PRESIGNER_MAP.put(service, operations);
}
}
}
@Override
public byte getOrder() {
// The associated customization ordering is relative to operation deserializers
// and thus the integration should be added at the end.
return 127;
}
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
ServiceShape serviceShape = settings.getService(model);
if (!PRESIGNER_MAP.containsKey(serviceShape.getId())) {
return;
}
Set<ShapeId> validOperations = PRESIGNER_MAP.get(serviceShape.getId());
if (validOperations.isEmpty()) {
return;
}
// delegator for service shape
goDelegator.useShapeWriter(serviceShape, (writer) -> {
// generate presigner interface
writePresignInterface(writer, model, symbolProvider, serviceShape);
// generate s3 sigv4a presigner interface
writePresignV4aInterface(writer, model, symbolProvider, serviceShape);
// generate presign options and helpers per service
writePresignOptionType(writer, model, symbolProvider, serviceShape);
// generate Presign client per service
writePresignClientType(writer, model, symbolProvider, serviceShape);
// generate client helpers such as copyAPIClient, GetAPIClientOptions()
writePresignClientHelpers(writer, model, symbolProvider, serviceShape);
// generate convertToPresignMiddleware per service
writeConvertToPresignMiddleware(writer, model, symbolProvider, serviceShape);
});
for (OperationShape operationShape : TopDownIndex.of(model).getContainedOperations(serviceShape)) {
if (!validOperations.contains(operationShape.getId())) {
continue;
}
goDelegator.useShapeWriter(operationShape, (writer) -> {
// generate presign operation function for a client operation.
writePresignOperationFunction(writer, model, symbolProvider, serviceShape, operationShape);
// generate s3 unsigned payload middleware helper
writeS3AddAsUnsignedPayloadHelper(writer, model, symbolProvider, serviceShape, operationShape);
});
}
}
private void writePresignOperationFunction(
GoWriter writer,
Model model,
SymbolProvider symbolProvider,
ServiceShape serviceShape,
OperationShape operationShape
) {
Symbol operationSymbol = symbolProvider.toSymbol(operationShape);
Shape operationInputShape = model.expectShape(operationShape.getInput().get());
Symbol operationInputSymbol = symbolProvider.toSymbol(operationInputShape);
writer.writeDocs(
String.format(
"Presign%s is used to generate a presigned HTTP Request which contains presigned URL, signed headers "
+ "and HTTP method used.", operationSymbol.getName())
);
writer.openBlock(
"func (c *$T) Presign$T(ctx context.Context, params $P, optFns ...func($P)) "
+ "($P, error) {", "}", presignClientSymbol, operationSymbol,
operationInputSymbol, presignOptionsSymbol, v4PresignedHTTPRequestSymbol,
() -> {
writer.write("if params == nil { params = &$T{} }", operationInputSymbol).insertTrailingNewline();
// process presignerOptions
writer.write("options := c.options.copy()");
processFunctionalOptions(writer, "optFns", "options");
writer.write("clientOptFns := append(options.ClientOptions, $L)", NOP_HTTP_CLIENT_OPTION_FUNC_NAME);
writer.write("");
writer.openBlock("result, _, err := c.client.invokeOperation(ctx, $S, params, clientOptFns,", ")",
operationSymbol.getName(), () -> {
writer.write("c.client.$L,", OperationGenerator
.getAddOperationMiddlewareFuncName(operationSymbol));
writer.write("$L(options).$L,", CONVERT_TO_PRESIGN_TYPE_NAME,
CONVERT_TO_PRESIGN_MIDDLEWARE_NAME);
// we should remove Content-Type header if input is a stream and
// payload is empty/nil stream.
if (operationInputShape.members().stream().anyMatch(memberShape -> {
return memberShape.getMemberTrait(model, StreamingTrait.class).isPresent();
})) {
writer.addUseImports(SmithyGoDependency.SMITHY_MIDDLEWARE);
writer.addUseImports(AwsGoDependency.AWS_MIDDLEWARE);
Symbol removeContentTypeHeader = SymbolUtils.createValueSymbolBuilder(
"RemoveContentTypeHeader", AwsGoDependency.AWS_HTTP_TRANSPORT
).build();
writer.openBlock("func(stack *middleware.Stack, options Options) error {", "},",
() -> {
writer.write("return $T(stack)", removeContentTypeHeader);
});
}
// s3 needs to add a middleware to switch to using unsigned payload .
if (isS3ServiceShape(model, serviceShape)) {
writer.write("$L,", addAsUnsignedPayloadName(operationSymbol.getName()));
}
});
writer.write("if err != nil { return nil, err }");
writer.write("");
writer.write("out := result.($P)", v4PresignedHTTPRequestSymbol);
writer.write("return out, nil");
});
writer.write("");
}
private void writeS3AddAsUnsignedPayloadHelper(
GoWriter writer,
Model model,
SymbolProvider symbolProvider,
ServiceShape serviceShape,
OperationShape operationShape
) {
// if service is not s3, return
if (!isS3ServiceShape(model, serviceShape)) {
return;
}
Symbol operationSymbol = symbolProvider.toSymbol(operationShape);
Shape operationInputShape = model.expectShape(operationShape.getInput().get());
writer.openBlock("func $L(stack $P, options Options) error {", "}",
addAsUnsignedPayloadName(operationSymbol.getName()),
SymbolUtils.createPointableSymbolBuilder("Stack", SmithyGoDependency.SMITHY_MIDDLEWARE).build(),
() -> {
writer.addUseImports(AwsGoDependency.AWS_SIGNER_V4);
writer.write("v4.RemoveContentSHA256HeaderMiddleware(stack)");
writer.write("v4.RemoveComputePayloadSHA256Middleware(stack)");
writer.write("return $T(stack)", SymbolUtils.createValueSymbolBuilder(
"AddUnsignedPayloadMiddleware", AwsGoDependency.AWS_SIGNER_V4).build());
});
writer.write("");
}
/**
* generates a helper to mutate request middleware stack in favor of generating a presign URL request
*
* @param writer the writer to write to
* @param model the service model
* @param symbolProvider the symbol provider
* @param serviceShape the service for which helper is generated
*/
private void writeConvertToPresignMiddleware(
GoWriter writer,
Model model,
SymbolProvider symbolProvider,
ServiceShape serviceShape
) {
Symbol smithyStack = SymbolUtils.createPointableSymbolBuilder("Stack", SmithyGoDependency.SMITHY_MIDDLEWARE)
.build();
writer.write("type $L $T", CONVERT_TO_PRESIGN_TYPE_NAME, presignOptionsSymbol);
writer.openBlock("func (c $L) $L(stack $P, options Options) (err error) {", "}",
CONVERT_TO_PRESIGN_TYPE_NAME,
CONVERT_TO_PRESIGN_MIDDLEWARE_NAME,
smithyStack,
() -> {
Symbol smithyAfter = SymbolUtils.createValueSymbolBuilder("After",
SmithyGoDependency.SMITHY_MIDDLEWARE)
.build();
// Middleware to remove
Symbol requestInvocationID = SymbolUtils.createPointableSymbolBuilder(
"ClientRequestID",
AwsGoDependency.AWS_MIDDLEWARE)
.build();
Symbol presignMiddleware = SymbolUtils.createValueSymbolBuilder("NewPresignHTTPRequestMiddleware",
AwsGoDependency.AWS_SIGNER_V4)
.build();
// Middleware to add
writer.write("stack.Finalize.Clear()");
writer.write("stack.Deserialize.Clear()");
writer.write("stack.Build.Remove(($P)(nil).ID())", requestInvocationID);
writer.write("stack.Build.Remove($S)", "UserAgent");
Symbol middlewareOptionsSymbol = SymbolUtils.createValueSymbolBuilder(
"PresignHTTPRequestMiddlewareOptions", AwsGoDependency.AWS_SIGNER_V4).build();
writer.openBlock("pmw := $T($T{", "})", presignMiddleware, middlewareOptionsSymbol, () -> {
writer.write("CredentialsProvider: options.$L,", AddAwsConfigFields.CREDENTIALS_CONFIG_NAME);
writer.write("Presigner: c.Presigner,");
writer.write("LogSigning: options.$L.IsSigning(),", AddAwsConfigFields.LOG_MODE_CONFIG_NAME);
});
writer.write("err = stack.Finalize.Add(pmw, $T)", smithyAfter);
writer.write("if err != nil { return err }");
// Add the default content-type remover middleware
writer.openBlock("if err = $T(stack); err != nil {", "}",
SymbolUtils.createValueSymbolBuilder("AddNoPayloadDefaultContentTypeRemover",
SmithyGoDependency.SMITHY_HTTP_TRANSPORT).build(),
() -> {
writer.write("return err");
});
// if protocol used is ec2query or query or if service is polly
if (serviceShape.hasTrait(AwsQueryTrait.ID) || serviceShape.hasTrait(Ec2QueryTrait.ID) || isPollyServiceShape(serviceShape)) {
// presigned url should convert to Get request
Symbol queryAsGetMiddleware = SymbolUtils.createValueSymbolBuilder("AddAsGetRequestMiddleware",
AwsGoDependency.AWS_QUERY_PROTOCOL).build();
writer.writeDocs("convert request to a GET request");
writer.write("err = $T(stack)", queryAsGetMiddleware);
writer.write("if err != nil { return err }");
}
// polly presigner needs to serialize input param into query string
if (isPollyServiceShape(serviceShape)) {
Symbol serializeInputMiddleware = SymbolUtils.createValueSymbolBuilder("AddPresignSynthesizeSpeechMiddleware",
AwsGoDependency.AWS_QUERY_PROTOCOL).build();
writer.writeDocs("use query encoder to encode GET request query string");
writer.write("err = AddPresignSynthesizeSpeechMiddleware(stack)");
writer.write("if err != nil { return err }");
}
// s3 service needs expires and sets unsignedPayload if input is stream
if (isS3ServiceShape(model, serviceShape)) {
writer.write("");
writer.write("// add multi-region access point presigner");
// ==== multi-region access point support
Symbol PresignConstructor = SymbolUtils.createValueSymbolBuilder(
"NewPresignHTTPRequestMiddleware", AwsCustomGoDependency.S3_CUSTOMIZATION
).build();
Symbol PresignOptions = SymbolUtils.createValueSymbolBuilder(
"PresignHTTPRequestMiddlewareOptions", AwsCustomGoDependency.S3_CUSTOMIZATION
).build();
Symbol RegisterPresigningMiddleware = SymbolUtils.createValueSymbolBuilder(
"RegisterPreSigningMiddleware", AwsCustomGoDependency.S3_CUSTOMIZATION
).build();
writer.openBlock("signermv := $T($T{", "})",
PresignConstructor, PresignOptions, () -> {
writer.write("CredentialsProvider : options.Credentials,");
writer.write("V4Presigner : c.Presigner,");
writer.write("V4aPresigner : c.presignerV4a,");
writer.write("LogSigning : options.ClientLogMode.IsSigning(),");
});
writer.write("err = $T(stack, signermv)", RegisterPresigningMiddleware);
writer.write("if err != nil { return err }");
writer.write("");
// =======
writer.openBlock("if c.Expires < 0 {", "}", () -> {
writer.addUseImports(SmithyGoDependency.FMT);
writer.write(
"return fmt.Errorf(\"presign URL duration must be 0 or greater, %v\", c.Expires)");
});
Symbol expiresAsHeaderMiddleware = SymbolUtils.createValueSymbolBuilder(
"AddExpiresOnPresignedURL",
AwsCustomGoDependency.S3_CUSTOMIZATION).build();
writer.writeDocs("add middleware to set expiration for s3 presigned url, "
+ " if expiration is set to 0, this middleware sets a default expiration of 900 seconds");
writer.write("err = stack.Build.Add(&$T{ Expires: c.Expires, }, middleware.After)",
expiresAsHeaderMiddleware);
writer.write("if err != nil { return err }");
}
Symbol addAsPresignMiddlewareSymbol = SymbolUtils.createValueSymbolBuilder(
"AddAsIsPresigingMiddleware",
AwsCustomGoDependency.PRESIGNEDURL_CUSTOMIZATION).build();
writer.write("err = $T(stack)", addAsPresignMiddlewareSymbol);
writer.write("if err != nil { return err }");
writer.write("return nil");
}).insertTrailingNewline();
}
/**
* Writes the Presign client's type and methods.
*
* @param writer writer to write to
*/
private void writePresignClientType(
GoWriter writer,
Model model,
SymbolProvider symbolProvider,
ServiceShape serviceShape
) {
writer.addUseImports(SmithyGoDependency.CONTEXT);
writer.addUseImports(AwsGoDependency.AWS_SIGNER_V4);
writer.writeDocs(String.format("%s represents the presign url client", PRESIGN_CLIENT));
writer.openBlock("type $T struct {", "}", presignClientSymbol, () -> {
writer.write("client *Client");
writer.write("options $T", presignOptionsSymbol);
});
writer.write("");
// generate NewPresignClient
writer.writeDocs(
String.format("%s generates a presign client using provided API Client and presign options",
NEW_CLIENT)
);
writer.openBlock("func $L(c *Client, optFns ...func($P)) $P {", "}",
NEW_CLIENT, presignOptionsSymbol, presignClientSymbol, () -> {
writer.write("var options $T", presignOptionsSymbol);
processFunctionalOptions(writer, "optFns", "options");
writer.openBlock("if len(options.ClientOptions) != 0 {", "}", () -> {
writer.write("c = New(c.options, options.ClientOptions...)");
});
writer.write("");
writer.openBlock("if options.Presigner == nil {", "}", () -> {
writer.write("options.Presigner = $L(c.options)", AwsSignatureVersion4.NEW_SIGNER_FUNC_NAME);
});
writer.write("");
if (isS3ServiceShape(model, serviceShape)) {
writer.openBlock("if options.presignerV4a == nil {", "}", () -> {
writer.write("options.presignerV4a = $L(c.options)",
AwsSignatureVersion4.NEW_SIGNER_V4A_FUNC_NAME);
});
writer.write("");
}
writer.openBlock("return &$L{", "}", presignClientSymbol, () -> {
writer.write("client: c,");
writer.write("options: options,");
});
});
writer.write("");
}
/**
* Writes the Presign client's helper methods.
*
* @param writer writer to write to
*/
private void writePresignClientHelpers(
GoWriter writer,
Model model,
SymbolProvider symbolProvider,
ServiceShape serviceShape
) {
// Helper function for NopClient
writer.openBlock("func $L(o *Options) {", "}", NOP_HTTP_CLIENT_OPTION_FUNC_NAME, () -> {
Symbol nopClientSymbol = SymbolUtils.createPointableSymbolBuilder("NopClient",
SmithyGoDependency.SMITHY_HTTP_TRANSPORT)
.build();
writer.write("o.HTTPClient = $T{}", nopClientSymbol);
});
writer.write("");
}
/**
* Writes the presigner interface used by the presign url client
*/
public void writePresignInterface(
GoWriter writer,
Model model,
SymbolProvider symbolProvider,
ServiceShape serviceShape
) {
Symbol signerOptionsSymbol = SymbolUtils.createPointableSymbolBuilder("SignerOptions",
AwsGoDependency.AWS_SIGNER_V4).build();
writer.writeDocs(
String.format("%s represents presigner interface used by presign url client",
presignerInterfaceSymbol.getName())
);
writer.openBlock("type $T interface {", "}", presignerInterfaceSymbol, () -> {
writer.write("PresignHTTP(");
writer.write("ctx context.Context, credentials aws.Credentials, r *http.Request,");
writer.write("payloadHash string, service string, region string, signingTime time.Time,");
writer.write("optFns ...func($P),", signerOptionsSymbol);
writer.write(") (url string, signedHeader http.Header, err error)");
});
writer.write("");
}
/**
* Writes the presigner sigv4a interface used by the presign url client
*/
public void writePresignV4aInterface(
GoWriter writer,
Model model,
SymbolProvider symbolProvider,
ServiceShape serviceShape
) {
if (!isS3ServiceShape(model, serviceShape)) {
return;
}
Symbol signerOptionsSymbol = SymbolUtils.createPointableSymbolBuilder(
"SignerOptions", AwsGoDependency.INTERNAL_SIGV4A).build();
writer.writeDocs(
String.format("%s represents sigv4a presigner interface used by presign url client",
presignerV4aInterfaceSymbol.getName())
);
writer.openBlock("type $T interface {", "}", presignerV4aInterfaceSymbol, () -> {
writer.write("PresignHTTP(");
writer.write("ctx context.Context, credentials v4a.Credentials, r *http.Request,");
writer.write("payloadHash string, service string, regionSet []string, signingTime time.Time,");
writer.write("optFns ...func($P),", signerOptionsSymbol);
writer.write(") (url string, signedHeader http.Header, err error)");
});
writer.write("");
}
/**
* Writes the Presign client's type and methods.
*
* @param writer writer to write to
*/
public void writePresignOptionType(
GoWriter writer,
Model model,
SymbolProvider symbolProvider,
ServiceShape serviceShape
) {
writer.addUseImports(SmithyGoDependency.CONTEXT);
// generate presign options
writer.writeDocs(String.format("%s represents the presign client options", PRESIGN_OPTIONS));
writer.openBlock("type $T struct {", "}", presignOptionsSymbol, () -> {
writer.write("");
writer.writeDocs(
"ClientOptions are list of functional options to mutate client options used by the presign client."
);
writer.write("ClientOptions []func(*Options)");
writer.write("");
writer.writeDocs("Presigner is the presigner used by the presign url client");
writer.write("Presigner $T", presignerInterfaceSymbol);
// s3 service has an additional Expires options
if (isS3ServiceShape(model, serviceShape)) {
writer.write("");
writer.writeDocs(
String.format("Expires sets the expiration duration for the generated presign url. This should "
+ "be the duration in seconds the presigned URL should be considered valid for. If "
+ "not set or set to zero, presign url would default to expire after 900 seconds."
)
);
writer.write("Expires time.Duration");
writer.write("");
writer.writeDocs("presignerV4a is the presigner used by the presign url client");
writer.write("presignerV4a $T", presignerV4aInterfaceSymbol);
}
});
writer.openBlock("func (o $T) copy() $T {", "}", presignOptionsSymbol, presignOptionsSymbol, () -> {
writer.write("clientOptions := make([]func(*Options), len(o.ClientOptions))");
writer.write("copy(clientOptions, o.ClientOptions)");
writer.write("o.ClientOptions = clientOptions");
writer.write("return o");
});
// generate WithPresignClientFromClientOptions Helper
Symbol presignOptionsFromClientOptionsInternal = buildSymbol(PRESIGN_OPTIONS_FROM_CLIENT_OPTIONS, false);
writer.writeDocs(
String.format("%s is a helper utility to retrieve a function that takes PresignOption as input",
PRESIGN_OPTIONS_FROM_CLIENT_OPTIONS)
);
writer.openBlock("func $L(optFns ...func(*Options)) func($P) {", "}",
PRESIGN_OPTIONS_FROM_CLIENT_OPTIONS, presignOptionsSymbol, () -> {
writer.write("return $L(optFns).options", presignOptionsFromClientOptionsInternal.getName());
});
writer.insertTrailingNewline();
writer.write("type $L []func(*Options)", presignOptionsFromClientOptionsInternal.getName());
writer.openBlock("func (w $L) options (o $P) {", "}",
presignOptionsFromClientOptionsInternal.getName(), presignOptionsSymbol, () -> {
writer.write("o.ClientOptions = append(o.ClientOptions, w...)");
}).insertTrailingNewline();
// s3 specific helpers
if (isS3ServiceShape(model, serviceShape)) {
// generate WithPresignExpires Helper
Symbol presignOptionsFromExpiresInternal = buildSymbol(PRESIGN_OPTIONS_FROM_EXPIRES, false);
writer.writeDocs(String.format(
"%s is a helper utility to append Expires value on presign options optional function",
PRESIGN_OPTIONS_FROM_EXPIRES));
writer.openBlock("func $L(dur time.Duration) func($P) {", "}",
PRESIGN_OPTIONS_FROM_EXPIRES, presignOptionsSymbol, () -> {
writer.write("return $L(dur).options", presignOptionsFromExpiresInternal.getName());
});
writer.insertTrailingNewline();
writer.write("type $L time.Duration", presignOptionsFromExpiresInternal.getName());
writer.openBlock("func (w $L) options (o $P) {", "}",
presignOptionsFromExpiresInternal.getName(), presignOptionsSymbol, () -> {
writer.write("o.Expires = time.Duration(w)");
}).insertTrailingNewline();
}
}
private final boolean isS3ServiceShape(Model model, ServiceShape service) {
String serviceId = service.expectTrait(ServiceTrait.class).getSdkId();
return serviceId.equalsIgnoreCase("S3");
}
private final boolean isPollyServiceShape(ServiceShape service) {
return service.expectTrait(ServiceTrait.class).getSdkId().equalsIgnoreCase("Polly");
}
}
| 8,306 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsEndpointConfigTestGenerator.java | package software.amazon.smithy.aws.go.codegen;
import static software.amazon.smithy.go.codegen.GoWriter.goTemplate;
import software.amazon.smithy.aws.traits.ServiceTrait;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.go.codegen.GoSettings;
import software.amazon.smithy.go.codegen.TriConsumer;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.utils.MapUtils;
import software.amazon.smithy.go.codegen.GoWriter;
import software.amazon.smithy.go.codegen.SmithyGoDependency;
import software.amazon.smithy.go.codegen.SymbolUtils;
import java.util.Map;
import java.util.function.Consumer;
/*
* This class generates service specific tests for resolving configured endpoints.
*/
public class AwsEndpointConfigTestGenerator implements GoIntegration {
private Map<String, Object> commonCodegenArgs;
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
TriConsumer<String, String, Consumer<GoWriter>> writerFactory
) {
String sdkId = settings.getService(model).expectTrait(ServiceTrait.class).getSdkId();
this.commonCodegenArgs = MapUtils.of(
"envSdkId", sdkId.toUpperCase().replaceAll(" ", "_"),
"configSdkId", sdkId.toLowerCase().replaceAll(" ", "_"),
"urlSdkId", sdkId.toLowerCase().replaceAll(" ", "-"),
"testing", SymbolUtils.createPointableSymbolBuilder("T", SmithyGoDependency.TESTING).build(),
"awsString", SymbolUtils.createValueSymbolBuilder("String", AwsGoDependency.AWS_CORE).build(),
"context", SymbolUtils.createValueSymbolBuilder("Context", SmithyGoDependency.CONTEXT).build()
);
writerFactory.accept("endpoints_config_test.go", settings.getModuleName(), writer -> {
writer.write("$W", generate());
});
}
private GoWriter.Writable generate() {
return (GoWriter w) -> {
w.write(
"""
$W
$W
""",
generateMockProviders(),
generateTestFunction()
);
};
}
private GoWriter.Writable generateMockProviders() {
return goTemplate(
"""
type mockConfigSource struct {
global string
service string
ignore bool
}
// GetIgnoreConfiguredEndpoints is used in knowing when to disable configured
// endpoints feature.
func (m mockConfigSource) GetIgnoreConfiguredEndpoints($context:T) (bool, bool, error) {
return m.ignore, m.ignore, nil
}
// GetServiceBaseEndpoint is used to retrieve a normalized SDK ID for use
// with configured endpoints.
func (m mockConfigSource) GetServiceBaseEndpoint(ctx $context:T, sdkID string) (string, bool, error) {
if m.service != "" {
return m.service, true, nil
}
return "", false, nil
}
""",
this.commonCodegenArgs
);
}
private GoWriter.Writable generateTestFunction() {
return (GoWriter w) -> {
w.write(
"""
func TestResolveBaseEndpoint(t $P) {
$W
$W
}
""",
SymbolUtils.createPointableSymbolBuilder("T", SmithyGoDependency.TESTING).build(),
generateCases(),
generateTests()
);
};
}
private GoWriter.Writable generateCases() {
return goTemplate(
"""
cases := map[string]struct {
envGlobal string
envService string
envIgnore bool
configGlobal string
configService string
configIgnore bool
clientEndpoint *string
expectURL *string
}{
"env ignore": {
envGlobal: "https://env-global.dev",
envService: "https://env-$urlSdkId:L.dev",
envIgnore: true,
configGlobal: "http://config-global.dev",
configService: "http://config-$urlSdkId:L.dev",
expectURL: nil,
},
"env global": {
envGlobal: "https://env-global.dev",
configGlobal: "http://config-global.dev",
configService: "http://config-$urlSdkId:L.dev",
expectURL: aws.String("https://env-global.dev"),
},
"env service": {
envGlobal: "https://env-global.dev",
envService: "https://env-$urlSdkId:L.dev",
configGlobal: "http://config-global.dev",
configService: "http://config-$urlSdkId:L.dev",
expectURL: aws.String("https://env-$urlSdkId:L.dev"),
},
"config ignore": {
envGlobal: "https://env-global.dev",
envService: "https://env-$urlSdkId:L.dev",
configGlobal: "http://config-global.dev",
configService: "http://config-$urlSdkId:L.dev",
configIgnore: true,
expectURL: nil,
},
"config global": {
configGlobal: "http://config-global.dev",
expectURL: aws.String("http://config-global.dev"),
},
"config service": {
configGlobal: "http://config-global.dev",
configService: "http://config-$urlSdkId:L.dev",
expectURL: aws.String("http://config-$urlSdkId:L.dev"),
},
"client": {
envGlobal: "https://env-global.dev",
envService: "https://env-$urlSdkId:L.dev",
configGlobal: "http://config-global.dev",
configService: "http://config-$urlSdkId:L.dev",
clientEndpoint: aws.String("https://client-$urlSdkId:L.dev"),
expectURL: aws.String("https://client-$urlSdkId:L.dev"),
},
}
""",
this.commonCodegenArgs
);
}
private GoWriter.Writable generateTests() {
return goTemplate(
"""
for name, c := range cases {
t.Run(name, func(t $testing:P) {
$clearEnv:T()
awsConfig := $awsConfig:T{}
ignore := c.envIgnore || c.configIgnore
if c.configGlobal != "" && !ignore {
awsConfig.BaseEndpoint = $awsString:T(c.configGlobal)
}
if c.envGlobal != "" {
t.Setenv("AWS_ENDPOINT_URL", c.envGlobal)
if !ignore {
awsConfig.BaseEndpoint = $awsString:T(c.envGlobal)
}
}
if c.envService != "" {
t.Setenv("AWS_ENDPOINT_URL_$envSdkId:L", c.envService)
}
awsConfig.ConfigSources = []interface{}{
mockConfigSource{
global: c.envGlobal,
service: c.envService,
ignore: c.envIgnore,
},
mockConfigSource{
global: c.configGlobal,
service: c.configService,
ignore: c.configIgnore,
},
}
client := NewFromConfig(awsConfig, func (o *Options) {
if c.clientEndpoint != nil {
o.BaseEndpoint = c.clientEndpoint
}
})
if e, a := c.expectURL, client.options.BaseEndpoint; !$deepEqual:T(e, a) {
t.Errorf("expect endpoint %v , got %v", e, a)
}
})
}
""",
this.commonCodegenArgs,
MapUtils.of(
"clearEnv", SymbolUtils.createValueSymbolBuilder("Clearenv", SmithyGoDependency.OS).build(),
"awsConfig", SymbolUtils.createValueSymbolBuilder("Config", AwsGoDependency.AWS_CORE).build(),
"deepEqual", SymbolUtils.createValueSymbolBuilder("DeepEqual", SmithyGoDependency.REFLECT).build()
)
);
}
}
| 8,307 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/XmlProtocolUtils.java | package software.amazon.smithy.aws.go.codegen;
import java.util.Collection;
import java.util.Optional;
import software.amazon.smithy.aws.go.codegen.customization.AwsCustomGoDependency;
import software.amazon.smithy.aws.traits.ServiceTrait;
import software.amazon.smithy.aws.traits.protocols.RestXmlTrait;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.go.codegen.GoValueAccessUtils;
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.Synthetic;
import software.amazon.smithy.go.codegen.integration.ProtocolGenerator;
import software.amazon.smithy.go.codegen.knowledge.GoPointableIndex;
import software.amazon.smithy.model.shapes.MemberShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.traits.EnumTrait;
import software.amazon.smithy.model.traits.TimestampFormatTrait;
import software.amazon.smithy.model.traits.XmlAttributeTrait;
import software.amazon.smithy.model.traits.XmlNameTrait;
import software.amazon.smithy.model.traits.XmlNamespaceTrait;
public final class XmlProtocolUtils {
private XmlProtocolUtils() {
}
/**
* generateXMLStartElement generates the XML start element for a shape. It is used to generate smithy xml's startElement.
*
* @param context is the generation context.
* @param shape is the Shape for which xml start element is to be generated.
* @param dst is the operand name which holds the generated start element.
* @param inputSrc is the input variable for the shape with values to be serialized.
*/
public static void generateXMLStartElement(
ProtocolGenerator.GenerationContext context, Shape shape, String dst, String inputSrc
) {
GoWriter writer = context.getWriter().get();
String attrName = dst + "Attr";
generateXmlNamespaceAndAttributes(context, shape, attrName, inputSrc);
writer.openBlock("$L := smithyxml.StartElement{ ", "}", dst, () -> {
writer.openBlock("Name:smithyxml.Name{", "},", () -> {
writer.write("Local: $S,", getSerializedXMLShapeName(context, shape));
});
writer.write("Attr : $L,", attrName);
});
}
/**
* Generates XML Start element for a document shape marked as a payload.
*
* @param context is the generation context.
* @param memberShape is the payload as document member shape
* @param dst is the operand name which holds the generated start element.
* @param inputSrc is the input variable for the shape with values to be serialized.
*/
public static void generatePayloadAsDocumentXMLStartElement(
ProtocolGenerator.GenerationContext context, MemberShape memberShape, String dst, String inputSrc
) {
GoWriter writer = context.getWriter().get();
String attrName = dst + "Attr";
Shape targetShape = context.getModel().expectShape(memberShape.getTarget());
generateXmlNamespaceAndAttributes(context, targetShape, attrName, inputSrc);
writer.openBlock("$L := smithyxml.StartElement{ ", "}", dst, () -> {
writer.openBlock("Name:smithyxml.Name{", "},", () -> {
String name = memberShape.getMemberName();
if (targetShape.isStructureShape()) {
if (memberShape.hasTrait(XmlNameTrait.class)) {
name = getSerializedXMLMemberName(memberShape);
} else {
name = getSerializedXMLShapeName(context, targetShape);
}
}
writer.write("Local: $S,", name);
});
writer.write("Attr : $L,", attrName);
});
}
/**
* Generates XML Attributes as per xmlNamespace and xmlAttribute traits.
*
* @param context is the generation context.
* @param shape is the shape that is decorated with XmlNamespace, XmlAttribute trait.
* @param dst is the operand name which holds the generated xml Attribute value.
* @param inputSrc is the input variable for the shape with values to be put as xml attributes.
*/
private static void generateXmlNamespaceAndAttributes(
ProtocolGenerator.GenerationContext context, Shape shape, String dst, String inputSrc
) {
GoWriter writer = context.getWriter().get();
writer.write("$L := []smithyxml.Attr{}", dst);
Optional<XmlNamespaceTrait> xmlNamespaceTrait = shape.getTrait(XmlNamespaceTrait.class);
if (xmlNamespaceTrait.isPresent()) {
XmlNamespaceTrait namespace = xmlNamespaceTrait.get();
writer.write("$L = append($L, smithyxml.NewNamespaceAttribute($S, $S))",
dst, dst,
namespace.getPrefix().isPresent() ? namespace.getPrefix().get() : "", namespace.getUri()
);
}
// Traverse member shapes to get attributes
if (shape.isMemberShape()) {
MemberShape memberShape = shape.asMemberShape().get();
Shape target = context.getModel().expectShape(memberShape.getTarget());
String memberName = context.getSymbolProvider().toMemberName(memberShape);
String operand = inputSrc + "." + memberName;
generateXmlAttributes(context, target.members(), operand, dst);
} else {
generateXmlAttributes(context, shape.members(), inputSrc, dst);
}
}
private static void generateXmlAttributes(
ProtocolGenerator.GenerationContext context,
Collection<MemberShape> members,
String inputSrc,
String dst
) {
GoWriter writer = context.getWriter().get();
members.forEach(memberShape -> {
if (memberShape.hasTrait(XmlAttributeTrait.class)) {
GoValueAccessUtils.writeIfNonZeroValueMember(context.getModel(), context.getSymbolProvider(),
writer, memberShape, inputSrc, true, memberShape.isRequired(), (operand) -> {
// xml attributes should always be string
String dest = "av";
formatXmlAttributeValueAsString(context, memberShape, operand, dest);
writer.write("$L = append($L, smithyxml.NewAttribute($S, $L))",
dst, dst, getSerializedXMLMemberName(memberShape), dest);
});
}
});
}
// generates code to format xml attributes. If a shape type is timestamp, number, or boolean
// it will be formatted into a string.
private static void formatXmlAttributeValueAsString(
ProtocolGenerator.GenerationContext context,
MemberShape member, String src, String dest
) {
GoWriter writer = context.getWriter().get();
Shape target = context.getModel().expectShape(member.getTarget());
// declare destination variable
writer.write("var $L string", dest);
// Pointable value references need to be dereferenced before being used.
String derefSource = src;
if (GoPointableIndex.of(context.getModel()).isPointable(member)) {
derefSource = "*" + src;
}
if (target.hasTrait(EnumTrait.class)) {
writer.write("$L = string($L)", dest, derefSource);
return;
} else if (target.isStringShape()) {
// create dereferenced copy of pointed to value.
writer.write("$L = $L", dest, derefSource);
return;
}
if (target.isTimestampShape() || target.hasTrait(TimestampFormatTrait.class)) {
TimestampFormatTrait.Format format = member.getMemberTrait(context.getModel(), TimestampFormatTrait.class)
.map(TimestampFormatTrait::getFormat).orElse(TimestampFormatTrait.Format.DATE_TIME);
writer.addUseImports(SmithyGoDependency.SMITHY_TIME);
switch (format) {
case DATE_TIME:
writer.write("$L = smithytime.FormatDateTime($L)", dest, derefSource);
break;
case HTTP_DATE:
writer.write("$L = smithytime.FormatHTTPDate($L)", dest, derefSource);
break;
case EPOCH_SECONDS:
writer.addUseImports(SmithyGoDependency.STRCONV);
writer.write("$L = strconv.FormatFloat(smithytime.FormatEpochSeconds($L), 'f', -1, 64)",
dest, derefSource);
break;
case UNKNOWN:
throw new CodegenException("Unknown timestamp format");
}
return;
}
if (target.isBooleanShape()) {
writer.write(SmithyGoDependency.STRCONV);
writer.write("$L = strconv.FormatBool($L)", dest, derefSource);
return;
}
if (target.isByteShape() || target.isShortShape() || target.isIntegerShape() || target.isLongShape()) {
writer.write(SmithyGoDependency.STRCONV);
writer.write("$L = strconv.FormatInt(int64($L), 10)", dest, derefSource);
return;
}
if (target.isFloatShape()) {
writer.write(SmithyGoDependency.STRCONV);
writer.write("$L = strconv.FormatFloat(float64($L),'f', -1, 32)", dest, derefSource);
return;
}
if (target.isDoubleShape()) {
writer.write(SmithyGoDependency.STRCONV);
writer.write("$L = strconv.FormatFloat($L,'f', -1, 64)", dest, derefSource);
return;
}
if (target.isBigIntegerShape() || target.isBigDecimalShape()) {
throw new CodegenException(String.format("Cannot serialize shape type %s on protocol, shape: %s.",
target.getType(), target.getId()));
}
throw new CodegenException(
"Members serialized as XML attributes can only be of string, number, boolean or timestamp format");
}
/**
* getSerializedXMLMemberName returns a xml member name used for serializing. If a member shape has
* XML name trait, xml name would be given precedence over member name.
*
* @param memberShape is the member shape for which serializer name is queried.
* @return name of a xml member shape used by serializers
*/
private static String getSerializedXMLMemberName(MemberShape memberShape) {
Optional<XmlNameTrait> xmlNameTrait = memberShape.getTrait(XmlNameTrait.class);
return xmlNameTrait.isPresent() ? xmlNameTrait.get().getValue() : memberShape.getMemberName();
}
/**
* getSerializedXMLShapeName returns a xml shape name used for serializing. If a member shape
* has xml name trait, xml name would be given precedence over member name.
* This correctly handles renamed shapes, and returns the original shape name.
*
* @param context is the generation context for which
* @param shape is the Shape for which serializer name is queried.
* @return name of a xml member shape used by serializers.
*/
private static String getSerializedXMLShapeName(ProtocolGenerator.GenerationContext context, Shape shape) {
SymbolProvider symbolProvider = context.getSymbolProvider();
Symbol shapeSymbol = symbolProvider.toSymbol(shape);
String shapeName = shapeSymbol.getName();
ServiceShape service = context.getService();
// check if synthetic shape
Optional<Synthetic> synthOptional = shape.getTrait(Synthetic.class);
if (synthOptional.isPresent()) {
Synthetic synth = synthOptional.get();
if (synth.getArchetype().isPresent()) {
shapeName = synth.getArchetype().get().getName(service);
}
}
// check if shape is member shape
Optional<MemberShape> member = shape.asMemberShape();
if (member.isPresent()) {
return getSerializedXMLMemberName(member.get());
}
return shape.getTrait(XmlNameTrait.class).map(XmlNameTrait::getValue).orElse(shapeName);
}
/**
* initializeXmlDecoder generates stub code to initialize xml decoder.
* Returns nil in case EOF occurs while initializing xml decoder.
*
* @param writer the go writer used to write
* @param bodyLocation the variable used to represent response body
*/
public static void initializeXmlDecoder(GoWriter writer, String bodyLocation) {
initializeXmlDecoder(writer, bodyLocation, "", "nil");
}
/**
* initializeXmlDecoder generates stub code to initialize xml decoder
*
* @param writer the go writer used to write
* @param bodyLocation the variable used to represent response body
* @param returnOnEOF the variable to return in case an EOF error occurs while initializing xml decoder
*/
public static void initializeXmlDecoder(GoWriter writer, String bodyLocation, String returnOnEOF) {
initializeXmlDecoder(writer, bodyLocation, "", returnOnEOF);
}
/**
* initializeXmlDecoder generates stub code to initialize xml decoder
*
* @param writer the go writer used to write
* @param bodyLocation the variable used to represent response body
* @param returnExtras the extra variables to be returned with the wrapped error check statement
* @param returnOnEOF the variable to return in case an EOF error occurs while initializing xml decoder
*/
public static void initializeXmlDecoder(
GoWriter writer, String bodyLocation, String returnExtras, String returnOnEOF
) {
// Use a ring buffer and tee reader to help in pinpointing any deserialization errors.
writer.addUseImports(SmithyGoDependency.SMITHY_IO);
writer.write("var buff [1024]byte");
writer.write("ringBuffer := smithyio.NewRingBuffer(buff[:])");
writer.insertTrailingNewline();
writer.addUseImports(SmithyGoDependency.IO);
writer.addUseImports(SmithyGoDependency.XML);
writer.addUseImports(SmithyGoDependency.SMITHY_XML);
writer.write("body := io.TeeReader($L, ringBuffer)", bodyLocation);
writer.write("rootDecoder := xml.NewDecoder(body)");
writer.write("t, err := smithyxml.FetchRootElement(rootDecoder)");
writer.write("if err == io.EOF { return $L$L}", returnExtras, returnOnEOF);
handleDecodeError(writer, returnExtras);
writer.insertTrailingNewline();
writer.write("decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)");
writer.insertTrailingNewline();
}
/**
* handleDecodeError handles the xml deserialization error wrapping.
*
* @param writer the go writer used to write
* @param returnExtras extra variables to be returned with the wrapped error statement
*/
public static void handleDecodeError(GoWriter writer, String returnExtras) {
writer.addUseImports(SmithyGoDependency.IO);
writer.openBlock("if err != nil {", "}", () -> {
writer.addUseImports(SmithyGoDependency.BYTES);
writer.addUseImports(SmithyGoDependency.SMITHY);
writer.write("var snapshot bytes.Buffer");
writer.write("io.Copy(&snapshot, ringBuffer)");
writer.openBlock("return $L&smithy.DeserializationError {", "}", returnExtras, () -> {
writer.write("Err : fmt.Errorf(\"failed to decode response body, %w\", err),");
writer.write("Snapshot: snapshot.Bytes(),");
});
}).write("");
}
/**
* Generates code to retrieve error code or error message from the error response body
* This method is used indirectly by generateErrorDispatcher to generate operation specific error handling functions
*
* @param context the generation context
* @see <a href="https://smithy.io/2.0/aws/protocols/aws-restxml-protocol.html#error-response-serialization">Rest-XML operation error serialization.</a>
*/
public static void writeXmlErrorMessageCodeDeserializer(ProtocolGenerator.GenerationContext context) {
GoWriter writer = context.getWriter().get();
// Check if service uses isNoErrorWrapping setting
boolean isNoErrorWrapping = context.getService().getTrait(RestXmlTrait.class).map(
RestXmlTrait::isNoErrorWrapping).orElse(false);
ServiceShape service = context.getService();
if (requiresS3Customization(service)) {
Symbol getErrorComponentFunction = SymbolUtils.createValueSymbolBuilder(
"GetErrorResponseComponents",
AwsCustomGoDependency.S3_SHARED_CUSTOMIZATION
).build();
Symbol errorOptions = SymbolUtils.createValueSymbolBuilder(
"ErrorResponseDeserializerOptions",
AwsCustomGoDependency.S3_SHARED_CUSTOMIZATION
).build();
if (isS3Service(service)) {
// s3 service
writer.openBlock("errorComponents, err := $T(errorBody, $T{",
"})", getErrorComponentFunction, errorOptions, () -> {
writer.write("UseStatusCode : true, StatusCode : response.StatusCode,");
});
} else {
// s3 control
writer.openBlock("errorComponents, err := $T(errorBody, $T{",
"})", getErrorComponentFunction, errorOptions, () -> {
writer.write("IsWrappedWithErrorTag: true,");
});
}
writer.write("if err != nil { return err }");
writer.insertTrailingNewline();
writer.openBlock("if hostID := errorComponents.HostID; len(hostID)!=0 {", "}", () -> {
writer.write("s3shared.SetHostIDMetadata(metadata, hostID)");
});
} else {
writer.addUseImports(AwsGoDependency.AWS_XML);
writer.write("errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, $L)", isNoErrorWrapping);
writer.write("if err != nil { return err }");
writer.insertTrailingNewline();
}
writer.addUseImports(AwsGoDependency.AWS_MIDDLEWARE);
writer.openBlock("if reqID := errorComponents.RequestID; len(reqID)!=0 {", "}", () -> {
writer.write("awsmiddleware.SetRequestIDMetadata(metadata, reqID)");
});
writer.insertTrailingNewline();
writer.write("if len(errorComponents.Code) != 0 { errorCode = errorComponents.Code}");
writer.write("if len(errorComponents.Message) != 0 { errorMessage = errorComponents.Message}");
writer.insertTrailingNewline();
writer.write("errorBody.Seek(0, io.SeekStart)");
writer.insertTrailingNewline();
}
// returns true if service is either s3 or s3 control and needs s3 customization
private static boolean requiresS3Customization(ServiceShape service) {
String serviceId = service.expectTrait(ServiceTrait.class).getSdkId();
return serviceId.equalsIgnoreCase("S3") || serviceId.equalsIgnoreCase("S3 Control");
}
private static boolean isS3Service(ServiceShape service) {
String serviceId = service.expectTrait(ServiceTrait.class).getSdkId();
return serviceId.equalsIgnoreCase("S3");
}
}
| 8,308 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AddProtocols.java | package software.amazon.smithy.aws.go.codegen;
import java.util.List;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.go.codegen.integration.HttpProtocolUtils;
import software.amazon.smithy.go.codegen.integration.ProtocolGenerator;
import software.amazon.smithy.go.codegen.integration.RuntimeClientPlugin;
import software.amazon.smithy.utils.ListUtils;
public class AddProtocols implements GoIntegration {
/**
* Gets the sort order of the customization from -128 to 127, with lowest
* executed first.
*
* @return Returns the sort order, defaults to -10.
*/
@Override
public byte getOrder() {
return -10;
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
List<RuntimeClientPlugin> plugins = HttpProtocolUtils.getCloseResponseClientPlugins((model, service) -> {
// All AWS protocols are HTTP based currently. When protocol is added that is not it must be
// excluded if the service is configured for that protocol.
return true;
});
return plugins;
}
@Override
public List<ProtocolGenerator> getProtocolGenerators() {
return ListUtils.of(
new AwsRestJson1(),
new AwsJsonRpc1_0(),
new AwsJsonRpc1_1(),
new AwsRestXml(),
new AwsQuery(),
new Ec2Query()
);
}
}
| 8,309 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/ResolveClientConfigFromSources.java | package software.amazon.smithy.aws.go.codegen;
import java.util.List;
import java.util.logging.Logger;
import software.amazon.smithy.aws.traits.ServiceTrait;
import software.amazon.smithy.aws.traits.clientendpointdiscovery.ClientEndpointDiscoveryTrait;
import software.amazon.smithy.codegen.core.Symbol;
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.GoIntegration;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.utils.ListUtils;
/**
* Registers additional client specific configuration fields
* TODO: This needs to refactored so that we aren't defining "pseudo-config fields"
*/
public class ResolveClientConfigFromSources implements GoIntegration {
private static final Logger LOGGER = Logger.getLogger(AddAwsConfigFields.class.getName());
private static final String CONFIG_SOURCE_CONFIG_NAME = "ConfigSources";
private static final String USE_ARN_REGION_OPTION = "UseARNRegion";
private static final String USE_ARN_REGION_CONFIG_RESOLVER = "resolveUseARNRegion";
private static final String RESOLVE_USE_ARN_REGION = "ResolveUseARNRegion";
private static final String DISABLE_MRAP_OPTION = "DisableMultiRegionAccessPoints";
private static final String DISABLE_MRAP_CONFIG_RESOLVER = "resolveDisableMultiRegionAccessPoints";
private static final String RESOLVE_DISABLE_MRAP = "ResolveDisableMultiRegionAccessPoints";
// EndpointDiscovery options
private static final String ENDPOINT_DISCOVERY_OPTION = "EndpointDiscovery";
private static final Symbol ENDPOINT_DISCOVERY_OPTION_TYPE = SymbolUtils.createValueSymbolBuilder(
"EndpointDiscoveryOptions").build();
// Enable EndpointDiscovery
private static final String ENABLE_ENDPOINT_DISCOVERY_OPTION = "EnableEndpointDiscovery";
private static final String ENABLE_ENDPOINT_DISCOVERY_CONFIG_RESOLVER = "resolveEnableEndpointDiscoveryFromConfigSources";
private static final String RESOLVE_ENABLE_ENDPOINT_DISCOVERY = "ResolveEnableEndpointDiscovery";
// UseDualStack
private static final String DUAL_STACK_ENDPOINT_CONFIG_RESOLVER = "resolveUseDualStackEndpoint";
private static final String RESOLVE_USE_DUAL_STACK_ENDPOINT = "ResolveUseDualStackEndpoint";
private static final String USE_FIPS_ENDPOINT_CONFIG_RESOLVER = "resolveUseFIPSEndpoint";
private static final String RESOLVE_USE_FIPS_ENDPOINT = "ResolveUseFIPSEndpoint";
public static final List<AddAwsConfigFields.AwsConfigField> AWS_CONFIG_FIELDS = ListUtils.of(
AddAwsConfigFields.AwsConfigField.builder()
.name(USE_ARN_REGION_OPTION)
.type(getUniversalSymbol("bool"))
.generatedOnClient(false)
.servicePredicate(ResolveClientConfigFromSources::isS3SharedService)
.awsResolveFunction(SymbolUtils.createValueSymbolBuilder(USE_ARN_REGION_CONFIG_RESOLVER)
.build())
.build(),
AddAwsConfigFields.AwsConfigField.builder()
.name(DISABLE_MRAP_OPTION)
.type(getUniversalSymbol("bool"))
.generatedOnClient(false)
.servicePredicate(ResolveClientConfigFromSources::isS3Service)
.awsResolveFunction(SymbolUtils.createValueSymbolBuilder(DISABLE_MRAP_CONFIG_RESOLVER)
.build())
.build(),
AddAwsConfigFields.AwsConfigField.builder()
.name(ENDPOINT_DISCOVERY_OPTION)
.type(ENDPOINT_DISCOVERY_OPTION_TYPE)
.generatedOnClient(false)
.servicePredicate(ResolveClientConfigFromSources::supportsEndpointDiscovery)
.awsResolveFunction(SymbolUtils.createValueSymbolBuilder(ENABLE_ENDPOINT_DISCOVERY_CONFIG_RESOLVER)
.build())
.build(),
AddAwsConfigFields.AwsConfigField.builder()
.name("EndpointOptions.UseDualStackEndpoint")
.type(SymbolUtils.createPointableSymbolBuilder("bool").build())
.generatedOnClient(false)
.awsResolveFunction(SymbolUtils.createValueSymbolBuilder(DUAL_STACK_ENDPOINT_CONFIG_RESOLVER)
.build())
.build(),
AddAwsConfigFields.AwsConfigField.builder()
.name("EndpointOptions.UseFIPSEndpoint")
.type(SymbolUtils.createPointableSymbolBuilder("bool").build())
.generatedOnClient(false)
.awsResolveFunction(SymbolUtils.createValueSymbolBuilder(USE_FIPS_ENDPOINT_CONFIG_RESOLVER)
.build())
.build(),
AddAwsConfigFields.AwsConfigField.builder()
.name("BaseEndpoint")
.type(SymbolUtils.createPointableSymbolBuilder("string").build())
.generatedOnClient(false)
.awsResolveFunction(SymbolUtils.createValueSymbolBuilder(
AwsEndpointResolverInitializerGenerator.RESOLVE_BASE_ENDPOINT)
.build())
.build()
);
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
LOGGER.info("generating client config resolver");
ServiceShape serviceShape = settings.getService(model);
goDelegator.useShapeWriter(serviceShape, writer -> {
generateUseARNRegionResolver(model, serviceShape, writer);
generateDisableMrapResolver(model, serviceShape, writer);
generateEnableEndpointDiscoveryResolver(model, serviceShape, writer);
generateUseUseDualStackResolver(model, serviceShape, writer);
generateUseUseFIPSEndpointResolver(model, serviceShape, writer);
});
}
private static void generatedResolverFunction(GoWriter writer, String name, String documentation, Runnable f) {
if (documentation.length() > 0) {
writer.writeDocs(documentation);
}
writer.addUseImports(AwsGoDependency.AWS_CORE);
writer.openBlock("func $L(cfg aws.Config, o *Options) error {", "}", name, () -> {
writer.openBlock("if len(cfg.$L) == 0 {", "}",
CONFIG_SOURCE_CONFIG_NAME,
() -> writer.write("return nil")
);
f.run();
writer.write("return nil");
});
}
private static void generateUseARNRegionResolver(Model model, ServiceShape serviceShape, GoWriter writer) {
if (!isS3SharedService(model, serviceShape)) {
return;
}
generatedResolverFunction(writer, USE_ARN_REGION_CONFIG_RESOLVER, "resolves UseARNRegion S3 configuration", () -> {
writer.addUseImports(SmithyGoDependency.CONTEXT);
Symbol resolverFunc = SymbolUtils.createValueSymbolBuilder(RESOLVE_USE_ARN_REGION,
AwsGoDependency.S3_SHARED_CONFIG).build();
writer.write("value, found, err := $T(context.Background(), cfg.$L)", resolverFunc,
CONFIG_SOURCE_CONFIG_NAME);
writer.write("if err != nil { return err }");
writer.write("if found { o.$L = value }", USE_ARN_REGION_OPTION);
});
writer.write("");
}
private static void generateDisableMrapResolver(Model model, ServiceShape serviceShape, GoWriter writer) {
if (!isS3Service(model, serviceShape)) {
return;
}
generatedResolverFunction(writer, DISABLE_MRAP_CONFIG_RESOLVER, "resolves DisableMultiRegionAccessPoints S3 configuration", () -> {
writer.addUseImports(SmithyGoDependency.CONTEXT);
Symbol resolverFunc = SymbolUtils.createValueSymbolBuilder(RESOLVE_DISABLE_MRAP,
AwsGoDependency.S3_SHARED_CONFIG).build();
writer.write("value, found, err := $T(context.Background(), cfg.$L)", resolverFunc,
CONFIG_SOURCE_CONFIG_NAME);
writer.write("if err != nil { return err }");
writer.write("if found { o.$L = value }", DISABLE_MRAP_OPTION);
});
writer.write("");
}
private static void generateEnableEndpointDiscoveryResolver(
Model model,
ServiceShape serviceShape,
GoWriter writer
) {
if (!supportsEndpointDiscovery(model, serviceShape)) {
return;
}
generatedResolverFunction(writer, ENABLE_ENDPOINT_DISCOVERY_CONFIG_RESOLVER,
"resolves EnableEndpointDiscovery configuration", () -> {
writer.addUseImports(SmithyGoDependency.CONTEXT);
Symbol resolverFunc = SymbolUtils.createValueSymbolBuilder(RESOLVE_ENABLE_ENDPOINT_DISCOVERY,
AwsGoDependency.SERVICE_INTERNAL_CONFIG).build();
writer.write("value, found, err := $T(context.Background(), cfg.$L)", resolverFunc,
CONFIG_SOURCE_CONFIG_NAME);
writer.write("if err != nil { return err }");
writer.write("if found { o.$L.$L = value }", ENDPOINT_DISCOVERY_OPTION, ENABLE_ENDPOINT_DISCOVERY_OPTION);
});
writer.write("");
}
private void generateUseUseDualStackResolver(Model model, ServiceShape serviceShape, GoWriter writer) {
writer.addUseImports(AwsGoDependency.AWS_CORE);
generatedResolverFunction(writer, DUAL_STACK_ENDPOINT_CONFIG_RESOLVER,
"resolves dual-stack endpoint configuration", () -> {
writer.addUseImports(SmithyGoDependency.CONTEXT);
var resolverFunc = SymbolUtils.createValueSymbolBuilder(RESOLVE_USE_DUAL_STACK_ENDPOINT,
AwsGoDependency.SERVICE_INTERNAL_CONFIG).build();
writer.write("value, found, err := $T(context.Background(), cfg.$L)", resolverFunc,
CONFIG_SOURCE_CONFIG_NAME);
writer.write("if err != nil { return err }");
writer.openBlock("if found {", "}", () -> writer
.write("o.EndpointOptions.$L = value",
EndpointGenerator.DUAL_STACK_ENDPOINT_OPTION));
});
}
private void generateUseUseFIPSEndpointResolver(Model model, ServiceShape serviceShape, GoWriter writer) {
writer.addUseImports(AwsGoDependency.AWS_CORE);
generatedResolverFunction(writer, USE_FIPS_ENDPOINT_CONFIG_RESOLVER,
"resolves FIPS endpoint configuration", () -> {
writer.addUseImports(SmithyGoDependency.CONTEXT);
var resolverFunc = SymbolUtils.createValueSymbolBuilder(RESOLVE_USE_FIPS_ENDPOINT,
AwsGoDependency.SERVICE_INTERNAL_CONFIG).build();
writer.write("value, found, err := $T(context.Background(), cfg.$L)", resolverFunc,
CONFIG_SOURCE_CONFIG_NAME);
writer.write("if err != nil { return err }");
writer.openBlock("if found {", "}", () -> {
writer.write("o.EndpointOptions.$L = value", EndpointGenerator.USE_FIPS_ENDPOINT_OPTION);
});
});
}
private static Symbol getUniversalSymbol(String symbolName) {
return SymbolUtils.createValueSymbolBuilder(symbolName)
.putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true).build();
}
private static boolean isS3SharedService(Model model, ServiceShape service) {
return isS3Service(model, service) || isS3ControlService(model, service);
}
private static boolean isS3Service(Model model, ServiceShape service) {
return service.expectTrait(ServiceTrait.class).getSdkId().equalsIgnoreCase("S3");
}
private static boolean isS3ControlService(Model model, ServiceShape service) {
return service.expectTrait(ServiceTrait.class).getSdkId().equalsIgnoreCase("S3 Control");
}
private static boolean supportsEndpointDiscovery(Model model, ServiceShape service) {
return service.hasTrait(ClientEndpointDiscoveryTrait.class);
}
}
| 8,310 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/JsonShapeSerVisitor.java | /*
* 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.aws.go.codegen;
import java.util.Collections;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.TreeSet;
import java.util.function.Predicate;
import java.util.logging.Logger;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.go.codegen.GoValueAccessUtils;
import software.amazon.smithy.go.codegen.GoWriter;
import software.amazon.smithy.go.codegen.ProtocolDocumentGenerator;
import software.amazon.smithy.go.codegen.SmithyGoDependency;
import software.amazon.smithy.go.codegen.SymbolUtils;
import software.amazon.smithy.go.codegen.integration.DocumentShapeSerVisitor;
import software.amazon.smithy.go.codegen.integration.ProtocolGenerator.GenerationContext;
import software.amazon.smithy.go.codegen.knowledge.GoPointableIndex;
import software.amazon.smithy.go.codegen.trait.NoSerializeTrait;
import software.amazon.smithy.model.knowledge.NullableIndex;
import software.amazon.smithy.model.shapes.CollectionShape;
import software.amazon.smithy.model.shapes.DocumentShape;
import software.amazon.smithy.model.shapes.MapShape;
import software.amazon.smithy.model.shapes.MemberShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.model.shapes.UnionShape;
import software.amazon.smithy.model.traits.JsonNameTrait;
import software.amazon.smithy.model.traits.TimestampFormatTrait;
import software.amazon.smithy.model.traits.TimestampFormatTrait.Format;
import software.amazon.smithy.utils.FunctionalUtils;
import software.amazon.smithy.utils.SmithyBuilder;
/**
* Visitor to generate serialization functions for shapes in AWS JSON protocol
* document bodies.
* <p>
* This class handles function body generation for all types expected by the
* {@code DocumentShapeSerVisitor}. No other shape type serialization is overwritten.
* <p>
* Timestamps are serialized to {@link Format}.EPOCH_SECONDS by default.
*/
final class JsonShapeSerVisitor extends DocumentShapeSerVisitor {
private static final Format DEFAULT_TIMESTAMP_FORMAT = Format.EPOCH_SECONDS;
private static final Logger LOGGER = Logger.getLogger(JsonShapeSerVisitor.class.getName());
private final Predicate<MemberShape> memberFilter;
private final GoPointableIndex pointableIndex;
private final NullableIndex nullableIndex;
private final boolean supportJsonName;
/**
* Returns a new builder for building the JsonShapeSerVisitor.
* @return Builder
*/
public static Builder builder() {
return new Builder();
}
protected JsonShapeSerVisitor(Builder builder) {
super(SmithyBuilder.requiredState("context", builder.context), builder.serNameProvider);
if (builder.memberFilter != null) {
this.memberFilter = builder.memberFilter;
} else {
this.memberFilter = NoSerializeTrait.excludeNoSerializeMembers().and(
FunctionalUtils.alwaysTrue());
}
this.supportJsonName = builder.supportJsonName;
this.pointableIndex = GoPointableIndex.of(this.getContext().getModel());
this.nullableIndex = NullableIndex.of(this.getContext().getModel());
}
private DocumentMemberSerVisitor getMemberSerVisitor(MemberShape member, String source, String dest) {
// Get the timestamp format to be used, defaulting to epoch seconds.
Format format = member.getMemberTrait(getContext().getModel(), TimestampFormatTrait.class)
.map(TimestampFormatTrait::getFormat).orElse(DEFAULT_TIMESTAMP_FORMAT);
return new DocumentMemberSerVisitor(getContext(), member, source, dest, format);
}
@Override
protected Map<String, String> getAdditionalSerArguments() {
return Collections.singletonMap("value", "smithyjson.Value");
}
@Override
protected void serializeCollection(GenerationContext context, CollectionShape shape) {
GoWriter writer = context.getWriter().get();
Shape target = context.getModel().expectShape(shape.getMember().getTarget());
writer.addUseImports(SmithyGoDependency.SMITHY_JSON);
writer.write("array := value.Array()");
writer.write("defer array.Close()");
writer.write("");
writer.openBlock("for i := range v {", "}", () -> {
writer.write("av := array.Value()");
// Null values in lists should be serialized as such. Enums can't be null, so we don't bother
// putting this in for their case.
if (pointableIndex.isNillable(shape.getMember())) {
writer.openBlock("if vv := v[i]; vv == nil {", "}", () -> {
if (nullableIndex.isNullable(shape.getMember())) {
writer.write("av.Null()");
}
writer.write("continue");
});
}
target.accept(getMemberSerVisitor(shape.getMember(), "v[i]", "av"));
});
writer.write("return nil");
}
@Override
protected void serializeDocument(GenerationContext context, DocumentShape shape) {
GoWriter writer = context.getWriter().get();
Symbol isInterface = ProtocolDocumentGenerator.Utilities.getInternalDocumentSymbolBuilder(context.getSettings(),
ProtocolDocumentGenerator.INTERNAL_IS_DOCUMENT_INTERFACE).build();
writer.openBlock("if v == nil {", "}", () -> writer.write("return nil"));
writer.openBlock("if !$T(v) {", "}", isInterface, () -> {
writer.addUseImports(SmithyGoDependency.FMT);
writer.write("return fmt.Errorf(\"%T is not a compatible document type\", v)");
});
writer.write("db, err := v.MarshalSmithyDocument()");
writer.openBlock("if err != nil {", "}", () -> writer.write("return err"));
writer.write("value.Write(db)");
writer.write("return nil");
}
@Override
protected void serializeMap(GenerationContext context, MapShape shape) {
GoWriter writer = context.getWriter().get();
Shape target = context.getModel().expectShape(shape.getValue().getTarget());
writer.addUseImports(SmithyGoDependency.SMITHY_JSON);
writer.write("object := value.Object()");
writer.write("defer object.Close()");
writer.write("");
writer.openBlock("for key := range v {", "}", () -> {
writer.write("om := object.Key(key)");
// Null values in maps should be serialized as such. Enums can't be null, so we don't bother
// putting this in for their case.
if (pointableIndex.isNillable(shape.getValue())) {
writer.openBlock("if vv := v[key]; vv == nil {", "}", () -> {
if (nullableIndex.isNullable(shape.getValue())) {
writer.write("om.Null()");
}
writer.write("continue");
});
}
target.accept(getMemberSerVisitor(shape.getValue(), "v[key]", "om"));
});
writer.write("return nil");
}
@Override
protected void serializeStructure(GenerationContext context, StructureShape shape) {
GoWriter writer = context.getWriter().get();
writer.addUseImports(SmithyGoDependency.SMITHY_JSON);
writer.write("object := value.Object()");
writer.write("defer object.Close()");
writer.write("");
// Use a TreeSet to sort the members.
Set<MemberShape> members = new TreeSet<>(shape.getAllMembers().values());
for (MemberShape member : members) {
if (!memberFilter.test(member)) {
continue;
}
Shape target = context.getModel().expectShape(member.getTarget());
String serializedMemberName = getSerializedMemberName(member);
GoValueAccessUtils.writeIfNonZeroValueMember(context.getModel(), context.getSymbolProvider(), writer,
member, "v", true, member.isRequired(), (operand) -> {
writer.write("ok := object.Key($S)", serializedMemberName);
target.accept(getMemberSerVisitor(member, operand, "ok"));
});
writer.write("");
}
writer.write("return nil");
}
private String getSerializedMemberName(MemberShape memberShape) {
if (this.supportJsonName) {
Optional<JsonNameTrait> jsonNameTrait = memberShape.getTrait(JsonNameTrait.class);
return jsonNameTrait.isPresent() ? jsonNameTrait.get().getValue() : memberShape.getMemberName();
}
return memberShape.getMemberName();
}
@Override
protected void serializeUnion(GenerationContext context, UnionShape shape) {
GoWriter writer = context.getWriter().get();
SymbolProvider symbolProvider = context.getSymbolProvider();
Symbol symbol = symbolProvider.toSymbol(shape);
writer.addUseImports(SmithyGoDependency.FMT);
writer.addUseImports(SmithyGoDependency.SMITHY_JSON);
writer.write("object := value.Object()");
writer.write("defer object.Close()");
writer.write("");
writer.openBlock("switch uv := v.(type) {", "}", () -> {
// Use a TreeSet to sort the members.
Set<MemberShape> members = new TreeSet<>(shape.getAllMembers().values());
for (MemberShape member : members) {
Shape target = context.getModel().expectShape(member.getTarget());
Symbol memberSymbol = SymbolUtils.createValueSymbolBuilder(
symbolProvider.toMemberName(member),
symbol.getNamespace()
).build();
String serializedMemberName = getSerializedMemberName(member);
writer.openBlock("case *$T:", "", memberSymbol, () -> {
writer.write("av := object.Key($S)", serializedMemberName);
target.accept(getMemberSerVisitor(member, "uv.Value", "av"));
});
}
// Handle unknown union values
writer.openBlock("default:", "", () -> {
writer.write("return fmt.Errorf(\"attempted to serialize unknown member type %T"
+ " for union %T\", uv, v)");
});
});
writer.write("return nil");
}
public static final class Builder implements SmithyBuilder<JsonShapeSerVisitor> {
private GenerationContext context;
private Predicate<MemberShape> memberFilter;
private SerializerNameProvider serNameProvider;
private boolean supportJsonName;
private Builder() {}
public Builder context(GenerationContext context) {
this.context = context;
return this;
}
public Builder memberFilter(Predicate<MemberShape> filter) {
this.memberFilter = filter;
return this;
}
public Builder serializerNameProvider(SerializerNameProvider nameProvider) {
this.serNameProvider = nameProvider;
return this;
}
public Builder supportJsonName(boolean v) {
this.supportJsonName = v;
return this;
}
@Override
public JsonShapeSerVisitor build() {
return new JsonShapeSerVisitor(this);
}
}
}
| 8,311 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsRestJson1.java | /*
* Copyright 2019 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.aws.go.codegen;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.aws.traits.protocols.RestJson1Trait;
/**
* Handles generating the aws.rest-json protocol for services.
*
* @inheritDoc
*
* @see RestJsonProtocolGenerator
*/
public final class AwsRestJson1 extends RestJsonProtocolGenerator {
@Override
protected String getDocumentContentType() {
return "application/json";
}
@Override
public ShapeId getProtocol() {
return RestJson1Trait.ID;
}
}
| 8,312 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/ClientResolvedDefaultsMode.java | /*
* Copyright 2022 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.aws.go.codegen;
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.SymbolUtils;
import software.amazon.smithy.go.codegen.integration.ConfigField;
import software.amazon.smithy.go.codegen.integration.ConfigFieldResolver;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.go.codegen.integration.RuntimeClientPlugin;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.utils.ListUtils;
/**
* Records the initial resolve DefaultsMode when the client is constructed.
*/
public class ClientResolvedDefaultsMode implements GoIntegration {
public static final String RESOLVED_DEFAULTS_MODE_CONFIG_NAME = "resolvedDefaultsMode";
private static final String RESOLVE_RESOLVED_DEFAULTS_MODE = "setResolvedDefaultsMode";
private static final ConfigField CONFIG_FIELD = ConfigField.builder()
.name(RESOLVED_DEFAULTS_MODE_CONFIG_NAME)
.type(SymbolUtils.createValueSymbolBuilder("DefaultsMode", AwsGoDependency.AWS_CORE)
.build())
.documentation("""
The initial DefaultsMode used when the client options were constructed. If the
DefaultsMode was set to aws.DefaultsModeAuto this will store what the resolved value
was at that point in time.
Currently does not support per operation call overrides, may in the future.
""")
.build();
private void writeSetResolvedDefaultsMode(GoWriter writer) {
writer.pushState();
writer.putContext("resolverName", RESOLVE_RESOLVED_DEFAULTS_MODE);
writer.putContext("resolvedOption", RESOLVED_DEFAULTS_MODE_CONFIG_NAME);
writer.putContext("modeType", SymbolUtils.createValueSymbolBuilder("DefaultsMode",
AwsGoDependency.AWS_CORE)
.build());
writer.putContext("modeOption", AddAwsConfigFields.DEFAULTS_MODE_CONFIG_NAME);
writer.putContext("autoResolve", SymbolUtils.createValueSymbolBuilder("ResolveDefaultsModeAuto",
AwsGoDependency.AWS_DEFAULTS)
.build());
writer.putContext("autoMode", SymbolUtils.createValueSymbolBuilder("DefaultsModeAuto",
AwsGoDependency.AWS_CORE)
.build());
writer.putContext("region", "Region");
writer.putContext("envOption", AddAwsConfigFields.RUNTIME_ENVIRONMENT_CONFIG_NAME);
writer.write("""
func $resolverName:L(o *Options) {
if len(o.$resolvedOption:L) > 0 {
return
}
var mode $modeType:T
mode.SetFromString(string(o.$modeOption:L))
if mode == $autoMode:T {
mode = $autoResolve:T(o.$region:L, o.$envOption:L)
}
o.$resolvedOption:L = mode
}
""");
writer.popState();
}
/**
* Gets the sort order of the customization from -128 to 127, with lowest
* executed first.
*
* @return Returns the sort order, defaults to -50.
*/
@Override
public byte getOrder() {
return -50;
}
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
ServiceShape serviceShape = settings.getService(model);
goDelegator.useShapeWriter(serviceShape, w -> {
writeSetResolvedDefaultsMode(w);
});
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return ListUtils.of(
RuntimeClientPlugin.builder()
.addConfigField(CONFIG_FIELD)
.addConfigFieldResolver(ConfigFieldResolver.builder()
.location(ConfigFieldResolver.Location.CLIENT)
.target(ConfigFieldResolver.Target.INITIALIZATION)
.resolver(SymbolUtils.createValueSymbolBuilder(RESOLVE_RESOLVED_DEFAULTS_MODE).build())
.build())
.build()
);
}
}
| 8,313 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/RestXmlProtocolGenerator.java | package software.amazon.smithy.aws.go.codegen;
import static software.amazon.smithy.go.codegen.integration.HttpProtocolGeneratorUtils.isShapeWithResponseBindings;
import static software.amazon.smithy.aws.go.codegen.XmlProtocolUtils.initializeXmlDecoder;
import static software.amazon.smithy.aws.go.codegen.XmlProtocolUtils.handleDecodeError;
import static software.amazon.smithy.aws.go.codegen.XmlProtocolUtils.writeXmlErrorMessageCodeDeserializer;
import static software.amazon.smithy.aws.go.codegen.XmlProtocolUtils.generateXMLStartElement;
import static software.amazon.smithy.aws.go.codegen.XmlProtocolUtils.generatePayloadAsDocumentXMLStartElement;
import java.util.HashSet;
import java.util.Optional;
import java.util.Set;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import java.util.TreeSet;
import java.util.function.Predicate;
import software.amazon.smithy.aws.traits.protocols.RestXmlTrait;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.go.codegen.GoStackStepMiddlewareGenerator;
import software.amazon.smithy.go.codegen.GoValueAccessUtils;
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.HttpBindingProtocolGenerator;
import software.amazon.smithy.go.codegen.integration.ProtocolGenerator;
import software.amazon.smithy.go.codegen.integration.ProtocolUtils;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.knowledge.EventStreamInfo;
import software.amazon.smithy.model.knowledge.HttpBinding;
import software.amazon.smithy.model.knowledge.HttpBindingIndex;
import software.amazon.smithy.model.shapes.MemberShape;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.model.shapes.UnionShape;
import software.amazon.smithy.model.traits.ErrorTrait;
import software.amazon.smithy.model.traits.EventHeaderTrait;
import software.amazon.smithy.model.traits.EventPayloadTrait;
import software.amazon.smithy.model.traits.MediaTypeTrait;
import software.amazon.smithy.model.traits.EnumTrait;
import software.amazon.smithy.model.traits.StreamingTrait;
import software.amazon.smithy.model.traits.TimestampFormatTrait;
import software.amazon.smithy.model.traits.XmlAttributeTrait;
import software.amazon.smithy.model.traits.XmlNamespaceTrait;
import software.amazon.smithy.go.codegen.endpoints.EndpointResolutionGenerator;
import software.amazon.smithy.go.codegen.endpoints.FnGenerator;
abstract class RestXmlProtocolGenerator extends HttpBindingProtocolGenerator {
private final Set<ShapeId> generatedDocumentBodyShapeSerializers = new HashSet<>();
private final Set<ShapeId> generatedEventMessageSerializers = new HashSet<>();
private final Set<ShapeId> generatedDocumentBodyShapeDeserializers = new HashSet<>();
private final Set<ShapeId> generatedEventMessageDeserializers = new HashSet<>();
/**
* Creates a AWS REST XML protocol generator.
*/
RestXmlProtocolGenerator() {
super(true);
}
@Override
public void generateProtocolTests(GenerationContext context) {
AwsProtocolUtils.generateHttpProtocolTests(context);
}
@Override
protected TimestampFormatTrait.Format getDocumentTimestampFormat() {
return TimestampFormatTrait.Format.DATE_TIME;
}
@Override
protected void generateOperationDocumentSerializer(GenerationContext context, OperationShape operation) {
Model model = context.getModel();
HttpBindingIndex bindingIndex = HttpBindingIndex.of(model);
Set<MemberShape> documentBindings = bindingIndex.getRequestBindings(operation, HttpBinding.Location.DOCUMENT)
.stream()
.map(HttpBinding::getMember)
.collect(Collectors.toSet());
if (documentBindings.isEmpty()) {
return;
}
Shape inputShape = ProtocolUtils.expectInput(context.getModel(), operation);
inputShape.accept(new XmlShapeSerVisitor(context,
memberShape -> documentBindings.contains(memberShape) && !memberShape.hasTrait(
XmlAttributeTrait.class)));
}
@Override
protected void writeMiddlewareDocumentSerializerDelegator(
GenerationContext context,
OperationShape operation,
GoStackStepMiddlewareGenerator generator) {
GoWriter writer = context.getWriter().get();
writer.addUseImports(SmithyGoDependency.SMITHY);
writer.addUseImports(SmithyGoDependency.SMITHY_XML);
writer.write("restEncoder.SetHeader(\"Content-Type\").String($S)", getDocumentContentType());
writer.write("");
Shape inputShape = ProtocolUtils.expectInput(context.getModel(), operation);
String functionName = ProtocolGenerator.getDocumentSerializerFunctionName(inputShape, context.getService(),
getProtocolName());
initalizeXmlEncoder(context, writer, inputShape, "root", "input");
writer.openBlock("if err := $L(input, xmlEncoder.RootElement(root)); err != nil {", "}",
functionName, () -> {
writer.write("return out, metadata, &smithy.SerializationError{Err: err}");
});
writer.insertTrailingNewline();
writer.openBlock("if request, err = request.SetStream(bytes.NewReader(xmlEncoder.Bytes())); "
+ "err != nil {", "}", () -> {
writer.write("return out, metadata, &smithy.SerializationError{Err: err}");
});
}
private void initalizeXmlEncoder(
GenerationContext context,
GoWriter writer,
Shape inputShape,
String nodeDst,
String inputSrc) {
writer.addUseImports(SmithyGoDependency.SMITHY_XML);
writer.addUseImports(SmithyGoDependency.BYTES);
writer.write("xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil))");
generateXMLStartElement(context, inputShape, nodeDst, inputSrc);
// check if service shape is bound by xmlNameSpace Trait
Optional<XmlNamespaceTrait> xmlNamespaceTrait = context.getService().getTrait(XmlNamespaceTrait.class);
if (xmlNamespaceTrait.isPresent()) {
XmlNamespaceTrait namespace = xmlNamespaceTrait.get();
writer.write("$L.Attr = append($L.Attr, smithyxml.NewNamespaceAttribute($S, $S))", nodeDst, nodeDst,
namespace.getPrefix().isPresent() ? namespace.getPrefix().get() : "", namespace.getUri());
}
}
@Override
protected void writeMiddlewarePayloadAsDocumentSerializerDelegator(
GenerationContext context,
MemberShape memberShape,
String operand) {
GoWriter writer = context.getWriter().get();
Model model = context.getModel();
Shape payloadShape = model.expectShape(memberShape.getTarget());
GoValueAccessUtils.writeIfNonZeroValueMember(context.getModel(), context.getSymbolProvider(), writer,
memberShape, operand, (s) -> {
writeSetPayloadShapeHeader(writer, payloadShape);
writer.addUseImports(SmithyGoDependency.SMITHY_XML);
writer.addUseImports(SmithyGoDependency.BYTES);
writer.write("xmlEncoder := smithyxml.NewEncoder(bytes.NewBuffer(nil))");
generatePayloadAsDocumentXMLStartElement(context, memberShape, "payloadRoot", s);
// check if service shape is bound by xmlNameSpace Trait
Optional<XmlNamespaceTrait> xmlNamespaceTrait = context.getService()
.getTrait(XmlNamespaceTrait.class);
if (xmlNamespaceTrait.isPresent()) {
XmlNamespaceTrait namespace = xmlNamespaceTrait.get();
writer.write(
"payloadRoot.Attr = append(payloadRoot.Attr, smithyxml.NewNamespaceAttribute($S, $S))",
namespace.getPrefix().isPresent() ? namespace.getPrefix().get() : "",
namespace.getUri());
}
String functionName = ProtocolGenerator.getDocumentSerializerFunctionName(
payloadShape, context.getService(), getProtocolName());
writer.openBlock("if err := $L($L, xmlEncoder.RootElement(payloadRoot)); err != nil {", "}",
functionName,
s, () -> {
writer.write("return out, metadata, &smithy.SerializationError{Err: err}");
});
writer.write("payload := bytes.NewReader(xmlEncoder.Bytes())");
writeSetStream(writer, "payload");
});
}
@Override
protected void generateDocumentBodyShapeSerializers(GenerationContext context, Set<Shape> shapes) {
// filter shapes marked as attributes
XmlShapeSerVisitor visitor = new XmlShapeSerVisitor(context,
memberShape -> !memberShape.hasTrait(XmlAttributeTrait.class));
shapes.forEach(shape -> {
if (generatedDocumentBodyShapeSerializers.contains(shape.toShapeId())) {
return;
}
shape.accept(visitor);
generatedDocumentBodyShapeSerializers.add(shape.toShapeId());
});
}
/**
* Returns the MediaType for the payload shape derived from the MediaTypeTrait,
* shape type, or document content type.
*
* @param payloadShape shape bound to the payload.
* @return string for media type.
*/
private String getPayloadShapeMediaType(Shape payloadShape) {
Optional<MediaTypeTrait> mediaTypeTrait = payloadShape.getTrait(MediaTypeTrait.class);
if (mediaTypeTrait.isPresent()) {
return mediaTypeTrait.get().getValue();
}
if (payloadShape.isBlobShape()) {
return "application/octet-stream";
}
if (payloadShape.isStringShape()) {
return "text/plain";
}
return getDocumentContentType();
}
/* ================Deserializer=========================== */
@Override
protected void deserializeError(GenerationContext context, StructureShape shape) {
GoWriter writer = context.getWriter().get();
Symbol symbol = context.getSymbolProvider().toSymbol(shape);
writer.write("output := &$T{}", symbol);
writer.insertTrailingNewline();
if (isShapeWithRestResponseBindings(context.getModel(), shape)) {
String bindingDeserFunctionName = ProtocolGenerator.getOperationHttpBindingsDeserFunctionName(
shape, context.getService(), getProtocolName());
writer.openBlock("if err := $L(output, response); err != nil {", "}", bindingDeserFunctionName, () -> {
writer.addUseImports(SmithyGoDependency.SMITHY);
writer.write(String.format("return &smithy.DeserializationError{Err: %s}",
"fmt.Errorf(\"failed to decode response error with invalid HTTP bindings, %w\", err)"));
});
writer.insertTrailingNewline();
}
if (isShapeWithResponseBindings(context.getModel(), shape, HttpBinding.Location.DOCUMENT)) {
String documentDeserFunctionName = ProtocolGenerator.getDocumentDeserializerFunctionName(
shape, context.getService(), getProtocolName());
initializeXmlDecoder(writer, "errorBody", "output");
boolean isNoErrorWrapping = isNoErrorWrapping(context);
Runnable writeErrorDelegator = () -> {
writer.write("err = $L(&output, decoder)", documentDeserFunctionName);
handleDecodeError(writer, "");
writer.insertTrailingNewline();
};
if (isNoErrorWrapping) {
writeErrorDelegator.run();
} else {
writer.write("t, err = decoder.GetElement(\"Error\")");
XmlProtocolUtils.handleDecodeError(writer, "");
Symbol wrapNodeDecoder = SymbolUtils.createValueSymbolBuilder("WrapNodeDecoder",
SmithyGoDependency.SMITHY_XML).build();
writer.write("decoder = $T(decoder.Decoder, t)", wrapNodeDecoder);
writeErrorDelegator.run();
}
}
writer.write("return output");
}
private Boolean isNoErrorWrapping(GenerationContext context) {
return context.getService().getTrait(RestXmlTrait.class).map(
RestXmlTrait::isNoErrorWrapping).orElse(false);
}
@Override
protected void writeErrorMessageCodeDeserializer(GenerationContext context) {
writeXmlErrorMessageCodeDeserializer(context);
}
@Override
protected void writeMiddlewareDocumentDeserializerDelegator(
GenerationContext context,
OperationShape operation,
GoStackStepMiddlewareGenerator generator) {
Model model = context.getModel();
GoWriter writer = context.getWriter().get();
Shape targetShape = ProtocolUtils.expectOutput(model, operation);
String operand = "output";
if (isShapeWithResponseBindings(model, operation, HttpBinding.Location.PAYLOAD)) {
// since payload trait can only be applied to a single member in a output shape
MemberShape memberShape = HttpBindingIndex.of(model)
.getResponseBindings(operation, HttpBinding.Location.PAYLOAD).stream()
.findFirst()
.orElseThrow(() -> new CodegenException("Expected payload binding member"))
.getMember();
Shape payloadShape = model.expectShape(memberShape.getTarget());
// if target shape is of type String or type Blob, then delegate deserializers
// for explicit payload shapes
if (payloadShape.isStringShape() || payloadShape.isBlobShape()) {
writeMiddlewarePayloadBindingDeserializerDelegator(writer, context.getService(), targetShape,
payloadShape);
return;
}
// for other payload target types we should deserialize using the appropriate
// document deserializer
targetShape = payloadShape;
operand += "." + context.getSymbolProvider().toMemberName(memberShape);
}
writeMiddlewareDocumentBindingDeserializerDelegator(context, writer, targetShape, operand);
}
@Override
protected void generateOperationDocumentDeserializer(
GenerationContext context, OperationShape operation) {
Model model = context.getModel();
HttpBindingIndex bindingIndex = HttpBindingIndex.of(model);
Set<MemberShape> documentBindings = bindingIndex.getResponseBindings(operation, HttpBinding.Location.DOCUMENT)
.stream()
.map(HttpBinding::getMember)
.collect(Collectors.toSet());
Shape outputShape = ProtocolUtils.expectOutput(model, operation);
GoWriter writer = context.getWriter().get();
if (documentBindings.size() != 0) {
outputShape.accept(new XmlShapeDeserVisitor(context, documentBindings::contains));
}
Set<MemberShape> payloadBindings = bindingIndex.getResponseBindings(operation, HttpBinding.Location.PAYLOAD)
.stream()
.map(HttpBinding::getMember)
.collect(Collectors.toSet());
if (payloadBindings.size() == 0) {
return;
}
writePayloadBindingDeserializer(context, outputShape, payloadBindings::contains);
writer.write("");
}
@Override
protected void generateDocumentBodyShapeDeserializers(GenerationContext context, Set<Shape> shapes) {
XmlShapeDeserVisitor visitor = new XmlShapeDeserVisitor(context);
shapes.forEach(shape -> {
if (generatedDocumentBodyShapeDeserializers.contains(shape.toShapeId())) {
return;
}
shape.accept(visitor);
generatedDocumentBodyShapeDeserializers.add(shape.toShapeId());
});
}
// Generate deserializers for shapes with payload binding
private void writePayloadBindingDeserializer(
GenerationContext context,
Shape shape,
Predicate<MemberShape> filterMemberShapes) {
GoWriter writer = context.getWriter().get();
SymbolProvider symbolProvider = context.getSymbolProvider();
Symbol shapeSymbol = symbolProvider.toSymbol(shape);
String funcName = ProtocolGenerator.getDocumentDeserializerFunctionName(shape, context.getService(),
getProtocolName());
for (MemberShape memberShape : new TreeSet<>(shape.members())) {
if (!filterMemberShapes.test(memberShape)) {
continue;
}
String memberName = symbolProvider.toMemberName(memberShape);
Shape targetShape = context.getModel().expectShape(memberShape.getTarget());
if (!targetShape.isStringShape() && !targetShape.isBlobShape()) {
shape.accept(new XmlShapeDeserVisitor(context, filterMemberShapes));
return;
}
String contentLengthParam = "";
if (!targetShape.hasTrait(StreamingTrait.class)) {
contentLengthParam = "contentLength int64";
}
writer.openBlock("func $L(v $P, body io.ReadCloser, $L) error {", "}",
funcName, shapeSymbol, contentLengthParam, () -> {
writer.openBlock("if v == nil {", "}", () -> {
writer.write("return fmt.Errorf(\"unsupported deserialization of nil %T\", v)");
});
writer.insertTrailingNewline();
if (targetShape.hasTrait(StreamingTrait.class)) {
writer.write("v.$L = body", memberName);
writer.write("return nil");
return;
}
writer.addUseImports(SmithyGoDependency.BYTES);
writer.write("var buf bytes.Buffer");
writer.openBlock("if contentLength > 0 {", "", () -> {
writer.write("buf.Grow(int(contentLength))");
writer.openBlock("} else {", "}", () -> {
writer.write("buf.Grow(512)");
});
});
writer.write("_, err := buf.ReadFrom(body)");
writer.write("if err != nil { return err }");
writer.openBlock("if buf.Len() > 0 {", "}", () -> {
if (targetShape.isBlobShape()) {
writer.write("v.$L = buf.Bytes()", memberName);
} else { // string
writer.addUseImports(SmithyGoDependency.SMITHY_PTR);
if (targetShape.hasTrait(EnumTrait.class)) {
writer.write("v.$L = $T(buf.Bytes())", memberName,
symbolProvider.toSymbol(targetShape));
} else {
writer.write("v.$L = ptr.String(buf.String())", memberName);
}
}
});
writer.write("return nil");
});
}
}
// Writes middleware that delegates to deserializers for shapes that have
// explicit payload.
private void writeMiddlewarePayloadBindingDeserializerDelegator(
GoWriter writer, ServiceShape service, Shape outputShape, Shape payloadShape) {
String deserFuncName = ProtocolGenerator.getDocumentDeserializerFunctionName(outputShape, service,
getProtocolName());
String contentLengthParam = "";
if (!payloadShape.hasTrait(StreamingTrait.class)) {
contentLengthParam = "response.ContentLength";
}
writer.write("err = $L(output, response.Body, $L)", deserFuncName, contentLengthParam);
writer.openBlock("if err != nil {", "}", () -> {
writer.addUseImports(SmithyGoDependency.SMITHY);
writer.write(String.format("return out, metadata, &smithy.DeserializationError{Err:%s}",
"fmt.Errorf(\"failed to deserialize response payload, %w\", err)"));
});
}
// Writes middleware that delegates to deserializers for shapes that have
// implicit payload.
private void writeMiddlewareDocumentBindingDeserializerDelegator(
GenerationContext context,
GoWriter writer,
Shape shape,
String operand) {
XmlProtocolUtils.initializeXmlDecoder(writer, "response.Body", "out, metadata,", "nil");
String functionName = ProtocolGenerator.getDocumentDeserializerFunctionName(
shape, context.getService(), context.getProtocolName());
writer.write("err = $L(&$L, decoder)", functionName, operand);
XmlProtocolUtils.handleDecodeError(writer, "out, metadata,");
}
@Override
public void generateEventStreamComponents(GenerationContext context) {
AwsEventStreamUtils.generateEventStreamComponents(context);
}
@Override
protected void writeOperationSerializerMiddlewareEventStreamSetup(GenerationContext context, EventStreamInfo info) {
AwsEventStreamUtils.writeOperationSerializerMiddlewareEventStreamSetup(context, info, "restEncoder");
}
@Override
protected void generateEventStreamSerializers(
GenerationContext context,
UnionShape eventUnion,
Set<EventStreamInfo> eventStreamInfos) {
Model model = context.getModel();
AwsEventStreamUtils.generateEventStreamSerializer(context, eventUnion);
var memberShapes = eventUnion.members().stream()
.filter(ms -> ms.getMemberTrait(model, ErrorTrait.class).isEmpty())
.collect(Collectors.toCollection(TreeSet::new));
final var eventDocumentShapes = new TreeSet<Shape>();
for (MemberShape member : memberShapes) {
var targetShape = model.expectShape(member.getTarget());
if (generatedEventMessageSerializers.contains(targetShape.toShapeId())) {
continue;
}
AwsEventStreamUtils.generateEventMessageSerializer(context, targetShape, (ctx, payloadTarget, operand) -> {
var ctxWriter = ctx.getWriter().get();
var stringValue = SymbolUtils.createValueSymbolBuilder("StringValue",
AwsGoDependency.SERVICE_INTERNAL_EVENTSTREAM).build();
var contentTypeHeader = SymbolUtils.createValueSymbolBuilder("ContentTypeHeader",
AwsGoDependency.SERVICE_INTERNAL_EVENTSTREAMAPI).build();
ctxWriter.write("msg.Headers.Set($T, $T($S))",
contentTypeHeader, stringValue, getDocumentContentType());
String functionName = ProtocolGenerator.getDocumentSerializerFunctionName(payloadTarget,
context.getService(), getProtocolName());
initalizeXmlEncoder(context, ctxWriter, payloadTarget, "root", operand);
ctxWriter.openBlock("if err := $L(input, xmlEncoder.RootElement(root)); err != nil {", "}",
functionName, () -> {
ctxWriter.write("return &$T{Err: err}",
SymbolUtils.createValueSymbolBuilder("SerializationError",
SmithyGoDependency.SMITHY).build());
})
.write("msg.Payload = xmlEncoder.Bytes()")
.write("return nil");
});
generatedEventMessageSerializers.add(targetShape.toShapeId());
var hasBindings = targetShape.members().stream()
.filter(ms -> ms.getTrait(EventHeaderTrait.class).isPresent()
|| ms.getTrait(EventPayloadTrait.class).isPresent())
.findAny();
if (hasBindings.isPresent()) {
var payload = targetShape.members().stream()
.filter(ms -> ms.getTrait(EventPayloadTrait.class).isPresent())
.map(ms -> model.expectShape(ms.getTarget()))
.filter(ProtocolUtils::requiresDocumentSerdeFunction)
.findAny();
payload.ifPresent(eventDocumentShapes::add);
continue;
}
eventDocumentShapes.add(targetShape);
}
eventDocumentShapes.addAll(ProtocolUtils.resolveRequiredDocumentShapeSerde(model, eventDocumentShapes));
generateDocumentBodyShapeSerializers(context, eventDocumentShapes);
}
@Override
protected void generateEventStreamDeserializers(
GenerationContext context,
UnionShape eventUnion,
Set<EventStreamInfo> eventStreamInfos) {
var model = context.getModel();
AwsEventStreamUtils.generateEventStreamDeserializer(context, eventUnion);
AwsEventStreamUtils.generateEventStreamExceptionDeserializer(context, eventUnion, ctx -> {
var ctxWriter = ctx.getWriter().get();
ctxWriter.write("br := $T(msg.Payload)", SymbolUtils.createValueSymbolBuilder("NewReader",
SmithyGoDependency.BYTES).build());
AwsProtocolUtils.initializeJsonDecoder(ctxWriter, "br");
ctxWriter.addUseImports(AwsGoDependency.AWS_XML);
ctxWriter.write("""
errorComponents, err := $T(br, $L)
if err != nil {
return err
}
errorCode := "UnknownError"
errorMessage := errorCode
if ev := exceptionType.String(); len(ev) > 0 {
errorCode = ev
} else if ev := errorComponents.Code; len(ev) > 0 {
errorCode = ev
}
if ev := errorComponents.Message; len(ev) > 0 {
errorMessage = ev
}
return &$T{
Code: errorCode,
Message: errorMessage,
}
""",
SymbolUtils.createValueSymbolBuilder("GetErrorResponseComponents", AwsGoDependency.AWS_XML).build(),
isNoErrorWrapping(context),
SymbolUtils.createValueSymbolBuilder("GenericAPIError", SmithyGoDependency.SMITHY).build());
});
final var eventDocumentShapes = new TreeSet<Shape>();
for (MemberShape shape : eventUnion.members()) {
var targetShape = model.expectShape(shape.getTarget());
if (generatedEventMessageDeserializers.contains(targetShape.toShapeId())) {
continue;
}
generatedEventMessageDeserializers.add(targetShape.toShapeId());
if (shape.getMemberTrait(model, ErrorTrait.class).isPresent()) {
AwsEventStreamUtils.generateEventMessageExceptionDeserializer(context, targetShape,
(ctx, payloadTarget) -> {
var ctxWriter = ctx.getWriter().get();
ctxWriter.write("br := $T(msg.Payload)", SymbolUtils.createValueSymbolBuilder("NewReader",
SmithyGoDependency.BYTES).build())
.write("output := &$T{}", context.getSymbolProvider().toSymbol(payloadTarget));
String functionName = ProtocolGenerator.getDocumentDeserializerFunctionName(
payloadTarget, context.getService(), getProtocolName());
initializeXmlDecoder(ctxWriter, "br", "output");
boolean isNoErrorWrapping = isNoErrorWrapping(context);
Runnable writeErrorDelegator = () -> {
ctxWriter.write("err = $L(&output, decoder)", functionName);
handleDecodeError(ctxWriter, "");
};
if (isNoErrorWrapping) {
writeErrorDelegator.run();
} else {
ctxWriter.write("t, err = decoder.GetElement(\"Error\")");
XmlProtocolUtils.handleDecodeError(ctxWriter, "");
Symbol wrapNodeDecoder = SymbolUtils.createValueSymbolBuilder("WrapNodeDecoder",
SmithyGoDependency.SMITHY_XML).build();
ctxWriter.write("decoder = $T(decoder.Decoder, t)", wrapNodeDecoder);
writeErrorDelegator.run();
}
});
eventDocumentShapes.add(targetShape);
} else {
AwsEventStreamUtils.generateEventMessageDeserializer(context, targetShape,
(ctx, payloadTarget, operand) -> {
var ctxWriter = ctx.getWriter().get();
ctxWriter.write("br := $T(msg.Payload)", SymbolUtils.createValueSymbolBuilder(
"NewReader", SmithyGoDependency.BYTES).build());
XmlProtocolUtils.initializeXmlDecoder(ctxWriter, "br", "", "nil");
String functionName = ProtocolGenerator.getDocumentDeserializerFunctionName(
payloadTarget, context.getService(), context.getProtocolName());
ctxWriter.write("err = $L(&$L, decoder)", functionName, operand);
XmlProtocolUtils.handleDecodeError(ctxWriter, "");
ctxWriter.write("return nil");
});
var hasBindings = targetShape.members().stream()
.filter(ms -> ms.getTrait(EventHeaderTrait.class).isPresent()
|| ms.getTrait(EventPayloadTrait.class).isPresent())
.findAny();
if (hasBindings.isPresent()) {
var payload = targetShape.members().stream()
.filter(ms -> ms.getTrait(EventPayloadTrait.class).isPresent())
.map(ms -> model.expectShape(ms.getTarget()))
.filter(ProtocolUtils::requiresDocumentSerdeFunction)
.findAny();
payload.ifPresent(eventDocumentShapes::add);
continue;
}
eventDocumentShapes.add(targetShape);
}
}
eventDocumentShapes.addAll(ProtocolUtils.resolveRequiredDocumentShapeSerde(model, eventDocumentShapes));
generateDocumentBodyShapeDeserializers(context, eventDocumentShapes);
}
@Override
public void generateEndpointResolution(GenerationContext context) {
var generator = new EndpointResolutionGenerator(new AwsFnProvider());
generator.generate(context);
}
}
| 8,314 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/QueryShapeSerVisitor.java | package software.amazon.smithy.aws.go.codegen;
import java.util.Collections;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.function.Predicate;
import java.util.logging.Logger;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.go.codegen.GoDependency;
import software.amazon.smithy.go.codegen.GoValueAccessUtils;
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.DocumentShapeSerVisitor;
import software.amazon.smithy.go.codegen.integration.ProtocolGenerator.GenerationContext;
import software.amazon.smithy.go.codegen.integration.ProtocolUtils;
import software.amazon.smithy.go.codegen.knowledge.GoPointableIndex;
import software.amazon.smithy.go.codegen.trait.NoSerializeTrait;
import software.amazon.smithy.model.shapes.CollectionShape;
import software.amazon.smithy.model.shapes.DocumentShape;
import software.amazon.smithy.model.shapes.MapShape;
import software.amazon.smithy.model.shapes.MemberShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.model.shapes.UnionShape;
import software.amazon.smithy.model.traits.EnumTrait;
import software.amazon.smithy.model.traits.TimestampFormatTrait;
import software.amazon.smithy.model.traits.TimestampFormatTrait.Format;
import software.amazon.smithy.model.traits.XmlFlattenedTrait;
import software.amazon.smithy.model.traits.XmlNameTrait;
import software.amazon.smithy.utils.FunctionalUtils;
/**
* Visitor to generate serialization functions for shapes in AWS Query protocol
* document bodies.
* <p>
* This class handles function body generation for all types expected by the
* {@code DocumentShapeSerVisitor}. No other shape type serialization is overwritten.
* <p>
* Timestamps are serialized to {@link Format}.DATE_TIME by default.
*/
class QueryShapeSerVisitor extends DocumentShapeSerVisitor {
private static final Format DEFAULT_TIMESTAMP_FORMAT = Format.DATE_TIME;
private static final Logger LOGGER = Logger.getLogger(QueryShapeSerVisitor.class.getName());
private final Predicate<MemberShape> memberFilter;
public QueryShapeSerVisitor(GenerationContext context) {
this(context, NoSerializeTrait.excludeNoSerializeMembers().and(FunctionalUtils.alwaysTrue()));
}
public QueryShapeSerVisitor(GenerationContext context, Predicate<MemberShape> memberFilter) {
super(context);
this.memberFilter = NoSerializeTrait.excludeNoSerializeMembers().and(memberFilter);
}
private DocumentMemberSerVisitor getMemberSerVisitor(MemberShape member, String source, String dest) {
// Get the timestamp format to be used, defaulting to epoch seconds.
Format format = member.getMemberTrait(getContext().getModel(), TimestampFormatTrait.class)
.map(TimestampFormatTrait::getFormat)
.orElse(DEFAULT_TIMESTAMP_FORMAT);
return new DocumentMemberSerVisitor(getContext(), member, source, dest, format);
}
@Override
protected Map<String, String> getAdditionalSerArguments() {
return Collections.singletonMap("value", "query.Value");
}
@Override
protected void serializeCollection(GenerationContext context, CollectionShape shape) {
GoWriter writer = context.getWriter().get();
MemberShape member = shape.getMember();
Shape target = context.getModel().expectShape(member.getTarget());
writer.write("array := value.Array($S)", getSerializedLocationName(member, "member"));
writer.write("");
writer.openBlock("for i := range v {", "}", () -> {
// Null values should be omitted for query.
if (GoPointableIndex.of(context.getModel()).isNillable(shape.getMember())) {
writer.openBlock("if vv := v[i]; vv == nil {", "}", () -> {
writer.write("continue");
});
}
writer.write("av := array.Value()");
target.accept(getMemberSerVisitor(shape.getMember(), "v[i]", "av"));
});
writer.write("return nil");
}
@Override
protected void serializeDocument(GenerationContext context, DocumentShape shape) {
LOGGER.warning("Document type is unsupported for Query serialization.");
context.getWriter().get().write("return &smithy.SerializationError{Err: fmt.Errorf("
+ "\"Document type is unsupported for the query protocol.\")}");
}
@Override
protected void serializeMap(GenerationContext context, MapShape shape) {
GoWriter writer = context.getWriter().get();
// If the map is empty, exit early to avoid extra effort.
writer.write("if len(v) == 0 { return nil }");
Shape target = context.getModel().expectShape(shape.getValue().getTarget());
String keyLocationName = getSerializedLocationName(shape.getKey(), "key");
String valueLocationName = getSerializedLocationName(shape.getValue(), "value");
writer.write("object := value.Map($S, $S)", keyLocationName, valueLocationName);
writer.write("");
// Create a sorted list of the map's keys so we can have a stable body.
// Ideally this would be a function we dispatch to, but the lack of generics make
// that impractical since you can't make a function for a map[string]any
writer.write("keys := make([]string, 0, len(v))");
writer.write("for key := range v { keys = append(keys, key) }");
writer.addUseImports(GoDependency.standardLibraryDependency("sort", "1.15"));
writer.write("sort.Strings(keys)");
writer.write("");
writer.addUseImports(SmithyGoDependency.FMT);
writer.openBlock("for _, key := range keys {", "}", () -> {
// Null values should be omitted for query.
if (GoPointableIndex.of(context.getModel()).isNillable(shape.getValue())) {
writer.openBlock("if vv := v[key]; vv == nil {", "}", () -> {
writer.write("continue");
});
}
writer.write("om := object.Key(key)");
target.accept(getMemberSerVisitor(shape.getValue(), "v[key]", "om"));
});
writer.write("return nil");
}
@Override
protected void serializeStructure(GenerationContext context, StructureShape shape) {
GoWriter writer = context.getWriter().get();
writer.write("object := value.Object()");
writer.write("_ = object");
writer.write("");
// Use a TreeSet to sort the members.
Set<MemberShape> members = new TreeSet<>(shape.getAllMembers().values());
for (MemberShape member : members) {
if (!memberFilter.test(member)) {
continue;
}
Shape target = context.getModel().expectShape(member.getTarget());
GoValueAccessUtils.writeIfNonZeroValueMember(context.getModel(), context.getSymbolProvider(), writer,
member, "v", true, member.isRequired(), (operand) -> {
String locationName = getSerializedLocationName(member, member.getMemberName());
if (isFlattened(context, member)) {
writer.write("objectKey := object.FlatKey($S)", locationName);
} else {
writer.write("objectKey := object.Key($S)", locationName);
}
target.accept(getMemberSerVisitor(member, operand, "objectKey"));
});
writer.write("");
}
writer.write("return nil");
}
/**
* Retrieves the correct serialization location based on the member's
* xmlName trait or uses the default value.
*
* @param memberShape The member being serialized.
* @param defaultValue A default value for the location.
* @return The location where the member will be serialized.
*/
protected String getSerializedLocationName(MemberShape memberShape, String defaultValue) {
return memberShape.getTrait(XmlNameTrait.class)
.map(XmlNameTrait::getValue)
.orElse(defaultValue);
}
/**
* Tells whether the contents of the member should be flattened
* when serialized.
*
* @param context The generation context.
* @param memberShape The member being serialized.
* @return If the member's contents should be flattened when serialized.
*/
protected boolean isFlattened(GenerationContext context, MemberShape memberShape) {
return memberShape.hasTrait(XmlFlattenedTrait.class);
}
@Override
protected void serializeUnion(GenerationContext context, UnionShape shape) {
GoWriter writer = context.getWriter().get();
SymbolProvider symbolProvider = context.getSymbolProvider();
Symbol symbol = symbolProvider.toSymbol(shape);
writer.addUseImports(SmithyGoDependency.FMT);
writer.write("object := value.Object()");
writer.write("");
writer.openBlock("switch uv := v.(type) {", "}", () -> {
// Use a TreeSet to sort the members.
Set<MemberShape> members = new TreeSet<>(shape.getAllMembers().values());
for (MemberShape member : members) {
Shape target = context.getModel().expectShape(member.getTarget());
Symbol memberSymbol = SymbolUtils.createValueSymbolBuilder(
symbolProvider.toMemberName(member),
symbol.getNamespace()
).build();
writer.openBlock("case *$T:", "", memberSymbol, () -> {
String locationName = getSerializedLocationName(member, member.getMemberName());
if (isFlattened(context, member)) {
writer.write("objectKey := object.FlatKey($S)", locationName);
} else {
writer.write("objectKey := object.Key($S)", locationName);
}
target.accept(getMemberSerVisitor(member, "uv.Value", "objectKey"));
});
}
// Handle unknown union values
writer.openBlock("default:", "", () -> {
writer.write("return fmt.Errorf(\"attempted to serialize unknown member type %T"
+ " for union %T\", uv, v)");
});
});
writer.write("return nil");
}
}
| 8,315 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/JsonShapeDeserVisitor.java | /*
* 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.aws.go.codegen;
import java.util.Collections;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.TreeSet;
import java.util.function.Predicate;
import java.util.logging.Logger;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.go.codegen.GoWriter;
import software.amazon.smithy.go.codegen.ProtocolDocumentGenerator;
import software.amazon.smithy.go.codegen.SmithyGoDependency;
import software.amazon.smithy.go.codegen.SymbolUtils;
import software.amazon.smithy.go.codegen.UnionGenerator;
import software.amazon.smithy.go.codegen.integration.DocumentShapeDeserVisitor;
import software.amazon.smithy.go.codegen.integration.ProtocolGenerator.GenerationContext;
import software.amazon.smithy.model.shapes.CollectionShape;
import software.amazon.smithy.model.shapes.DocumentShape;
import software.amazon.smithy.model.shapes.MapShape;
import software.amazon.smithy.model.shapes.MemberShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.model.shapes.UnionShape;
import software.amazon.smithy.model.traits.JsonNameTrait;
import software.amazon.smithy.model.traits.TimestampFormatTrait;
import software.amazon.smithy.model.traits.TimestampFormatTrait.Format;
import software.amazon.smithy.utils.FunctionalUtils;
import software.amazon.smithy.utils.SmithyBuilder;
/**
* Visitor to generate deserialization functions for shapes in AWS JSON protocol
* document bodies.
* <p>
* This class handles function body generation for all types expected by the
* {@code DocumentShapeDeserVisitor}. No other shape type serialization is overwritten.
* <p>
* Timestamps are serialized to {@link Format}.EPOCH_SECONDS by default.
*/
public class JsonShapeDeserVisitor extends DocumentShapeDeserVisitor {
private static final Format DEFAULT_TIMESTAMP_FORMAT = Format.EPOCH_SECONDS;
private static final Logger LOGGER = Logger.getLogger(JsonShapeDeserVisitor.class.getName());
private final Predicate<MemberShape> memberFilter;
private final boolean supportJsonName;
/**
* Returns a new builder for building the JsonShapeDeserVisitor.
* @return Builder
*/
public static Builder builder() {
return new Builder();
}
protected JsonShapeDeserVisitor(Builder builder) {
super(SmithyBuilder.requiredState("context", builder.context), builder.deserNameProvider);
this.memberFilter = builder.memberFilter != null ? builder.memberFilter : FunctionalUtils.alwaysTrue();
this.supportJsonName = builder.supportJsonName;
}
private JsonMemberDeserVisitor getMemberDeserVisitor(MemberShape member, String dataDest) {
// Get the timestamp format to be used, defaulting to epoch seconds.
Format format = member.getMemberTrait(getContext().getModel(), TimestampFormatTrait.class)
.map(TimestampFormatTrait::getFormat).orElse(DEFAULT_TIMESTAMP_FORMAT);
return new JsonMemberDeserVisitor(getContext(), member, dataDest, format);
}
@Override
protected Map<String, String> getAdditionalArguments() {
return Collections.singletonMap("value", "interface{}");
}
@Override
protected void deserializeCollection(GenerationContext context, CollectionShape shape) {
GoWriter writer = context.getWriter().get();
MemberShape member = shape.getMember();
Shape target = context.getModel().expectShape(member.getTarget());
writeJsonTypeAssertStub(writer, shape);
Symbol symbol = context.getSymbolProvider().toSymbol(shape);
// Initialize the value now that the start stub has verified that there's something there.
writer.write("var cv $P", symbol);
writer.openBlock("if *v == nil {", "", () -> {
writer.write("cv = $P{}", symbol);
writer.openBlock("} else {", "}", () -> {
writer.write("cv = *v");
});
});
// Iterate through the decoder. The member visitor will handle popping tokens.
writer.openBlock("for _, value := range shape {", "}", () -> {
// We need to write out an intermediate variable to assign the value of the
// member to so that we can use it in the append function later.
writer.write("var col $P", context.getSymbolProvider().toSymbol(member));
target.accept(getMemberDeserVisitor(member, "col"));
writer.write("cv = append(cv, col)");
writer.write("");
});
writer.write("*v = cv");
writer.write("return nil");
}
@Override
protected void deserializeDocument(GenerationContext context, DocumentShape shape) {
GoWriter writer = context.getWriter().get();
Symbol newUnmarshaler = ProtocolDocumentGenerator.Utilities.getInternalDocumentSymbolBuilder(
context.getSettings(), ProtocolDocumentGenerator.INTERNAL_NEW_DOCUMENT_UNMARSHALER_FUNC)
.build();
writer.write("*v = $T(value)", newUnmarshaler);
writer.write("return nil");
}
@Override
protected void deserializeMap(GenerationContext context, MapShape shape) {
GoWriter writer = context.getWriter().get();
SymbolProvider symbolProvider = context.getSymbolProvider();
Symbol symbol = symbolProvider.toSymbol(shape);
MemberShape member = shape.getValue();
Symbol targetSymbol = symbolProvider.toSymbol(member);
writeJsonTypeAssertStub(writer, shape);
// Initialize the value now that the start stub has verified that there's something there.
writer.write("var mv $P", symbol);
writer.openBlock("if *v == nil {", "", () -> {
writer.write("mv = $P{}", symbol);
writer.openBlock("} else {", "}", () -> {
writer.write("mv = *v");
});
});
// Iterate through the decoder. The member visitor will handle popping tokens.
writer.openBlock("for key, value := range shape {", "}", () -> {
// Deserialize the value. We need to write out an intermediate variable here
// since we can't just pass in &mv[key]
writer.write("var parsedVal $P", context.getSymbolProvider().toSymbol(member));
context.getModel().expectShape(member.getTarget()).accept(getMemberDeserVisitor(member, "parsedVal"));
writer.write("mv[key] = parsedVal");
writer.write("");
});
writer.write("*v = mv");
writer.write("return nil");
}
@Override
protected void deserializeStructure(GenerationContext context, StructureShape shape) {
GoWriter writer = context.getWriter().get();
SymbolProvider symbolProvider = context.getSymbolProvider();
Symbol symbol = symbolProvider.toSymbol(shape);
writeJsonTypeAssertStub(writer, shape);
// Initialize the value now that the start stub has verified that there's something there.
writer.write("var sv $P", symbol);
writer.openBlock("if *v == nil {", "", () -> {
writer.write("sv = &$T{}", symbol);
writer.openBlock("} else {", "}", () -> {
writer.write("sv = *v");
});
});
// Iterate through the decoder. The member visitor will handle popping tokens.
writer.openBlock("for key, value := range shape {", "}", () -> {
writer.openBlock("switch key {", "}", () -> {
Set<MemberShape> members = new TreeSet<>(shape.members());
for (MemberShape member : members) {
if (!memberFilter.test(member)) {
continue;
}
String memberName = symbolProvider.toMemberName(member);
String serializedMemberName = getSerializedMemberName(member);
writer.openBlock("case $S:", "", serializedMemberName, () -> {
String dest = "sv." + memberName;
context.getModel().expectShape(member.getTarget()).accept(getMemberDeserVisitor(member, dest));
});
}
writer.openBlock("default:", "", () -> {
writer.write("_, _ = key, value");
});
});
});
writer.write("*v = sv");
writer.write("return nil");
}
@Override
protected void deserializeUnion(GenerationContext context, UnionShape shape) {
GoWriter writer = context.getWriter().get();
SymbolProvider symbolProvider = context.getSymbolProvider();
Symbol symbol = symbolProvider.toSymbol(shape);
writeJsonTypeAssertStub(writer, shape);
writer.write("var uv $P", symbol);
writer.openBlock("loop: for key, value := range shape {", "}", () -> {
writer.openBlock("if value == nil {", "}", () -> writer.write("continue"));
writer.openBlock("switch key {", "}", () -> {
Set<MemberShape> members = new TreeSet<>(shape.members());
for (MemberShape member : members) {
if (!memberFilter.test(member)) {
continue;
}
Shape target = context.getModel().expectShape(member.getTarget());
Symbol targetSymbol = symbolProvider.toSymbol(member);
Symbol memberSymbol = SymbolUtils.createValueSymbolBuilder(
symbolProvider.toMemberName(member),
symbol.getNamespace()
).build();
String serializedMemberName = getSerializedMemberName(member);
writer.openBlock("case $S:", "", serializedMemberName, () -> {
writer.write("var mv $P", targetSymbol);
target.accept(getMemberDeserVisitor(member, "mv"));
// Union member types are never pointer types.
writer.write("uv = &$T{Value: mv}", memberSymbol);
writer.write("break loop");
});
}
writer.openBlock("default:", "", () -> {
// This is the function to take a value and convert it to the union type.
Symbol unknownMemberSymbol = SymbolUtils.createValueSymbolBuilder(
UnionGenerator.UNKNOWN_MEMBER_NAME,
symbol.getNamespace()
).build();
writer.write("uv = &$T{Tag: key}", unknownMemberSymbol);
writer.write("break loop");
});
});
});
writer.write("*v = uv");
writer.write("return nil");
}
private String getSerializedMemberName(MemberShape memberShape) {
if (this.supportJsonName) {
Optional<JsonNameTrait> jsonNameTrait = memberShape.getTrait(JsonNameTrait.class);
return jsonNameTrait.isPresent() ? jsonNameTrait.get().getValue() : memberShape.getMemberName();
}
return memberShape.getMemberName();
}
/**
* Writes out a stub to initialize decoding.
*
* @param writer The GoWriter to use.
* @param shape The shape the stub is intended to start parsing.
*/
private void writeJsonTypeAssertStub(GoWriter writer, Shape shape) {
writer.openBlock("if value == nil {", "}", () -> writer.write("return nil"));
writer.write("");
writer.addUseImports(SmithyGoDependency.FMT);
String targetType;
if (shape instanceof CollectionShape) {
targetType = "[]interface{}";
} else if (shape instanceof StructureShape || shape instanceof MapShape || shape instanceof UnionShape) {
targetType = "map[string]interface{}";
} else {
throw new CodegenException("unimplemented JSON type " + shape);
}
writer.write("shape, ok := value.($L)", targetType);
writer.openBlock("if !ok {", "}", () -> writer.write("return fmt.Errorf(\"unexpected JSON type %v\", value)"));
writer.write("");
}
public static final class Builder implements SmithyBuilder<JsonShapeDeserVisitor> {
private GenerationContext context;
private Predicate<MemberShape> memberFilter;
private DeserializerNameProvider deserNameProvider;
private boolean supportJsonName;
private Builder() {}
public Builder context(GenerationContext context) {
this.context = context;
return this;
}
public Builder memberFilter(Predicate<MemberShape> filter) {
this.memberFilter = filter;
return this;
}
public Builder deserializerNameProvider(DeserializerNameProvider nameProvider) {
this.deserNameProvider = nameProvider;
return this;
}
public Builder supportJsonName(boolean v) {
this.supportJsonName = v;
return this;
}
@Override
public JsonShapeDeserVisitor build() {
return new JsonShapeDeserVisitor(this);
}
}
}
| 8,316 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsSignatureVersion4aUtils.java | /*
* 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.aws.go.codegen;
import software.amazon.smithy.aws.go.codegen.customization.AwsCustomGoDependency;
import software.amazon.smithy.go.codegen.GoDependency;
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.model.Model;
import software.amazon.smithy.model.shapes.ServiceShape;
/**
* Generates Client Configuration, Middleware, and Config Resolvers for AWS Signature Version 4a support.
*/
public final class AwsSignatureVersion4aUtils {
public static final String RESOLVE_CREDENTIAL_PROVIDER = "resolveCredentialProvider";
public static final String REGISTER_MIDDLEWARE_FUNCTION = "swapWithCustomHTTPSignerMiddleware";
public static final String V4A_SIGNER_INTERFACE_NAME = "httpSignerV4a";
public static final String SIGNER_OPTION_FIELD_NAME = V4A_SIGNER_INTERFACE_NAME;
public static final String NEW_SIGNER_FUNC_NAME = "newDefaultV4aSigner";
public static final String SIGNER_RESOLVER = "resolveHTTPSignerV4a";
public static void writeCredentialProviderResolver(GoWriter writer) {
writer.pushState();
writer.putContext("resolverName", RESOLVE_CREDENTIAL_PROVIDER);
writer.putContext("fieldName", AddAwsConfigFields.CREDENTIALS_CONFIG_NAME);
writer.putContext("credType", SymbolUtils.createPointableSymbolBuilder("CredentialsProvider",
AwsCustomGoDependency.INTERNAL_SIGV4A).build());
writer.putContext("anonType", SymbolUtils.createPointableSymbolBuilder("AnonymousCredentials",
AwsCustomGoDependency.AWS_CORE).build());
writer.putContext("isProvider", SymbolUtils.createValueSymbolBuilder("IsCredentialsProvider",
AwsCustomGoDependency.AWS_CORE).build());
writer.putContext("adapType", SymbolUtils.createPointableSymbolBuilder("SymmetricCredentialAdaptor",
AwsCustomGoDependency.INTERNAL_SIGV4A).build());
writer.write("""
func $resolverName:L(o *Options) {
if o.$fieldName:L == nil {
return
}
if _, ok := o.$fieldName:L.($credType:T); ok {
return
}
if $isProvider:T(o.$fieldName:L, ($anonType:P)(nil)) {
return
}
o.$fieldName:L = &$adapType:T{SymmetricProvider: o.$fieldName:L}
}
""");
writer.popState();
}
public static void writerSignerInterface(GoWriter writer) {
writer.pushState();
writer.putContext("ifaceName", V4A_SIGNER_INTERFACE_NAME);
writer.putContext("contextType", SymbolUtils.createValueSymbolBuilder("Context",
SmithyGoDependency.CONTEXT).build());
writer.putContext("credType", SymbolUtils.createValueSymbolBuilder("Credentials",
AwsGoDependency.INTERNAL_SIGV4A).build());
writer.putContext("reqType", SymbolUtils.createPointableSymbolBuilder("Request",
SmithyGoDependency.NET_HTTP).build());
writer.putContext("timeType", SymbolUtils.createPointableSymbolBuilder("Time",
SmithyGoDependency.TIME).build());
writer.putContext("optionsType", SymbolUtils.createPointableSymbolBuilder("SignerOptions",
AwsGoDependency.INTERNAL_SIGV4A).build());
writer.write("""
type $ifaceName:L interface {
SignHTTP(ctx $contextType:T, credentials $credType:T, r $reqType:P, payloadHash,
service string, regionSet []string, signingTime $timeType:T,
optFns ...func($optionsType:P)) error
}
""");
writer.popState();
}
public static void writerConfigFieldResolver(GoWriter writer, ServiceShape serviceShape) {
writer.pushState();
writer.putContext("resolverName", SIGNER_RESOLVER);
writer.putContext("optionName", SIGNER_OPTION_FIELD_NAME);
writer.putContext("newSigner", NEW_SIGNER_FUNC_NAME);
writer.write("""
func $resolverName:L(o *Options) {
if o.$optionName:L != nil {
return
}
o.$optionName:L = $newSigner:L(*o)
}
""");
writer.popState();
}
public static void writeNewV4ASignerFunc(GoWriter writer, ServiceShape serviceShape) {
writeNewV4ASignerFunc(writer, serviceShape, false);
}
public static void writeNewV4ASignerFunc(
GoWriter writer,
ServiceShape serviceShape,
boolean disableURIPathEscaping
) {
writer.pushState();
writer.putContext("funcName", NEW_SIGNER_FUNC_NAME);
writer.putContext("signerType", SymbolUtils.createPointableSymbolBuilder("Signer",
AwsCustomGoDependency.INTERNAL_SIGV4A).build());
writer.putContext("newSigner", SymbolUtils.createValueSymbolBuilder("NewSigner",
AwsCustomGoDependency.INTERNAL_SIGV4A).build());
writer.putContext("signerOptions", SymbolUtils.createPointableSymbolBuilder("SignerOptions",
AwsCustomGoDependency.INTERNAL_SIGV4A).build());
writer.putContext("loggerField", AddAwsConfigFields.LOGGER_CONFIG_NAME);
writer.putContext("modeField", AddAwsConfigFields.LOG_MODE_CONFIG_NAME);
writer.putContext("disableEscape", disableURIPathEscaping);
writer.write("""
func $funcName:L(o Options) $signerType:P {
return $newSigner:T(func(so $signerOptions:P){
so.Logger = o.$loggerField:L
so.LogSigning = o.$modeField:L.IsSigning()
so.DisableURIPathEscaping = $disableEscape:L
})
}
""");
writer.popState();
}
public static void writeMiddlewareRegister(
Model model,
GoWriter writer,
ServiceShape serviceShape,
GoDependency signerMiddleware
) {
writer.pushState();
writer.putContext("funcName", REGISTER_MIDDLEWARE_FUNCTION);
writer.putContext("stackType", SymbolUtils.createPointableSymbolBuilder("Stack",
SmithyGoDependency.SMITHY_MIDDLEWARE).build());
writer.putContext("newMiddleware", SymbolUtils.createValueSymbolBuilder(
"NewSignHTTPRequestMiddleware", signerMiddleware).build());
writer.putContext("middleOptions", SymbolUtils.createValueSymbolBuilder(
"SignHTTPRequestMiddlewareOptions", signerMiddleware).build());
writer.putContext("registerMiddleware", SymbolUtils.createValueSymbolBuilder(
"RegisterSigningMiddleware", signerMiddleware).build());
writer.putContext("credFileName", AddAwsConfigFields.CREDENTIALS_CONFIG_NAME);
writer.putContext("v4Signer", AwsSignatureVersion4.SIGNER_CONFIG_FIELD_NAME);
writer.putContext("v4aSigner", SIGNER_OPTION_FIELD_NAME);
writer.putContext("logMode", AddAwsConfigFields.LOG_MODE_CONFIG_NAME);
writer.write("""
func $funcName:L(stack $stackType:P, o Options) error {
mw := $newMiddleware:T($middleOptions:T{
CredentialsProvider: o.$credFileName:L,
V4Signer: o.$v4Signer:L,
V4aSigner: o.$v4aSigner:L,
LogSigning: o.$logMode:L.IsSigning(),
})
return $registerMiddleware:T(stack, mw)
}
""");
writer.popState();
}
}
| 8,317 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/EndpointDisableHttps.java | /*
* Copyright 2023 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.aws.go.codegen;
import java.util.ArrayList;
import java.util.List;
import software.amazon.smithy.codegen.core.Symbol;
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.GoStackStepMiddlewareGenerator;
import software.amazon.smithy.go.codegen.GoWriter;
import software.amazon.smithy.go.codegen.MiddlewareIdentifier;
import software.amazon.smithy.go.codegen.SmithyGoDependency;
import software.amazon.smithy.go.codegen.SymbolUtils;
import software.amazon.smithy.go.codegen.endpoints.EndpointMiddlewareGenerator;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.go.codegen.integration.MiddlewareRegistrar;
import software.amazon.smithy.go.codegen.integration.ProtocolUtils;
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.OperationShape;
import software.amazon.smithy.model.shapes.ToShapeId;
/*
* Adds support for non-SSL endpoints during endpoint resolution.
* The new Rules Engine endpoint resolution doesnt support non-SSL endpoints.
* So this middleware exists for backwards compatibility with legacy
* endpoint resolution. It is operation specific because it is being inserted
* directly after the operation-specific endpoint resolution middleware.
*/
public class EndpointDisableHttps implements GoIntegration {
private final List<RuntimeClientPlugin> runtimeClientPlugins = new ArrayList<>();
public static final String MIDDLEWARE_ID = "endpointDisableHTTPSMiddleware";
public static final String MIDDLEWARE_ADDER = String.format("add%s", MIDDLEWARE_ID);
/**
* Gets the sort order of the customization from -128 to 127, with lowest
* executed first. Needs to execute after Rules Engine endpoint
* resolution middleware insertion.
*
* @return Returns the sort order, defaults to 127.
*/
@Override
public byte getOrder() {
return 127;
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return runtimeClientPlugins;
}
@Override
public void processFinalizedModel(GoSettings settings, Model model) {
var serviceShape = settings.getService(model);
runtimeClientPlugins.add(RuntimeClientPlugin.builder()
.servicePredicate((m, s) -> s.equals(serviceShape))
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(
MIDDLEWARE_ADDER)
.build())
.useClientOptions()
.build())
.build());
}
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator) {
var serviceShape = settings.getService(model);
goDelegator.useShapeWriter(serviceShape, writer -> {
GoStackStepMiddlewareGenerator middleware = GoStackStepMiddlewareGenerator
.createSerializeStepMiddleware(
MIDDLEWARE_ID,
MiddlewareIdentifier.string(MIDDLEWARE_ID));
middleware.writeMiddleware(writer, this::generateMiddlewareResolverBody,
this::generateMiddlewareStructureMembers);
writer.write(
"""
func $L(stack $P, o Options) error {
return stack.Serialize.Insert(&$L{
EndpointDisableHTTPS: o.EndpointOptions.DisableHTTPS,
}, \"$L\", middleware.Before)
}
""",
MIDDLEWARE_ADDER,
SymbolUtils.createPointableSymbolBuilder("Stack",
SmithyGoDependency.SMITHY_MIDDLEWARE).build(),
MIDDLEWARE_ID,
ProtocolUtils.OPERATION_SERIALIZER_MIDDLEWARE_ID);
writer.write("");
});
}
private void generateMiddlewareResolverBody(GoStackStepMiddlewareGenerator g, GoWriter writer) {
writer.write(
"""
req, ok := in.Request.($P)
if !ok {
return out, metadata, $T(\"unknown transport type %T\", in.Request)
}
if m.EndpointDisableHTTPS && !$T(ctx) {
req.URL.Scheme = \"http\"
}
return next.HandleSerialize(ctx, in)
""",
SymbolUtils.createPointableSymbolBuilder("Request",
SmithyGoDependency.SMITHY_HTTP_TRANSPORT).build(),
SymbolUtils.createValueSymbolBuilder("Errorf", SmithyGoDependency.FMT).build(),
SymbolUtils.createValueSymbolBuilder("GetHostnameImmutable", SmithyGoDependency.SMITHY_HTTP_TRANSPORT).build()
);
}
private void generateMiddlewareStructureMembers(GoStackStepMiddlewareGenerator g, GoWriter writer) {
writer.write("EndpointDisableHTTPS $L", "bool");
}
}
| 8,318 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsSignatureVersion4.java | /*
* 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.aws.go.codegen;
import java.util.List;
import java.util.Map;
import software.amazon.smithy.aws.traits.auth.SigV4Trait;
import software.amazon.smithy.codegen.core.Symbol;
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.ConfigFieldResolver;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.go.codegen.integration.RuntimeClientPlugin;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.knowledge.ServiceIndex;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.traits.OptionalAuthTrait;
import software.amazon.smithy.model.traits.Trait;
import software.amazon.smithy.utils.ListUtils;
/**
* Generates Client Configuration, Middleware, and Config Resolvers for AWS Signature Version 4 support.
*/
public final class AwsSignatureVersion4 implements GoIntegration {
public static final String REGISTER_MIDDLEWARE_FUNCTION = "addHTTPSignerV4Middleware";
public static final String SIGNER_INTERFACE_NAME = "HTTPSignerV4";
public static final String SIGNER_CONFIG_FIELD_NAME = SIGNER_INTERFACE_NAME;
public static final String NEW_SIGNER_FUNC_NAME = "newDefaultV4Signer";
public static final String NEW_SIGNER_V4A_FUNC_NAME = "newDefaultV4aSigner";
public static final String SIGNER_RESOLVER = "resolve" + SIGNER_CONFIG_FIELD_NAME;
private static final List<String> DISABLE_URI_PATH_ESCAPE = ListUtils.of("com.amazonaws.s3#AmazonS3");
@Override
public byte getOrder() {
return -48;
}
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
ServiceShape serviceShape = settings.getService(model);
if (isSupportedAuthentication(model, serviceShape)) {
goDelegator.useShapeWriter(serviceShape, writer -> {
writeMiddlewareRegister(model, writer, serviceShape);
writerSignerInterface(writer);
writerConfigFieldResolver(writer, serviceShape);
writeNewV4SignerFunc(writer, serviceShape);
});
}
}
private void writerSignerInterface(GoWriter writer) {
writer.openBlock("type $L interface {", "}", SIGNER_INTERFACE_NAME, () -> {
writer.addUseImports(SmithyGoDependency.CONTEXT);
writer.addUseImports(AwsGoDependency.AWS_CORE);
writer.addUseImports(AwsGoDependency.AWS_SIGNER_V4);
writer.addUseImports(SmithyGoDependency.NET_HTTP);
writer.addUseImports(SmithyGoDependency.TIME);
writer.write("SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, "
+ "payloadHash string, service string, region string, signingTime time.Time, "
+ "optFns ...func(*v4.SignerOptions)) error");
});
}
private void writerConfigFieldResolver(GoWriter writer, ServiceShape serviceShape) {
writer.openBlock("func $L(o *Options) {", "}", SIGNER_RESOLVER, () -> {
writer.openBlock("if o.$L != nil {", "}", SIGNER_CONFIG_FIELD_NAME, () -> writer.write("return"));
writer.write("o.$L = $L(*o)", SIGNER_CONFIG_FIELD_NAME, NEW_SIGNER_FUNC_NAME);
});
writer.write("");
}
private void writeNewV4SignerFunc(GoWriter writer, ServiceShape serviceShape) {
Symbol signerSymbol = SymbolUtils.createValueSymbolBuilder("Signer",
AwsGoDependency.AWS_SIGNER_V4).build();
Symbol newSignerSymbol = SymbolUtils.createValueSymbolBuilder("NewSigner",
AwsGoDependency.AWS_SIGNER_V4).build();
Symbol signerOptionsSymbol = SymbolUtils.createPointableSymbolBuilder("SignerOptions",
AwsGoDependency.AWS_SIGNER_V4).build();
writer.openBlock("func $L(o Options) *$T {", "}", NEW_SIGNER_FUNC_NAME, signerSymbol, () -> {
writer.openBlock("return $T(func(so $P) {", "})", newSignerSymbol, signerOptionsSymbol, () -> {
writer.write("so.Logger = o.$L", AddAwsConfigFields.LOGGER_CONFIG_NAME);
writer.write("so.LogSigning = o.$L.IsSigning()", AddAwsConfigFields.LOG_MODE_CONFIG_NAME);
if (DISABLE_URI_PATH_ESCAPE.contains(serviceShape.getId().toString())) {
writer.write("so.DisableURIPathEscaping = true");
}
});
});
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return ListUtils.of(RuntimeClientPlugin.builder()
.servicePredicate(AwsSignatureVersion4::isSupportedAuthentication)
.addConfigField(ConfigField.builder()
.name(SIGNER_INTERFACE_NAME)
.type(SymbolUtils.createValueSymbolBuilder(SIGNER_INTERFACE_NAME).build())
.documentation("Signature Version 4 (SigV4) Signer")
.build())
.addConfigFieldResolver(
ConfigFieldResolver.builder()
.location(ConfigFieldResolver.Location.CLIENT)
.target(ConfigFieldResolver.Target.INITIALIZATION)
.resolver(SymbolUtils.createValueSymbolBuilder(SIGNER_RESOLVER).build())
.build())
.build());
}
private void writeMiddlewareRegister(Model model, GoWriter writer, ServiceShape serviceShape) {
writer.addUseImports(SmithyGoDependency.SMITHY_MIDDLEWARE);
writer.openBlock("func $L(stack $P, o Options) error {", "}", REGISTER_MIDDLEWARE_FUNCTION,
SymbolUtils.createPointableSymbolBuilder("Stack", SmithyGoDependency.SMITHY_MIDDLEWARE).build(), () -> {
Symbol newMiddlewareSymbol = SymbolUtils.createValueSymbolBuilder(
"NewSignHTTPRequestMiddleware", AwsGoDependency.AWS_SIGNER_V4).build();
Symbol middlewareOptionsSymbol = SymbolUtils.createValueSymbolBuilder(
"SignHTTPRequestMiddlewareOptions", AwsGoDependency.AWS_SIGNER_V4).build();
writer.openBlock("mw := $T($T{", "})", newMiddlewareSymbol, middlewareOptionsSymbol, () -> {
writer.write("CredentialsProvider: o.$L,", AddAwsConfigFields.CREDENTIALS_CONFIG_NAME);
writer.write("Signer: o.$L,", SIGNER_CONFIG_FIELD_NAME);
writer.write("LogSigning: o.$L.IsSigning(),", AddAwsConfigFields.LOG_MODE_CONFIG_NAME);
});
writer.write("return stack.Finalize.Add(mw, middleware.After)");
});
writer.write("");
}
/**
* Returns if the SigV4Trait is a auth scheme supported by the service.
*
* @param model model definition
* @param serviceShape service shape for the API
* @return if the SigV4 trait is used by the service.
*/
public static boolean isSupportedAuthentication(Model model, ServiceShape serviceShape) {
return ServiceIndex.of(model).getAuthSchemes(serviceShape).values().stream().anyMatch(trait -> trait.getClass()
.equals(SigV4Trait.class));
}
/**
* Returns if the SigV4Trait is a auth scheme for the service and operation.
*
* @param model model definition
* @param service service shape for the API
* @param operation operation shape
* @return if SigV4Trait is an auth scheme for the operation and service.
*/
public static boolean hasSigV4AuthScheme(Model model, ServiceShape service, OperationShape operation) {
Map<ShapeId, Trait> auth = ServiceIndex.of(model).getEffectiveAuthSchemes(service.getId(), operation.getId());
return auth.containsKey(SigV4Trait.ID) && !operation.hasTrait(OptionalAuthTrait.class);
}
}
| 8,319 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsGoDependency.java | /*
* 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.aws.go.codegen;
import software.amazon.smithy.go.codegen.GoDependency;
import software.amazon.smithy.go.codegen.SmithyGoDependency;
/**
* A class of constants for dependencies used by this package.
*/
public class AwsGoDependency {
public static final String AWS_SOURCE_PATH = "github.com/aws/aws-sdk-go-v2";
public static final GoDependency AWS_REST_JSON_PROTOCOL = aws("aws/protocol/restjson");
public static final GoDependency AWS_QUERY_PROTOCOL = aws("aws/protocol/query");
public static final GoDependency AWS_EC2QUERY_PROTOCOL = aws("aws/protocol/ec2query");
public static final GoDependency AWS_CORE = aws("aws");
public static final GoDependency AWS_MIDDLEWARE = aws("aws/middleware", "awsmiddleware");
public static final GoDependency AWS_RETRY = aws("aws/retry");
public static final GoDependency AWS_SIGNER_V4 = aws("aws/signer/v4");
public static final GoDependency AWS_XML = aws("aws/protocol/xml", "awsxml");
public static final GoDependency AWS_HTTP_TRANSPORT = aws("aws/transport/http", "awshttp");
public static final GoDependency AWSTESTING_UNIT = aws("internal/awstesting/unit");
public static final GoDependency SERVICE_INTERNAL_EVENTSTREAM = awsModuleDep("aws/protocol/eventstream",
null, Versions.AWS_PROTOCOL_EVENTSTREAM, "eventstream");
public static final GoDependency SERVICE_INTERNAL_EVENTSTREAMAPI = awsModuleDep("aws/protocol/eventstream",
"eventstreamapi", Versions.AWS_PROTOCOL_EVENTSTREAM, "eventstreamapi");
public static final GoDependency CONFIG = aws("config");
public static final GoDependency AWS_ENDPOINT_RULESFN = aws("internal/endpoints/awsrulesfn");
public static final GoDependency INTERNAL_ENDPOINTS = aws("internal/endpoints");
public static final GoDependency INTERNAL_AUTH = aws("internal/auth", "internalauth");
public static final GoDependency INTERNAL_ENDPOINTS_V2 = awsModuleDep("internal/endpoints/v2", null,
Versions.INTERNAL_ENDPOINTS_V2, "endpoints");
public static final GoDependency S3_SHARED_CONFIG = aws("service/internal/s3shared/config", "s3sharedconfig");
public static final GoDependency SERVICE_INTERNAL_CONFIG = awsModuleDep("internal/configsources",
null, Versions.SERVICE_INTERNAL_CONFIG, "internalConfig");
public static final GoDependency SERVICE_INTERNAL_ENDPOINT_DISCOVERY = awsModuleDep("service/internal/endpoint-discovery",
null, Versions.SERVICE_INTERNAL_ENDPOINT_DISCOVERY, "internalEndpointDiscovery");
public static final GoDependency AWS_DEFAULTS = aws("aws/defaults");
public static final GoDependency SERVICE_INTERNAL_CHECKSUM = awsModuleDep("service/internal/checksum",
null, Versions.SERVICE_INTERNAL_CHECKSUM, "internalChecksum");
public static final GoDependency INTERNAL_SIGV4A = awsModuleDep("internal/v4a",
null, Versions.INTERNAL_SIGV4A, "v4a");
public static final GoDependency S3_INTERNAL_ARN = aws("service/internal/s3shared/arn", "s3arn");
public static final GoDependency AWS_ARN = aws("aws/arn", "awsarn");
public static final GoDependency AWS_PROTOCOL_TEST_HTTP_CLIENT = aws("internal/protocoltest", "protocoltesthttp");
public static final GoDependency REGEXP = SmithyGoDependency.stdlib("regexp");
protected AwsGoDependency() {
}
protected static GoDependency aws(String relativePath) {
return aws(relativePath, null);
}
protected static GoDependency aws(String relativePath, String alias) {
return module(AWS_SOURCE_PATH, relativePath, Versions.AWS_SDK, alias);
}
/**
* awsModuleDep returns a GoDependency relative to the version of AWS_SDK core.
*
* @param moduleImportPath the module path within aws sdk to be added as go mod dependency.
* @param relativePath the relative path which will be used as import path relative to aws sdk path.
* @param version the version of the aws module dependency to be imported
* @param alias the go import alias.
* @return GoDependency
*/
protected static GoDependency awsModuleDep(
String moduleImportPath,
String relativePath,
String version,
String alias
) {
moduleImportPath = AWS_SOURCE_PATH + "/" + moduleImportPath;
return module(moduleImportPath, relativePath, version, alias);
}
protected static GoDependency module(
String moduleImportPath,
String relativePath,
String version,
String alias
) {
String importPath = moduleImportPath;
if (relativePath != null) {
importPath = importPath + "/" + relativePath;
}
return GoDependency.moduleDependency(moduleImportPath, importPath, version, alias);
}
private static final class Versions {
private static final String AWS_SDK = "v1.4.0";
private static final String SERVICE_INTERNAL_CONFIG = "v0.0.0-00010101000000-000000000000";
private static final String SERVICE_INTERNAL_ENDPOINT_DISCOVERY = "v0.0.0-00010101000000-000000000000";
private static final String INTERNAL_ENDPOINTS_V2 = "v2.0.0-00010101000000-000000000000";
private static final String AWS_PROTOCOL_EVENTSTREAM = "v0.0.0-00010101000000-000000000000";
private static final String SERVICE_INTERNAL_CHECKSUM = "v0.0.0-00010101000000-000000000000";
private static final String INTERNAL_SIGV4A = "v0.0.0-00010101000000-000000000000";
}
}
| 8,320 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/DocumentMemberSerVisitor.java | /*
* 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.aws.go.codegen;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.go.codegen.CodegenUtils;
import software.amazon.smithy.go.codegen.GoWriter;
import software.amazon.smithy.go.codegen.SmithyGoDependency;
import software.amazon.smithy.go.codegen.integration.ProtocolGenerator;
import software.amazon.smithy.go.codegen.integration.ProtocolGenerator.GenerationContext;
import software.amazon.smithy.go.codegen.integration.ProtocolUtils;
import software.amazon.smithy.go.codegen.knowledge.GoPointableIndex;
import software.amazon.smithy.model.shapes.BigDecimalShape;
import software.amazon.smithy.model.shapes.BigIntegerShape;
import software.amazon.smithy.model.shapes.BlobShape;
import software.amazon.smithy.model.shapes.BooleanShape;
import software.amazon.smithy.model.shapes.ByteShape;
import software.amazon.smithy.model.shapes.DocumentShape;
import software.amazon.smithy.model.shapes.DoubleShape;
import software.amazon.smithy.model.shapes.FloatShape;
import software.amazon.smithy.model.shapes.IntegerShape;
import software.amazon.smithy.model.shapes.ListShape;
import software.amazon.smithy.model.shapes.LongShape;
import software.amazon.smithy.model.shapes.MapShape;
import software.amazon.smithy.model.shapes.MemberShape;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ResourceShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.SetShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.ShapeVisitor;
import software.amazon.smithy.model.shapes.ShortShape;
import software.amazon.smithy.model.shapes.StringShape;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.model.shapes.TimestampShape;
import software.amazon.smithy.model.shapes.UnionShape;
import software.amazon.smithy.model.traits.EnumTrait;
import software.amazon.smithy.model.traits.TimestampFormatTrait.Format;
/**
* Visitor to generate member values for aggregate types serialized in documents.
*/
public class DocumentMemberSerVisitor implements ShapeVisitor<Void> {
private final GenerationContext context;
private final String dataSource;
private final String dataDest;
private final Format timestampFormat;
private final MemberShape member;
private final GoPointableIndex pointableIndex;
public DocumentMemberSerVisitor(
GenerationContext context,
MemberShape member,
String dataSource,
String dataDest,
Format timestampFormat
) {
this.context = context;
this.member = member;
this.dataSource = dataSource;
this.dataDest = dataDest;
this.timestampFormat = timestampFormat;
this.pointableIndex = GoPointableIndex.of(context.getModel());
}
@Override
public Void blobShape(BlobShape shape) {
String source = CodegenUtils.getAsValueIfDereferencable(pointableIndex, member, dataSource);
context.getWriter().get().write("$L.Base64EncodeBytes($L)", dataDest, source);
return null;
}
@Override
public Void booleanShape(BooleanShape shape) {
String source = CodegenUtils.getAsValueIfDereferencable(pointableIndex, member, dataSource);
context.getWriter().get().write("$L.Boolean($L)", dataDest, source);
return null;
}
@Override
public Void byteShape(ByteShape shape) {
String source = CodegenUtils.getAsValueIfDereferencable(pointableIndex, member, dataSource);
context.getWriter().get().write("$L.Byte($L)", dataDest, source);
return null;
}
@Override
public Void shortShape(ShortShape shape) {
String source = CodegenUtils.getAsValueIfDereferencable(pointableIndex, member, dataSource);
context.getWriter().get().write("$L.Short($L)", dataDest, source);
return null;
}
@Override
public Void integerShape(IntegerShape shape) {
String source = CodegenUtils.getAsValueIfDereferencable(pointableIndex, member, dataSource);
context.getWriter().get().write("$L.Integer($L)", dataDest, source);
return null;
}
@Override
public Void longShape(LongShape shape) {
String source = CodegenUtils.getAsValueIfDereferencable(pointableIndex, member, dataSource);
context.getWriter().get().write("$L.Long($L)", dataDest, source);
return null;
}
@Override
public Void floatShape(FloatShape shape) {
String source = CodegenUtils.getAsValueIfDereferencable(pointableIndex, member, dataSource);
GoWriter writer = context.getWriter().get();
handleDecimal(writer, dataDest, "float64(" + source + ")",
() -> writer.write("$L.Float($L)", dataDest, source));
return null;
}
@Override
public Void doubleShape(DoubleShape shape) {
String source = CodegenUtils.getAsValueIfDereferencable(pointableIndex, member, dataSource);
GoWriter writer = context.getWriter().get();
handleDecimal(writer, dataDest, source, () -> writer.write("$L.Double($L)", dataDest, source));
return null;
}
private void handleDecimal(GoWriter writer, String dataDest, String source, Runnable defaultCase) {
writer.addUseImports(SmithyGoDependency.MATH);
writer.openBlock("switch {", "}", () -> {
writer.openBlock("case math.IsNaN($L):", "", source, () -> {
writer.write("$L.String(\"NaN\")", dataDest);
});
writer.openBlock("case math.IsInf($L, 1):", "", source, () -> {
writer.write("$L.String(\"Infinity\")", dataDest);
});
writer.openBlock("case math.IsInf($L, -1):", "", source, () -> {
writer.write("$L.String(\"-Infinity\")", dataDest);
});
writer.openBlock("default:", "", defaultCase);
});
}
@Override
public Void timestampShape(TimestampShape shape) {
String source = CodegenUtils.getAsValueIfDereferencable(pointableIndex, member, dataSource);
GoWriter writer = context.getWriter().get();
writer.addUseImports(SmithyGoDependency.SMITHY_TIME);
switch (timestampFormat) {
case DATE_TIME:
writer.write("$L.String(smithytime.FormatDateTime($L))", dataDest, source);
break;
case HTTP_DATE:
writer.write("$L.String(smithytime.FormatHTTPDate($L))", dataDest, source);
break;
case EPOCH_SECONDS:
writer.write("$L.Double(smithytime.FormatEpochSeconds($L))", dataDest, source);
break;
case UNKNOWN:
throw new CodegenException("Unknown timestamp format");
}
return null;
}
@Override
public Void stringShape(StringShape shape) {
String source = CodegenUtils.getAsValueIfDereferencable(pointableIndex, member, dataSource);
if (shape.hasTrait(EnumTrait.class)) {
source = String.format("string(%s)", source);
}
context.getWriter().get().write("$L.String($L)", dataDest, source);
return null;
}
@Override
public Void bigIntegerShape(BigIntegerShape shape) {
// Fail instead of losing precision through Number.
unsupportedShape(shape);
return null;
}
@Override
public Void bigDecimalShape(BigDecimalShape shape) {
// Fail instead of losing precision through Number.
unsupportedShape(shape);
return null;
}
private void unsupportedShape(Shape shape) {
throw new CodegenException(String.format("Cannot serialize shape type %s on protocol, shape: %s.",
shape.getType(), shape.getId()));
}
@Override
public Void operationShape(OperationShape shape) {
throw new CodegenException("Operation shapes cannot be bound to documents.");
}
@Override
public Void resourceShape(ResourceShape shape) {
throw new CodegenException("Resource shapes cannot be bound to documents.");
}
@Override
public Void serviceShape(ServiceShape shape) {
throw new CodegenException("Service shapes cannot be bound to documents.");
}
@Override
public Void memberShape(MemberShape shape) {
throw new CodegenException("Member shapes cannot be bound to documents.");
}
@Override
public Void documentShape(DocumentShape shape) {
writeDelegateFunction(shape);
return null;
}
@Override
public Void structureShape(StructureShape shape) {
writeDelegateFunction(shape);
return null;
}
@Override
public Void unionShape(UnionShape shape) {
writeDelegateFunction(shape);
return null;
}
@Override
public Void listShape(ListShape shape) {
writeDelegateFunction(shape);
return null;
}
@Override
public Void setShape(SetShape shape) {
writeDelegateFunction(shape);
return null;
}
@Override
public Void mapShape(MapShape shape) {
writeDelegateFunction(shape);
return null;
}
private void writeDelegateFunction(Shape shape) {
String serFunctionName = ProtocolGenerator.getDocumentSerializerFunctionName(shape, context.getService(), context.getProtocolName());
GoWriter writer = context.getWriter().get();
ProtocolUtils.writeSerDelegateFunction(context, writer, member, dataSource, (srcVar) -> {
writer.openBlock("if err := $L($L, $L); err != nil {", "}", serFunctionName, srcVar, dataDest,
() -> writer.write("return err"));
});
}
}
| 8,321 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/EndpointGenerator.java | /*
* 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.aws.go.codegen;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.TreeMap;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import software.amazon.smithy.aws.go.codegen.customization.S3ModelUtils;
import software.amazon.smithy.aws.traits.ServiceTrait;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.go.codegen.GoSettings;
import software.amazon.smithy.go.codegen.GoStackStepMiddlewareGenerator;
import software.amazon.smithy.go.codegen.GoWriter;
import software.amazon.smithy.go.codegen.MiddlewareIdentifier;
import software.amazon.smithy.go.codegen.SmithyGoDependency;
import software.amazon.smithy.go.codegen.SymbolUtils;
import software.amazon.smithy.go.codegen.TriConsumer;
import software.amazon.smithy.go.codegen.endpoints.EndpointResolutionGenerator;
import software.amazon.smithy.go.codegen.integration.ConfigField;
import software.amazon.smithy.go.codegen.integration.ProtocolUtils;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.node.ArrayNode;
import software.amazon.smithy.model.node.Node;
import software.amazon.smithy.model.node.ObjectNode;
import software.amazon.smithy.model.node.StringNode;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.utils.IoUtils;
import software.amazon.smithy.utils.ListUtils;
import software.amazon.smithy.utils.SmithyBuilder;
/**
* Writes out a file that resolves endpoints using endpoints.json, but the
* created resolver resolves endpoints for a single service.
*/
public final class EndpointGenerator implements Runnable {
public static final String MIDDLEWARE_NAME = "ResolveEndpoint";
public static final String ADD_MIDDLEWARE_HELPER_NAME = String.format("add%sMiddleware", MIDDLEWARE_NAME);
public static final String RESOLVER_INTERFACE_NAME = "EndpointResolver";
public static final String RESOLVER_FUNC_NAME = "EndpointResolverFunc";
public static final String RESOLVER_OPTIONS = "EndpointResolverOptions";
public static final String CLIENT_CONFIG_RESOLVER = "resolveDefaultEndpointConfiguration";
public static final String RESOLVER_CONSTRUCTOR_NAME = "NewDefaultEndpointResolver";
public static final String AWS_ENDPOINT_RESOLVER_HELPER = "withEndpointResolver";
public static final String DUAL_STACK_ENDPOINT_OPTION = "UseDualStackEndpoint";
public static final String USE_FIPS_ENDPOINT_OPTION = "UseFIPSEndpoint";
public static final String LOGGER_OPTION = "Logger";
public static final String LOG_DEPRECATED_OPTION = "LogDeprecated";
public static final String RESOLVED_REGION = "ResolvedRegion";
public static final String FINALIZE_CLIENT_ENDPOINT_RESOLVER_OPTIONS = "finalizeClientEndpointResolverOptions";
private static final String EndpointResolverFromURL = "EndpointResolverFromURL";
private static final String ENDPOINT_SOURCE_CUSTOM = "EndpointSourceCustom";
private static final Symbol AWS_ENDPOINT = SymbolUtils.createPointableSymbolBuilder(
"Endpoint", AwsGoDependency.AWS_CORE).build();
private static final int ENDPOINT_MODEL_VERSION = 3;
private static final String INTERNAL_ENDPOINT_PACKAGE = "internal/endpoints";
private static final String INTERNAL_RESOLVER_NAME = "Resolver";
private static final String INTERNAL_RESOLVER_OPTIONS_NAME = "Options";
private static final String INTERNAL_ENDPOINTS_DATA_NAME = "defaultPartitions";
private static final String DISABLE_HTTPS = "DisableHTTPS";
// dual-stack related constants
private static final String DUAL_STACK_ENDPOINT_TYPE_NAME = "DualStackEndpointState";
// fips related constants
private static final String FIPS_ENDPOINT_TYPE_NAME = "FIPSEndpointState";
private static final String TRANSFORM_TO_SHARED_OPTIONS = "transformToSharedOptions";
private static final String AWS_ENDPOINT_RESOLVER_ADAPTOR = "awsEndpointResolverAdaptor";
private static final String DNS_SUFFIX_KEY = "dnsSuffix";
private static final String HOSTNAME_KEY = "hostname";
private static final String VARIANTS_KEY = "variants";
private static final String VARIANT_TAGS_KEY = "tags";
private static final List<EndpointOption> ENDPOINT_OPTIONS = ListUtils.of(
EndpointOption.builder()
.name(LOGGER_OPTION)
.documentation(String.format("%s is a logging implementation that log events should be sent to.",
LOGGER_OPTION))
.type(SymbolUtils.createValueSymbolBuilder("Logger", SmithyGoDependency.SMITHY_LOGGING)
.build())
.shared(true)
.build(),
EndpointOption.builder()
.name(LOG_DEPRECATED_OPTION)
.documentation(String.format("""
%s indicates that deprecated endpoints should be logged to the
provided logger.""", LOG_DEPRECATED_OPTION))
.type(SymbolUtils.createValueSymbolBuilder("bool")
.putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true)
.build())
.shared(true)
.build(),
EndpointOption.builder()
.name(RESOLVED_REGION)
.documentation(String.format("""
%s is used to override the region to be resolved, rather then the
using the value passed to the ResolveEndpoint method. This value is
used by the SDK to translate regions like fips-us-east-1 or
us-east-1-fips to an alternative name. You must not set this value
directly in your application.""", RESOLVED_REGION))
.type(SymbolUtils.createValueSymbolBuilder("string")
.putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true)
.build())
.shared(true)
.withGetter(true)
.build(),
EndpointOption.builder()
.name(DISABLE_HTTPS)
.documentation(String.format("""
%s informs the resolver to return an endpoint that does not use the
HTTPS scheme.
""", DISABLE_HTTPS))
.type(SymbolUtils.createValueSymbolBuilder("bool")
.putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true)
.build())
.shared(true)
.withGetter(true)
.build(),
EndpointOption.builder()
.name(DUAL_STACK_ENDPOINT_OPTION)
.documentation(String.format("""
%s specifies the resolver must resolve a dual-stack endpoint.
""", DUAL_STACK_ENDPOINT_OPTION))
.type(SymbolUtils.createValueSymbolBuilder(DUAL_STACK_ENDPOINT_TYPE_NAME,
AwsGoDependency.AWS_CORE).build())
.shared(true)
.withGetter(true)
.build(),
EndpointOption.builder()
.name(USE_FIPS_ENDPOINT_OPTION)
.documentation(String.format("""
%s specifies the resolver must resolve a FIPS endpoint.
""", USE_FIPS_ENDPOINT_OPTION))
.type(SymbolUtils.createValueSymbolBuilder(FIPS_ENDPOINT_TYPE_NAME,
AwsGoDependency.AWS_CORE).build())
.shared(true)
.withGetter(true)
.build()
);
private final GoSettings settings;
private final Model model;
private final TriConsumer<String, String, Consumer<GoWriter>> writerFactory;
private final ServiceShape serviceShape;
private final ObjectNode endpointData;
private final String endpointPrefix;
private final Map<String, Partition> partitions = new TreeMap<>();
private final boolean isInternalOnly;
private final boolean isGenerateModelQueryHelpers;
private final String resolvedSdkID;
private EndpointGenerator(Builder builder) {
settings = SmithyBuilder.requiredState("settings", builder.settings);
model = SmithyBuilder.requiredState("model", builder.model);
writerFactory = SmithyBuilder.requiredState("writerFactory", builder.writerFactory);
isInternalOnly = builder.internalOnly;
serviceShape = settings.getService(model);
isGenerateModelQueryHelpers = builder.modelQueryHelpers;
ServiceTrait serviceTrait = serviceShape.expectTrait(ServiceTrait.class);
if (builder.sdkID != null) {
resolvedSdkID = builder.sdkID;
} else {
resolvedSdkID = serviceTrait.getSdkId();
}
String arnNamespace;
if (builder.arnNamespace != null) {
arnNamespace = builder.arnNamespace;
} else {
arnNamespace = serviceTrait.getArnNamespace();
}
String endpointPrefix;
if (builder.endpointPrefix != null) {
endpointPrefix = builder.endpointPrefix;
} else {
endpointPrefix = serviceTrait.getEndpointPrefix();
}
if (endpointPrefix.length() == 0) {
endpointPrefix = arnNamespace;
}
this.endpointPrefix = endpointPrefix;
endpointData = Node.parse(IoUtils.readUtf8Resource(getClass(), "endpoints.json")).expectObjectNode();
validateVersion();
loadPartitions();
}
private void validateVersion() {
int version = endpointData.expectNumberMember("version").getValue().intValue();
if (version != ENDPOINT_MODEL_VERSION) {
throw new CodegenException("Invalid endpoints.json version. Expected version 3, found " + version);
}
}
private String getEndpointPrefix(String sdkId, String arnNamespace) {
ObjectNode endpointPrefixData = Node.parse(IoUtils.readUtf8Resource(getClass(), "endpoint-prefix.json"))
.expectObjectNode();
return endpointPrefixData.getStringMemberOrDefault(sdkId, arnNamespace);
}
private void loadPartitions() {
List<ObjectNode> partitionObjects = endpointData
.expectArrayMember("partitions")
.getElementsAs(Node::expectObjectNode);
for (ObjectNode partition : partitionObjects) {
String partitionName = partition.expectStringMember("partition").getValue();
partitions.put(partitionName, new Partition(partition, partitionName));
}
}
@Override
public void run() {
if (!this.isInternalOnly) {
writerFactory.accept("endpoints.go", settings.getModuleName(), writer -> {
generatePublicResolverTypes(writer);
generateMiddleware(writer);
generateAwsEndpointResolverWrapper(writer);
generateFinalizeClientEndpointResolverOptions(writer);
});
}
String pkgName = isInternalOnly ? INTERNAL_ENDPOINT_PACKAGE + "/" + this.endpointPrefix : INTERNAL_ENDPOINT_PACKAGE;
writerFactory.accept(pkgName + "/endpoints.go", getInternalEndpointImportPath(), (writer) -> {
generateInternalResolverImplementation(writer);
generateInternalEndpointsModel(writer);
if (isGenerateModelQueryHelpers) {
generateInternalModelHelpers(writer);
}
});
if (!this.isInternalOnly) {
writerFactory.accept(INTERNAL_ENDPOINT_PACKAGE + "/endpoints_test.go",
getInternalEndpointImportPath(), (writer) -> {
writer.addUseImports(SmithyGoDependency.TESTING);
writer.openBlock("func TestRegexCompile(t *testing.T) {", "}", () -> {
writer.write("_ = $T",
getInternalEndpointsSymbol(INTERNAL_ENDPOINTS_DATA_NAME, false).build());
});
});
}
}
private void generateFinalizeClientEndpointResolverOptions(GoWriter writer) {
writer.pushState();
writer.putContext("logDepOption", LOG_DEPRECATED_OPTION);
writer.putContext("dualStackOption", DUAL_STACK_ENDPOINT_OPTION);
writer.putContext("fipsOption", USE_FIPS_ENDPOINT_OPTION);
writer.putContext("unsetDualStack", DualStackEndpointConstant.UNSET.getSymbol());
writer.putContext("enableDualStack", DualStackEndpointConstant.ENABLE.getSymbol());
writer.putContext("disableDualStack", DualStackEndpointConstant.DISABLE.getSymbol());
writer.putContext("enableFIPS", FIPSEndpointConstant.ENABLE.getSymbol());
writer.putContext("contains", SymbolUtils.createValueSymbolBuilder("Contains",
SmithyGoDependency.STRINGS).build());
writer.putContext("replaceALL", SymbolUtils.createValueSymbolBuilder("ReplaceAll",
SmithyGoDependency.STRINGS).build());
writer.openBlock("func $L(options *Options) {", "}",
FINALIZE_CLIENT_ENDPOINT_RESOLVER_OPTIONS, () -> {
writer.write("""
options.EndpointOptions.$logDepOption:L = options.ClientLogMode.IsDeprecatedUsage()
if len(options.EndpointOptions.ResolvedRegion) == 0 {
const fipsInfix = "-fips-"
const fipsPrefix = "fips-"
const fipsSuffix = "-fips"
if ($contains:T(options.Region, fipsInfix) ||
$contains:T(options.Region, fipsPrefix) ||
$contains:T(options.Region, fipsSuffix)) {
options.EndpointOptions.ResolvedRegion = $replaceALL:T($replaceALL:T($replaceALL:T(
options.Region, fipsInfix, "-"), fipsPrefix, ""), fipsSuffix, "")
options.EndpointOptions.$fipsOption:L = $enableFIPS:T
}
}
""");
if (S3ModelUtils.isServiceS3(model, serviceShape)
|| S3ModelUtils.isServiceS3Control(model, serviceShape)) {
writer.write("""
if options.EndpointOptions.$dualStackOption:L == $unsetDualStack:T {
if options.UseDualstack {
options.EndpointOptions.$dualStackOption:L = $enableDualStack:T
} else {
options.EndpointOptions.$dualStackOption:L = $disableDualStack:T
}
}
""");
}
}).write("");
writer.popState();
}
private void generateInternalModelHelpers(GoWriter writer) {
generateDNSSuffixFunction(writer);
}
private void generateDNSSuffixFunction(GoWriter writer) {
Symbol optionsSymbol = getInternalEndpointsSymbol(INTERNAL_RESOLVER_OPTIONS_NAME, false).build();
writer.addUseImports(SmithyGoDependency.FMT);
writer.writeDocs("GetDNSSuffix returns the dnsSuffix URL component for the given partition id");
writer.openBlock("func GetDNSSuffix(id string, options $T) (string, error) {", "}", optionsSymbol, () -> {
Symbol equalFold = SymbolUtils.createValueSymbolBuilder("EqualFold", SmithyGoDependency.STRINGS)
.build();
writer.write("variant := $L(options).GetEndpointVariant()", TRANSFORM_TO_SHARED_OPTIONS);
writer.openBlock("switch {", "}", () -> {
partitions.forEach((s, partition) -> {
writer.openBlock("case $T(id, $S):", "", equalFold, partition.id, () -> {
writer.openBlock("switch variant {", "}", () -> {
partition.getDefaults().forEach((variant, objectNode) -> {
writer.writeInline("case ");
variant.writeVariantInline(writer);
writer.openBlock(":", "", () -> writer
.write("return $S, nil", objectNode.expectStringMember(DNS_SUFFIX_KEY)));
});
writer.write("""
default:
return "", $T("unsupported endpoint variant %v, in partition %s", variant, id)
""", SymbolUtils.createValueSymbolBuilder("Errorf",
SmithyGoDependency.FMT).build());
});
});
});
writer.openBlock("default:", "", () -> writer.write("return \"\", fmt.Errorf(\"unknown partition\")"));
});
}).write("");
writer.writeDocs("GetDNSSuffixFromRegion returns the DNS suffix for the provided region and options.");
writer.openBlock("func GetDNSSuffixFromRegion(region string, options $T) (string, error) {", "}", optionsSymbol,
() -> {
List<Partition> sortedPartitions = getSortedPartitions();
writer.openBlock("switch {", "}", () -> {
sortedPartitions.forEach(partition -> {
writer.write("""
case partitionRegexp.$L.MatchString(region):
return GetDNSSuffix($S, options)
""", getPartitionIDFieldName(partition.getId()), partition.getId());
});
writer.write("""
default:
return GetDNSSuffix("aws", options)
""");
});
}).write("");
}
private void generateAwsEndpointResolverWrapper(GoWriter writer) {
var endpointResolver = SymbolUtils.createValueSymbolBuilder("EndpointResolver", AwsGoDependency.AWS_CORE)
.build();
var endpointResolverWithOptions = SymbolUtils.createValueSymbolBuilder("EndpointResolverWithOptions", AwsGoDependency.AWS_CORE)
.build();
var resolverInterface = SymbolUtils.createValueSymbolBuilder(RESOLVER_INTERFACE_NAME).build();
var wrappedResolverSymbol = SymbolUtils.createPointableSymbolBuilder("wrappedEndpointResolver").build();
writer.write("""
type $T struct {
awsResolver $T
}
""", wrappedResolverSymbol, endpointResolverWithOptions);
var endpointNotFoundError = SymbolUtils.createValueSymbolBuilder("EndpointNotFoundError",
AwsGoDependency.AWS_CORE).build();
writeExternalResolveEndpointImplementation(writer, wrappedResolverSymbol, "w", () -> {
writer.write("return w.awsResolver.ResolveEndpoint(ServiceID, region, options)");
writer.addUseImports(SmithyGoDependency.ERRORS);
});
var endpoint = SymbolUtils.createValueSymbolBuilder("Endpoint",
AwsGoDependency.AWS_CORE).build();
writer.write("""
type $L func(service, region string) ($T, error)
func (a $L) ResolveEndpoint(service, region string, options ...interface{}) ($T, error) {
return a(service, region)
}
var _ $T = $L(nil)
""", AWS_ENDPOINT_RESOLVER_ADAPTOR, endpoint, AWS_ENDPOINT_RESOLVER_ADAPTOR,
endpoint, endpointResolverWithOptions, AWS_ENDPOINT_RESOLVER_ADAPTOR);
// Generate exported helper for constructing a wrapper around the AWS EndpointResolver type that is compatible
// with the clients EndpointResolver interface.
writer.write("""
// $1L returns an $3T that first delegates endpoint resolution to the awsResolver.
// If awsResolver returns $7T error, the v1 resolver middleware will swallow the error,
// and set an appropriate context flag such that fallback will occur when $8L is invoked
// via its middleware.
//
// If another error (besides $7T) is returned, then that error will be propagated.
func $1L(awsResolver $2T, awsResolverWithOptions $3T) $6L {
var resolver $3T
if awsResolverWithOptions != nil {
resolver = awsResolverWithOptions
} else if awsResolver != nil {
resolver = $4L(awsResolver.ResolveEndpoint)
}
return &$5T{
awsResolver: resolver,
}
}
""", AWS_ENDPOINT_RESOLVER_HELPER,
endpointResolver, endpointResolverWithOptions,
AWS_ENDPOINT_RESOLVER_ADAPTOR, wrappedResolverSymbol,
resolverInterface, endpointNotFoundError,
EndpointResolutionGenerator.RESOLVER_INTERFACE_NAME
);
}
private void generateMiddleware(GoWriter writer) {
// Generate middleware definition
GoStackStepMiddlewareGenerator middleware = GoStackStepMiddlewareGenerator.createSerializeStepMiddleware(
MIDDLEWARE_NAME, MiddlewareIdentifier.string(MIDDLEWARE_NAME));
middleware.writeMiddleware(writer, this::generateMiddlewareResolverBody,
this::generateMiddlewareStructureMembers);
Symbol stackSymbol = SymbolUtils.createPointableSymbolBuilder("Stack", SmithyGoDependency.SMITHY_MIDDLEWARE)
.build();
// Generate Middleware Adder Helper
writer.openBlock("func $L(stack $P, o Options) error {", "}", ADD_MIDDLEWARE_HELPER_NAME, stackSymbol, () -> {
writer.addUseImports(SmithyGoDependency.SMITHY_MIDDLEWARE);
String closeBlock = String.format("}, \"%s\", middleware.Before)",
ProtocolUtils.OPERATION_SERIALIZER_MIDDLEWARE_ID);
writer.openBlock("return stack.Serialize.Insert(&$T{", closeBlock,
middleware.getMiddlewareSymbol(),
() -> {
writer.write("Resolver: o.EndpointResolver,");
writer.write("Options: o.EndpointOptions,");
});
});
writer.write("");
// Generate Middleware Remover Helper
writer.openBlock("func remove$LMiddleware(stack $P) error {", "}", middleware.getMiddlewareSymbol(),
stackSymbol, () -> {
writer.write("_, err := stack.Serialize.Remove((&$T{}).ID())", middleware.getMiddlewareSymbol());
writer.write("return err");
});
}
private void generateMiddlewareResolverBody(GoStackStepMiddlewareGenerator g, GoWriter w) {
w.addUseImports(SmithyGoDependency.FMT);
w.addUseImports(SmithyGoDependency.NET_URL);
w.addUseImports(AwsGoDependency.AWS_MIDDLEWARE);
w.addUseImports(SmithyGoDependency.SMITHY_MIDDLEWARE);
w.addUseImports(SmithyGoDependency.SMITHY_HTTP_TRANSPORT);
w.write(
"""
if !$T(ctx) {
return next.HandleSerialize(ctx, in)
}
""",
SymbolUtils.createValueSymbolBuilder("GetRequiresLegacyEndpoints", AwsGoDependency.AWS_MIDDLEWARE).build()
);
w.write("req, ok := in.Request.(*smithyhttp.Request)");
w.openBlock("if !ok {", "}", () -> {
w.write("return out, metadata, fmt.Errorf(\"unknown transport type %T\", in.Request)");
});
w.write("");
w.openBlock("if m.Resolver == nil {", "}", () -> {
w.write("return out, metadata, fmt.Errorf(\"expected endpoint resolver to not be nil\")");
});
w.write("");
w.write("""
eo := m.Options
eo.$L = $T(ctx)
""", LOGGER_OPTION, SymbolUtils.createValueSymbolBuilder("GetLogger",
SmithyGoDependency.SMITHY_MIDDLEWARE).build());
w.write("var endpoint $T", SymbolUtils.createValueSymbolBuilder("Endpoint", AwsGoDependency.AWS_CORE)
.build());
w.write("endpoint, err = m.Resolver.ResolveEndpoint(awsmiddleware.GetRegion(ctx), eo)");
w.write(
"""
if err != nil {
nf := (&$1T{})
if $2T(err, &nf) {
ctx = $3T(ctx, false)
return next.HandleSerialize(ctx, in)
}
return out, metadata, $4T(\"failed to resolve service endpoint, %w\", err)
}
""",
SymbolUtils.createValueSymbolBuilder("EndpointNotFoundError", AwsGoDependency.AWS_CORE).build(),
SymbolUtils.createValueSymbolBuilder("As", SmithyGoDependency.ERRORS).build(),
SymbolUtils.createValueSymbolBuilder("SetRequiresLegacyEndpoints", AwsGoDependency.AWS_MIDDLEWARE).build(),
SymbolUtils.createValueSymbolBuilder("Errorf", SmithyGoDependency.FMT).build()
);
w.write("");
w.write("req.URL, err = url.Parse(endpoint.URL)");
w.openBlock("if err != nil {", "}", () -> {
w.write("return out, metadata, fmt.Errorf(\"failed to parse endpoint URL: %w\", err)");
});
w.write("");
w.openBlock("if len(awsmiddleware.GetSigningName(ctx)) == 0 {", "}", () -> {
w.write("signingName := endpoint.SigningName");
w.openBlock("if len(signingName) == 0 {", "}", () -> {
w.write("signingName = $S", serviceShape.expectTrait(ServiceTrait.class).getArnNamespace());
});
w.write("ctx = awsmiddleware.SetSigningName(ctx, signingName)");
});
// set endoint source on context
w.write("ctx = awsmiddleware.SetEndpointSource(ctx, endpoint.Source)");
// set host-name immutable on context
w.write("ctx = smithyhttp.SetHostnameImmutable(ctx, endpoint.HostnameImmutable)");
// set signing region on context
w.write("ctx = awsmiddleware.SetSigningRegion(ctx, endpoint.SigningRegion)");
// set partition id on context
w.write("ctx = awsmiddleware.SetPartitionID(ctx, endpoint.PartitionID)");
w.insertTrailingNewline();
w.write("return next.HandleSerialize(ctx, in)");
}
private void generateMiddlewareStructureMembers(GoStackStepMiddlewareGenerator g, GoWriter w) {
w.write("Resolver $L", RESOLVER_INTERFACE_NAME);
w.write("Options $L", RESOLVER_OPTIONS);
}
private Symbol.Builder getInternalEndpointsSymbol(String symbolName, boolean pointable) {
Symbol.Builder builder;
if (pointable) {
builder = SymbolUtils.createPointableSymbolBuilder(symbolName);
} else {
builder = SymbolUtils.createValueSymbolBuilder(symbolName);
}
return builder.namespace(getInternalEndpointImportPath(), "/")
.putProperty(SymbolUtils.NAMESPACE_ALIAS, "internalendpoints");
}
private String getInternalEndpointImportPath() {
return settings.getModuleName() + "/" + INTERNAL_ENDPOINT_PACKAGE;
}
private void generatePublicResolverTypes(GoWriter writer) {
Symbol awsEndpointSymbol = SymbolUtils.createValueSymbolBuilder("Endpoint", AwsGoDependency.AWS_CORE).build();
Symbol internalEndpointsSymbol = getInternalEndpointsSymbol(INTERNAL_RESOLVER_NAME, true).build();
Symbol resolverOptionsSymbol = SymbolUtils.createPointableSymbolBuilder(RESOLVER_OPTIONS).build();
writer.writeDocs(String.format("%s is the service endpoint resolver options",
resolverOptionsSymbol.getName()));
writer.write("type $T = $T", resolverOptionsSymbol, getInternalEndpointsSymbol(INTERNAL_RESOLVER_OPTIONS_NAME,
false).build());
writer.write("");
// Generate Resolver Interface
writer.writeDocs(String.format("%s interface for resolving service endpoints.", RESOLVER_INTERFACE_NAME));
writer.openBlock("type $L interface {", "}", RESOLVER_INTERFACE_NAME, () -> {
writer.write("ResolveEndpoint(region string, options $T) ($T, error)", resolverOptionsSymbol,
awsEndpointSymbol);
});
writer.write("var _ $L = &$T{}", RESOLVER_INTERFACE_NAME, internalEndpointsSymbol);
writer.write("");
// Resolver Constructor
writer.writeDocs(String.format("%s constructs a new service endpoint resolver", RESOLVER_CONSTRUCTOR_NAME));
writer.openBlock("func $L() $P {", "}", RESOLVER_CONSTRUCTOR_NAME, internalEndpointsSymbol, () -> {
writer.write("return $T()", getInternalEndpointsSymbol("New", false)
.build());
});
Symbol resolverFuncSymbol = SymbolUtils.createValueSymbolBuilder(RESOLVER_FUNC_NAME).build();
// Generate resolver function creator
writer.writeDocs(String.format("%s is a helper utility that wraps a function so it satisfies the %s "
+ "interface. This is useful when you want to add additional endpoint resolving logic, or stub out "
+ "specific endpoints with custom values.", RESOLVER_FUNC_NAME, RESOLVER_INTERFACE_NAME));
writer.write("type $T func(region string, options $T) ($T, error)",
resolverFuncSymbol, resolverOptionsSymbol, awsEndpointSymbol);
writeExternalResolveEndpointImplementation(writer, resolverFuncSymbol, "fn", () -> {
writer.write("return fn(region, options)");
});
// Generate EndpointResolverFromURL helper
writer.writeDocs(String.format("%s returns an EndpointResolver configured using the provided endpoint url. "
+ "By default, the resolved endpoint resolver uses the client region as signing region, and "
+ "the endpoint source is set to EndpointSourceCustom."
+ "You can provide functional options to configure endpoint values for the resolved endpoint.",
EndpointResolverFromURL));
writer.openBlock("func $L(url string, optFns ...func($P)) EndpointResolver {", "}",
EndpointResolverFromURL, AWS_ENDPOINT, () -> {
Symbol customEndpointSource = SymbolUtils.createValueSymbolBuilder(
ENDPOINT_SOURCE_CUSTOM, AwsGoDependency.AWS_CORE
).build();
writer.write("e := $T{ URL : url, Source : $T }", AWS_ENDPOINT, customEndpointSource);
writer.write("for _, fn := range optFns { fn(&e) }");
writer.write("");
writer.openBlock("return $T(", ")", resolverFuncSymbol, () -> {
writer.write("func(region string, options $L) ($T, error) {", RESOLVER_OPTIONS, AWS_ENDPOINT);
writer.write("if len(e.SigningRegion) == 0 { e.SigningRegion = region }");
writer.write("return e, nil },");
});
});
}
private void writeExternalResolveEndpointImplementation(
GoWriter writer,
Symbol receiverType,
String receiverIdentifier,
Runnable body
) {
Symbol resolverOptionsSymbol = SymbolUtils.createPointableSymbolBuilder(RESOLVER_OPTIONS).build();
writeResolveEndpointImplementation(writer, receiverType, receiverIdentifier, resolverOptionsSymbol,
body);
}
private void writeInternalResolveEndpointImplementation(
GoWriter writer,
Symbol receiverType,
String receiverIdentifier,
Runnable body
) {
Symbol resolverOptionsSymbol = SymbolUtils.createPointableSymbolBuilder(INTERNAL_RESOLVER_OPTIONS_NAME).build();
writeResolveEndpointImplementation(writer, receiverType, receiverIdentifier, resolverOptionsSymbol,
body);
}
/**
* Writes the ResolveEndpoint function signature to satisfy the EndpointResolver interface.
*
* @param writer the code writer
* @param receiverType the receiver symbol type should be can be value or pointer
* @param receiverIdentifier the identifier to use for the receiver
* @param resolverOptionsSymbol the symbol for the options
* @param body a runnable that will populate the function implementation.
*/
private void writeResolveEndpointImplementation(
GoWriter writer,
Symbol receiverType,
String receiverIdentifier,
Symbol resolverOptionsSymbol,
Runnable body
) {
Symbol awsEndpointSymbol = SymbolUtils.createValueSymbolBuilder("Endpoint", AwsGoDependency.AWS_CORE).build();
writer.openBlock("func ($L $P) ResolveEndpoint(region string, options $T) (endpoint $T, err error) {", "}",
receiverIdentifier, receiverType, resolverOptionsSymbol, awsEndpointSymbol, body::run)
.write("");
}
private void generateInternalResolverImplementation(GoWriter writer) {
// Options
Symbol resolverOptionsSymbol = SymbolUtils.createPointableSymbolBuilder(INTERNAL_RESOLVER_OPTIONS_NAME).build();
writer.writeDocs(String.format("%s is the endpoint resolver configuration options",
resolverOptionsSymbol.getName()));
writer.openBlock("type $T struct {", "}", resolverOptionsSymbol, () -> {
ENDPOINT_OPTIONS.forEach(field -> {
field.getDocumentation().ifPresent(s -> {
if (s.length() == 0) {
return;
}
writer.writeDocs(s);
});
writer.write("$L $P", field.getName(), field.getType()).write("");
});
});
writer.write("");
ENDPOINT_OPTIONS.forEach(endpointOption -> {
if (!endpointOption.withGetter) {
return;
}
writer.write("""
func (o $T) Get$L() $P {
return o.$L
}
""", resolverOptionsSymbol, endpointOption.getName(), endpointOption.getType(),
endpointOption.getName());
});
Symbol sharedOptions = SymbolUtils.createPointableSymbolBuilder("Options",
AwsGoDependency.INTERNAL_ENDPOINTS_V2).build();
writer.openBlock("func $L(options $T) $T {", "}", TRANSFORM_TO_SHARED_OPTIONS,
SymbolUtils.createValueSymbolBuilder(INTERNAL_RESOLVER_OPTIONS_NAME).build(), sharedOptions,
() -> writer
.openBlock("return $T{", "}", sharedOptions, () -> {
ENDPOINT_OPTIONS.stream().filter(EndpointOption::isShared).forEach(field -> {
String internalName = field.getSharedOptionName().orElse(field.getName());
Optional<Symbol> resolver = field.getSharedResolver();
if (resolver.isPresent()) {
writer.write("$L: $T(options.$L),", internalName, resolver.get(),
field.getName());
} else {
writer.write("$L: options.$L,", internalName, field.getName());
}
});
}));
// Resolver
Symbol resolverImplSymbol = SymbolUtils.createPointableSymbolBuilder(INTERNAL_RESOLVER_NAME).build();
writer.writeDocs(String.format("%s %s endpoint resolver", resolverImplSymbol.getName(),
this.resolvedSdkID));
writer.openBlock("type $T struct {", "}", resolverImplSymbol, () -> {
writer.write("partitions $T", SymbolUtils.createValueSymbolBuilder("Partitions",
AwsGoDependency.INTERNAL_ENDPOINTS_V2).build());
});
writer.write("");
writer.writeDocs("ResolveEndpoint resolves the service endpoint for the given region and options");
writeInternalResolveEndpointImplementation(writer, resolverImplSymbol, "r", () -> {
// Currently, all APIs require a region to derive the endpoint for that API. If there are ever a truly
// region-less API then this should be gated at codegen.
writer.addUseImports(AwsGoDependency.AWS_CORE);
writer.write("if len(region) == 0 { return endpoint, &aws.MissingRegionError{} }").write("")
.write("opt := $L(options)", TRANSFORM_TO_SHARED_OPTIONS)
.write("return r.partitions.ResolveEndpoint(region, opt)");
});
writer.write("");
writer.writeDocs(String.format("New returns a new %s", resolverImplSymbol.getName()));
writer.openBlock("func New() *$T {", "}", resolverImplSymbol, () -> writer.openBlock("return &$T{", "}",
resolverImplSymbol, () -> {
writer.write("partitions: $L,", INTERNAL_ENDPOINTS_DATA_NAME);
}));
}
private static String getPartitionIDFieldName(String id) {
StringBuilder builder = new StringBuilder();
char[] charArray = id.toCharArray();
boolean capitalize = true;
for (int i = 0; i < charArray.length; i++) {
if (!Character.isAlphabetic(charArray[i])) {
capitalize = true;
continue;
}
if (capitalize) {
builder.append(Character.toUpperCase(charArray[i]));
capitalize = false;
} else {
builder.append(Character.toLowerCase(charArray[i]));
}
}
return builder.toString();
}
private void generateInternalEndpointsModel(GoWriter writer) {
writer.addUseImports(AwsGoDependency.INTERNAL_ENDPOINTS_V2);
List<Partition> sortedPartitions = getSortedPartitions();
writer.openBlock("var partitionRegexp = struct{", "}{", () -> {
sortedPartitions.forEach(partition -> {
writer.write("$L $P", getPartitionIDFieldName(partition.getId()),
SymbolUtils.createPointableSymbolBuilder("Regexp", AwsGoDependency.REGEXP).build());
});
}).openBlock("", "}", () -> {
sortedPartitions.forEach(partition -> {
writer.write("$L: regexp.MustCompile($S),", getPartitionIDFieldName(partition.getId()),
partition.getConfig().expectStringMember("regionRegex").getValue());
});
});
writer.write("");
Symbol partitionsSymbol = SymbolUtils.createPointableSymbolBuilder("Partitions",
AwsGoDependency.INTERNAL_ENDPOINTS_V2).build();
writer.openBlock("var $L = $T{", "}", INTERNAL_ENDPOINTS_DATA_NAME, partitionsSymbol, () -> {
sortedPartitions.forEach(entry -> {
writer.openBlock("{", "},", () -> writePartition(writer, entry));
});
});
}
private List<Partition> getSortedPartitions() {
return partitions.entrySet().stream()
.sorted((x, y) -> {
// Always sort standard aws partition first
if (x.getKey().equals("aws")) {
return -1;
}
return x.getKey().compareTo(y.getKey());
}).map(Map.Entry::getValue).collect(Collectors.toList());
}
private void writePartition(GoWriter writer, Partition partition) {
writer.write("ID: $S,", partition.getId());
var defaultKey = SymbolUtils.createValueSymbolBuilder("DefaultKey",
AwsGoDependency.INTERNAL_ENDPOINTS_V2).build();
var endpointSymbol = SymbolUtils.createValueSymbolBuilder("Endpoint",
AwsGoDependency.INTERNAL_ENDPOINTS_V2).build();
writer.openBlock("Defaults: map[$T]$P{", "},", defaultKey, endpointSymbol,
() -> partition.getDefaults().forEach((variant, objectNode) -> {
writer.writeInline("""
$T{
Variant:""", defaultKey);
variant.writeVariantInline(writer);
writer.writeInline(",\n}:");
writer.openBlock("{", "},",
() -> writeEndpoint(writer, objectNode));
}));
writer.addUseImports(AwsGoDependency.REGEXP);
writer.write("RegionRegex: partitionRegexp.$L,", getPartitionIDFieldName(partition.getId()));
var optionalPartitionEndpoint = partition.getPartitionEndpoint();
var isRegionalizedValue = SymbolUtils.createValueSymbolBuilder(optionalPartitionEndpoint.isPresent()
? "false" : "true").build();
writer.write("IsRegionalized: $T,", isRegionalizedValue);
optionalPartitionEndpoint.ifPresent(s -> writer.write("PartitionEndpoint: $S,", s));
var endpoints = partition.getEndpoints().getMembers();
if (endpoints.size() > 0) {
var endpointKey = SymbolUtils.createPointableSymbolBuilder("EndpointKey",
AwsGoDependency.INTERNAL_ENDPOINTS_V2)
.build();
var endpointsSymbol = SymbolUtils.createPointableSymbolBuilder("Endpoints",
AwsGoDependency.INTERNAL_ENDPOINTS_V2)
.build();
writer.openBlock("Endpoints: $T{", "},", endpointsSymbol, () -> {
endpoints.forEach((region, en) -> {
var endpointNode = en.expectObjectNode();
writer.openBlock("""
$T{
Region: $S,
}: $T{""", "},", endpointKey, region,
endpointSymbol, () -> writeEndpoint(writer, endpointNode));
endpointNode.getArrayMember(VARIANTS_KEY).orElse(ArrayNode.fromNodes()).forEach(vn -> {
writer.writeInline("""
$T{
Region: $S,
Variant:""", endpointKey, region);
var variantNode = vn.expectObjectNode();
Variant.fromArrayNode(variantNode.expectArrayMember(VARIANT_TAGS_KEY))
.writeVariantInline(writer);
writer.openBlock(",\n}: {", "},",
() -> writeEndpoint(writer, mergeVariantDefinition(endpointNode, variantNode)));
});
});
});
}
}
private ObjectNode mergeVariantDefinition(ObjectNode endpointNode, ObjectNode variantNode) {
return endpointNode
.withoutMember(HOSTNAME_KEY)
.withoutMember(DNS_SUFFIX_KEY)
.merge(variantNode);
}
private void writeEndpoint(GoWriter writer, ObjectNode node) {
node.getStringMember(HOSTNAME_KEY).ifPresent(n -> {
writer.write("Hostname: $S,", n.getValue());
});
node.getArrayMember("protocols").ifPresent(nodes -> {
writer.writeInline("Protocols: []string{");
nodes.forEach(n -> {
writer.writeInline("$S, ", n.expectStringNode().getValue());
});
writer.write("},");
});
node.getArrayMember("signatureVersions").ifPresent(nodes -> {
writer.writeInline("SignatureVersions: []string{");
nodes.forEach(n -> writer.writeInline("$S, ", n.expectStringNode().getValue()));
writer.write("},");
});
node.getMember("credentialScope").ifPresent(n -> {
ObjectNode credentialScope = n.expectObjectNode();
Symbol credentialScopeSymbol = SymbolUtils.createValueSymbolBuilder("CredentialScope",
AwsGoDependency.INTERNAL_ENDPOINTS_V2)
.build();
writer.openBlock("CredentialScope: $T{", "},", credentialScopeSymbol, () -> {
credentialScope.getStringMember("region").ifPresent(nn -> {
writer.write("Region: $S,", nn.getValue());
});
credentialScope.getStringMember("service").ifPresent(nn -> {
writer.write("Service: $S,", nn.getValue());
});
});
});
node.getBooleanMember("deprecated").ifPresent(booleanNode -> {
if (booleanNode.getValue()) {
writer.write("Deprecated: $T,", SymbolUtils.createValueSymbolBuilder("TrueTernary",
AwsGoDependency.AWS_CORE).build());
}
});
}
private static class EndpointOption extends ConfigField {
private final boolean shared;
private final String sharedOptionName;
private final Symbol sharedResolver;
private final boolean withGetter;
public EndpointOption(Builder builder) {
super(builder);
this.shared = builder.shared;
this.sharedOptionName = builder.sharedOptionName;
this.sharedResolver = builder.sharedResolver;
this.withGetter = builder.withGetter;
}
public static Builder builder() {
return new Builder();
}
public boolean isShared() {
return shared;
}
public Optional<String> getSharedOptionName() {
return Optional.ofNullable(sharedOptionName);
}
public Optional<Symbol> getSharedResolver() {
return Optional.ofNullable(this.sharedResolver);
}
public boolean isWithGetter() {
return withGetter;
}
private static class Builder extends ConfigField.Builder {
private boolean shared;
private String sharedOptionName;
private Symbol sharedResolver;
private boolean withGetter;
public Builder() {
super();
}
/**
* Set the resolver config field to be shared common parameter
*
* @param shared whether the resolver config field is shared
* @return the builder
*/
public Builder shared(boolean shared) {
this.shared = shared;
return this;
}
public Builder sharedOptionName(String sharedOptionName) {
this.sharedOptionName = sharedOptionName;
return this;
}
public Builder sharedResolver(Symbol sharedResolver) {
this.sharedResolver = sharedResolver;
return this;
}
public Builder withGetter(boolean withGetter) {
this.withGetter = withGetter;
return this;
}
@Override
public EndpointOption build() {
return new EndpointOption(this);
}
@Override
public Builder name(String name) {
super.name(name);
return this;
}
@Override
public Builder type(Symbol type) {
super.type(type);
return this;
}
@Override
public Builder documentation(String documentation) {
super.documentation(documentation);
return this;
}
}
}
private static final class Variant {
private final boolean fips;
private final boolean dualstack;
private final Set<String> unknown;
private Variant(Builder builder) {
this.fips = builder.fips;
this.dualstack = builder.dualstack;
this.unknown = builder.unknown;
}
public boolean isFips() {
return fips;
}
public boolean isDualstack() {
return dualstack;
}
public Set<String> getUnknown() {
return unknown;
}
public void writeVariantInline(GoWriter writer) {
if (getUnknown().size() > 0) {
throw new CodegenException("unable to represent variant with unknown tags");
}
var symbols = new ArrayList<>();
if (fips) {
symbols.add(SymbolUtils.createValueSymbolBuilder("FIPSVariant",
AwsGoDependency.INTERNAL_ENDPOINTS_V2)
.build());
}
if (dualstack) {
symbols.add(SymbolUtils.createValueSymbolBuilder("DualStackVariant",
AwsGoDependency.INTERNAL_ENDPOINTS_V2)
.build());
}
if (symbols.size() > 0) {
for (int i = 0; i < symbols.size(); i++) {
if (i != 0) {
writer.writeInline("|");
}
writer.writeInline("$T", symbols.get(i));
}
} else {
writer.writeInline("0");
}
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Variant that = (Variant) o;
return isFips() == that.isFips() && isDualstack() == that.isDualstack()
&& getUnknown().equals(that.getUnknown());
}
@Override
public int hashCode() {
return Objects.hash(isFips(), isDualstack(), getUnknown());
}
public static Builder builder() {
return new Builder();
}
public static Variant fromArrayNode(ArrayNode arrayNode) {
if (arrayNode.size() == 0) {
throw new CodegenException("expect one or more variant tags");
}
var builder = builder();
arrayNode.getElements().forEach(node -> {
var value = node.expectStringNode().getValue();
if (value.equalsIgnoreCase("fips")) {
builder.fips(true);
} else if (value.equalsIgnoreCase("dualstack")) {
builder.dualstack(true);
} else {
builder.addUnknownTag(value);
}
});
return builder.build();
}
static class Builder implements SmithyBuilder<Variant> {
private boolean fips;
private boolean dualstack;
private Set<String> unknown = new HashSet<>();
public Builder fips(boolean fips) {
this.fips = fips;
return this;
}
public Builder dualstack(boolean dualstack) {
this.dualstack = dualstack;
return this;
}
public Builder addUnknownTag(String tag) {
this.unknown.add(tag);
return this;
}
@Override
public Variant build() {
return new Variant(this);
}
}
}
private final class Partition {
private static final String DEFAULTS_KEY = "defaults";
private final String id;
private final ObjectNode config;
private final Map<Variant, ObjectNode> defaults = new HashMap<>();
private Partition(ObjectNode config, String partition) {
id = partition;
this.config = config;
// Resolve the partition defaults + the service defaults.
ObjectNode service = getService();
// Merge service defaults onto partition defaults ignoring variants key
ObjectNode serviceDefaults = config.expectObjectMember(DEFAULTS_KEY)
.withoutMember(VARIANTS_KEY)
.merge(service
.getObjectMember(DEFAULTS_KEY)
.orElse(Node.objectNode())
.withMember(DNS_SUFFIX_KEY, config.expectStringMember(DNS_SUFFIX_KEY))
.withoutMember(VARIANTS_KEY));
Stream.concat(
getVariants(config.expectObjectMember(DEFAULTS_KEY), serviceDefaults).stream(),
getVariants(service.getObjectMember(DEFAULTS_KEY).orElse(Node.objectNode()),
serviceDefaults).stream()
)
.collect(Collectors.toMap(
objectNode -> Variant.fromArrayNode(objectNode.expectArrayMember("tags")),
Function.identity(), ObjectNode::merge))
.entrySet()
.stream()
.filter(entry -> entry.getKey().getUnknown().size() == 0)
.forEach(entry -> defaults.put(entry.getKey(), entry.getValue()));
for (Map.Entry<Variant, ObjectNode> variantObjectNodeEntry : defaults.entrySet()) {
var objectNode = variantObjectNodeEntry.getValue();
objectNode = objectNode.withMember(HOSTNAME_KEY, templateHostname(
objectNode.expectStringMember(HOSTNAME_KEY)
.getValue(),
endpointPrefix,
objectNode.expectStringMember(DNS_SUFFIX_KEY)
.getValue()));
variantObjectNodeEntry.setValue(objectNode);
}
serviceDefaults = serviceDefaults.withMember(HOSTNAME_KEY, templateHostname(
serviceDefaults.expectStringMember(HOSTNAME_KEY).getValue(),
endpointPrefix,
serviceDefaults.expectStringMember(DNS_SUFFIX_KEY).getValue()));
// the default configuration aka no tag variant
defaults.put(Variant.builder().build(), serviceDefaults);
}
private Set<ObjectNode> getVariants(ObjectNode objectNode, ObjectNode defaults) {
return objectNode.getArrayMember(VARIANTS_KEY)
.orElse(ArrayNode.fromNodes())
.getElements()
.stream()
.map(node -> mergeVariantDefinition(defaults, node.expectObjectNode()))
.collect(Collectors.toSet());
}
private String templateHostname(String hostname, String service, String dnsSuffix) {
return hostname
.replace("{service}", service)
.replace("{dnsSuffix}", dnsSuffix);
}
ObjectNode getService() {
ObjectNode services = config.getObjectMember("services").orElse(Node.objectNode());
return services.getObjectMember(endpointPrefix).orElse(Node.objectNode());
}
ObjectNode getEndpoints() {
return getService().getObjectMember("endpoints").orElse(Node.objectNode());
}
Optional<String> getPartitionEndpoint() {
ObjectNode service = getService();
// Note: regionalized services always use regionalized endpoints.
return service.getBooleanMemberOrDefault("isRegionalized", true)
? Optional.empty()
: service.getStringMember("partitionEndpoint").map(StringNode::getValue);
}
public Map<Variant, ObjectNode> getDefaults() {
return defaults;
}
public String getId() {
return id;
}
public ObjectNode getConfig() {
return config;
}
}
public static Builder builder() {
return new Builder();
}
public static final class Builder implements SmithyBuilder<EndpointGenerator> {
private GoSettings settings;
private Model model;
private TriConsumer<String, String, Consumer<GoWriter>> writerFactory;
private boolean internalOnly;
private boolean modelQueryHelpers;
private String sdkID;
private String arnNamespace;
private String endpointPrefix;
public Builder settings(GoSettings settings) {
this.settings = settings;
return this;
}
public Builder model(Model model) {
this.model = model;
return this;
}
public Builder writerFactory(TriConsumer<String, String, Consumer<GoWriter>> writerFactory) {
this.writerFactory = writerFactory;
return this;
}
public Builder internalOnly(boolean internalOnly) {
this.internalOnly = internalOnly;
return this;
}
public Builder modelQueryHelpers(boolean modelQueryHelpers) {
this.modelQueryHelpers = modelQueryHelpers;
return this;
}
public Builder sdkID(String sdkID) {
this.sdkID = sdkID;
return this;
}
public Builder arnNamespace(String arnNamespace) {
this.arnNamespace = arnNamespace;
return this;
}
public Builder endpointPrefix(String endpointPrefix) {
this.endpointPrefix = endpointPrefix;
return this;
}
@Override
public EndpointGenerator build() {
return new EndpointGenerator(this);
}
}
enum DualStackEndpointConstant {
UNSET(DUAL_STACK_ENDPOINT_TYPE_NAME + "Unset"),
ENABLE(DUAL_STACK_ENDPOINT_TYPE_NAME + "Enabled"),
DISABLE(DUAL_STACK_ENDPOINT_TYPE_NAME + "Disabled");
private final String constantName;
DualStackEndpointConstant(String name) {
this.constantName = name;
}
public String getConstantName() {
return constantName;
}
public Symbol getSymbol() {
return SymbolUtils.createValueSymbolBuilder(getConstantName(), AwsGoDependency.AWS_CORE)
.build();
}
}
enum FIPSEndpointConstant {
UNSET(FIPS_ENDPOINT_TYPE_NAME + "Unset"),
ENABLE(FIPS_ENDPOINT_TYPE_NAME + "Enabled"),
DISABLE(FIPS_ENDPOINT_TYPE_NAME + "Disabled");
private final String constantName;
FIPSEndpointConstant(String name) {
this.constantName = name;
}
public String getConstantName() {
return constantName;
}
public Symbol getSymbol() {
return SymbolUtils.createValueSymbolBuilder(getConstantName(), AwsGoDependency.AWS_CORE)
.build();
}
}
}
| 8,322 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsEndpointGenerator.java | /*
* 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.aws.go.codegen;
import java.util.List;
import java.util.function.Consumer;
import software.amazon.smithy.aws.go.codegen.customization.S3ModelUtils;
import software.amazon.smithy.aws.traits.ServiceTrait;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.go.codegen.GoSettings;
import software.amazon.smithy.go.codegen.GoWriter;
import software.amazon.smithy.go.codegen.SymbolUtils;
import software.amazon.smithy.go.codegen.TriConsumer;
import software.amazon.smithy.go.codegen.endpoints.EndpointResolutionGenerator;
import software.amazon.smithy.go.codegen.integration.ConfigField;
import software.amazon.smithy.go.codegen.integration.ConfigFieldResolver;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.go.codegen.integration.RuntimeClientPlugin;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.utils.ListUtils;
import software.amazon.smithy.utils.SetUtils;
/**
* Generates an endpoint resolver from endpoints.json.
*/
public final class AwsEndpointGenerator implements GoIntegration {
public static final String ENDPOINT_RESOLVER_CONFIG_NAME = "EndpointResolver";
public static final String ENDPOINT_OPTIONS_CONFIG_NAME = "EndpointOptions";
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
TriConsumer<String, String, Consumer<GoWriter>> writerFactory
) {
String serviceId = settings.getService(model).expectTrait(ServiceTrait.class).getSdkId();
boolean generateQueryHelpers = serviceId.equalsIgnoreCase("S3")
|| serviceId.equalsIgnoreCase("EventBridge");
EndpointGenerator.builder()
.settings(settings)
.model(model)
.writerFactory(writerFactory)
.modelQueryHelpers(generateQueryHelpers)
.build()
.run();
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return ListUtils.of(
RuntimeClientPlugin.builder()
.configFields(SetUtils.of(
ConfigField.builder()
.name(ENDPOINT_RESOLVER_CONFIG_NAME)
.type(SymbolUtils.createValueSymbolBuilder(EndpointGenerator.RESOLVER_INTERFACE_NAME)
.build())
.documentation("The service endpoint resolver.")
.deprecated(
"""
Deprecated: EndpointResolver and WithEndpointResolver.
Providing a value for this field will likely prevent you from using any
endpoint-related service features released after the introduction of
EndpointResolverV2 and BaseEndpoint.
To migrate an EndpointResolver implementation that uses a custom endpoint,
set the client option BaseEndpoint instead.
"""
)
.withHelper(true)
.build(),
ConfigField.builder()
.name(ENDPOINT_OPTIONS_CONFIG_NAME)
.type(SymbolUtils.createValueSymbolBuilder(EndpointGenerator.RESOLVER_OPTIONS)
.build())
.documentation("The endpoint options to be used when attempting "
+ "to resolve an endpoint.")
.build()
))
.addConfigFieldResolver(ConfigFieldResolver.builder()
.location(ConfigFieldResolver.Location.OPERATION)
.target(ConfigFieldResolver.Target.FINALIZATION)
.resolver(SymbolUtils.createValueSymbolBuilder(
EndpointGenerator.FINALIZE_CLIENT_ENDPOINT_RESOLVER_OPTIONS).build())
.build())
.build());
}
}
| 8,323 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsHttpChecksumGenerator.java | package software.amazon.smithy.aws.go.codegen;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import software.amazon.smithy.aws.traits.ServiceTrait;
import software.amazon.smithy.aws.traits.auth.UnsignedPayloadTrait;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.go.codegen.GoCodegenPlugin;
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.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.shapes.MemberShape;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.aws.traits.HttpChecksumTrait;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.model.traits.StreamingTrait;
import software.amazon.smithy.utils.MapUtils;
import software.amazon.smithy.utils.SetUtils;
public class AwsHttpChecksumGenerator implements GoIntegration {
// constant map with service to list of operation for which we should ignore multipart checksum validation.
private static final Map<ShapeId, Set<ShapeId>> ignoreMultipartChecksumValidationMap = MapUtils.of(
ShapeId.from("com.amazonaws.s3#AmazonS3"), SetUtils.of(
ShapeId.from("com.amazonaws.s3#GetObject")
)
);
// list of runtime-client plugins
private final List<RuntimeClientPlugin> runtimeClientPlugins = new ArrayList<>();
private static String getRequestAlgorithmAccessorFuncName(String operationName) {
return String.format("get%s%s", operationName, "RequestAlgorithmMember");
}
private static String getRequestValidationModeAccessorFuncName(String operationName) {
return String.format("get%s%s", operationName, "RequestValidationModeMember");
}
private static String getAddInputMiddlewareFuncName(String operationName) {
return String.format("add%sInputChecksumMiddlewares", operationName);
}
private static String getAddOutputMiddlewareFuncName(String operationName) {
return String.format("add%sOutputChecksumMiddlewares", operationName);
}
@Override
public byte getOrder() {
return 127;
}
/**
* Builds the set of runtime plugs.
*
* @param settings codegen settings
* @param model api model
*/
@Override
public void processFinalizedModel(GoSettings settings, Model model) {
ServiceShape service = settings.getService(model);
for (ShapeId operationId : service.getAllOperations()) {
final OperationShape operation = model.expectShape(operationId, OperationShape.class);
// Create a symbol provider because one is not available in this call.
SymbolProvider symbolProvider = GoCodegenPlugin.createSymbolProvider(model, settings);
// Input helper
String inputHelperFuncName = getAddInputMiddlewareFuncName(
symbolProvider.toSymbol(operation).getName()
);
runtimeClientPlugins.add(RuntimeClientPlugin.builder()
.operationPredicate((m, s, o) -> {
if (!hasInputChecksumTrait(m, s, o)) {
return false;
}
return o.equals(operation);
})
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(inputHelperFuncName)
.build())
.useClientOptions()
.build())
.build());
// Output helper
String outputHelperFuncName = getAddOutputMiddlewareFuncName(
symbolProvider.toSymbol(operation).getName()
);
runtimeClientPlugins.add(RuntimeClientPlugin.builder()
.operationPredicate((m, s, o) -> {
if (!hasOutputChecksumTrait(m, s, o)) {
return false;
}
return o.equals(operation);
})
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(outputHelperFuncName)
.build())
.useClientOptions()
.build())
.build());
}
}
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
ServiceShape service = settings.getService(model);
boolean supportsComputeInputChecksumsWorkflow = false;
boolean supportsChecksumValidationWorkflow = false;
for (ShapeId operationID : service.getAllOperations()) {
OperationShape operation = model.expectShape(operationID, OperationShape.class);
if (!hasChecksumTrait(model, service, operation)) {
continue;
}
final boolean generateComputeInputChecksums = hasInputChecksumTrait(model, service, operation);
if (generateComputeInputChecksums) {
supportsComputeInputChecksumsWorkflow = true;
}
final boolean generateOutputChecksumValidation = hasOutputChecksumTrait(model, service, operation);
if (generateOutputChecksumValidation) {
supportsChecksumValidationWorkflow = true;
}
goDelegator.useShapeWriter(operation, writer -> {
// generate getter helper function to access input member value
writeGetInputMemberAccessorHelper(writer, model, symbolProvider, operation);
// generate middleware helper function
if (generateComputeInputChecksums) {
writeInputMiddlewareHelper(writer, model, symbolProvider, service, operation);
}
if (generateOutputChecksumValidation) {
writeOutputMiddlewareHelper(writer, model, symbolProvider, service, operation);
}
});
}
if (supportsComputeInputChecksumsWorkflow) {
goDelegator.useShapeWriter(service, writer -> {
generateInputComputedChecksumMetadataHelpers(writer, model, symbolProvider, service);
});
}
if (supportsChecksumValidationWorkflow) {
goDelegator.useShapeWriter(service, writer -> {
generateOutputChecksumValidationMetadataHelpers(writer, model, symbolProvider, service);
});
}
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return runtimeClientPlugins;
}
// return true if operation shape is decorated with `httpChecksum` trait.
private boolean hasChecksumTrait(Model model, ServiceShape service, OperationShape operation) {
return operation.hasTrait(HttpChecksumTrait.class);
}
private boolean hasInputChecksumTrait(Model model, ServiceShape service, OperationShape operation) {
if (!hasChecksumTrait(model, service, operation)) {
return false;
}
HttpChecksumTrait trait = operation.expectTrait(HttpChecksumTrait.class);
return trait.isRequestChecksumRequired() || trait.getRequestAlgorithmMember().isPresent();
}
private boolean hasOutputChecksumTrait(Model model, ServiceShape service, OperationShape operation) {
if (!hasChecksumTrait(model, service, operation)) {
return false;
}
HttpChecksumTrait trait = operation.expectTrait(HttpChecksumTrait.class);
return trait.getRequestValidationModeMember().isPresent() && !trait.getResponseAlgorithms().isEmpty();
}
private boolean isS3ServiceShape(Model model, ServiceShape service) {
String serviceId = service.expectTrait(ServiceTrait.class).getSdkId();
return serviceId.equalsIgnoreCase("S3");
}
private void writeInputMiddlewareHelper(
GoWriter writer,
Model model,
SymbolProvider symbolProvider,
ServiceShape service,
OperationShape operation
) {
Symbol operationSymbol = symbolProvider.toSymbol(operation);
String operationName = operationSymbol.getName();
StructureShape input = model.expectShape(operation.getInput().get(), StructureShape.class);
HttpChecksumTrait trait = operation.expectTrait(HttpChecksumTrait.class);
boolean isRequestChecksumRequired = trait.isRequestChecksumRequired();
boolean hasRequestAlgorithmMember = trait.getRequestAlgorithmMember().isPresent();
boolean supportsTrailingChecksum = false;
for (MemberShape memberShape : input.getAllMembers().values()) {
Shape targetShape = model.expectShape(memberShape.getTarget());
if (targetShape.hasTrait(StreamingTrait.class) &&
!StreamingTrait.isEventStream(model, memberShape)
) {
if (isS3ServiceShape(model, service) || (
AwsSignatureVersion4.hasSigV4AuthScheme(model, service, operation)
&& !operation.hasTrait(UnsignedPayloadTrait.class))) {
supportsTrailingChecksum = true;
}
}
}
boolean supportsRequestTrailingChecksum = supportsTrailingChecksum;
boolean supportsDecodedContentLengthHeader = isS3ServiceShape(model, service);
// imports
writer.addUseImports(SmithyGoDependency.SMITHY_MIDDLEWARE);
writer.openBlock("func $L(stack *middleware.Stack, options Options) error {", "}",
getAddInputMiddlewareFuncName(operationName), () -> {
writer.write("""
return $T(stack, $T{
GetAlgorithm: $L,
RequireChecksum: $L,
EnableTrailingChecksum: $L,
EnableComputeSHA256PayloadHash: true,
EnableDecodedContentLengthHeader: $L,
})""",
SymbolUtils.createValueSymbolBuilder("AddInputMiddleware",
AwsGoDependency.SERVICE_INTERNAL_CHECKSUM).build(),
SymbolUtils.createValueSymbolBuilder("InputMiddlewareOptions",
AwsGoDependency.SERVICE_INTERNAL_CHECKSUM).build(),
hasRequestAlgorithmMember ?
getRequestAlgorithmAccessorFuncName(operationName) : "nil",
isRequestChecksumRequired,
supportsRequestTrailingChecksum,
supportsDecodedContentLengthHeader);
}
);
writer.insertTrailingNewline();
}
private void writeOutputMiddlewareHelper(
GoWriter writer,
Model model,
SymbolProvider symbolProvider,
ServiceShape service,
OperationShape operation
) {
Symbol operationSymbol = symbolProvider.toSymbol(operation);
String operationName = operationSymbol.getName();
StructureShape input = model.expectShape(operation.getInput().get(), StructureShape.class);
HttpChecksumTrait trait = operation.expectTrait(HttpChecksumTrait.class);
List<String> responseAlgorithms = trait.getResponseAlgorithms();
// imports
writer.addUseImports(SmithyGoDependency.SMITHY_MIDDLEWARE);
writer.openBlock("func $L(stack *middleware.Stack, options Options) error {", "}",
getAddOutputMiddlewareFuncName(operationName), () -> {
writer.write("""
return $T(stack, $T{
GetValidationMode: $L,
ValidationAlgorithms: $L,
IgnoreMultipartValidation: $L,
LogValidationSkipped: true,
LogMultipartValidationSkipped: true,
})""",
SymbolUtils.createValueSymbolBuilder("AddOutputMiddleware",
AwsGoDependency.SERVICE_INTERNAL_CHECKSUM).build(),
SymbolUtils.createValueSymbolBuilder("OutputMiddlewareOptions",
AwsGoDependency.SERVICE_INTERNAL_CHECKSUM).build(),
getRequestValidationModeAccessorFuncName(operationName),
convertToGoStringList(responseAlgorithms),
ignoreMultipartChecksumValidationMap.getOrDefault(
service.toShapeId(), new HashSet<>()).contains(operation.toShapeId())
);
});
writer.insertTrailingNewline();
}
private String convertToGoStringList(List<String> list) {
StringBuilder sb = new StringBuilder();
sb.append("[]string{");
for (String item : list) {
sb.append("\"").append(item).append("\"");
sb.append(",");
}
if (!list.isEmpty()) {
sb.deleteCharAt(sb.length() - 1);
}
sb.append("}");
return sb.toString();
}
private void writeGetInputMemberAccessorHelper(
GoWriter writer,
Model model,
SymbolProvider symbolProvider,
OperationShape operation
) {
Symbol operationSymbol = symbolProvider.toSymbol(operation);
StructureShape input = model.expectShape(operation.getInput().get(), StructureShape.class);
HttpChecksumTrait trait = operation.expectTrait(HttpChecksumTrait.class);
// Input parameter for computing request payload's checksum.
if (trait.getRequestAlgorithmMember().isPresent()) {
Optional<MemberShape> memberShape = input.getAllMembers().values().stream()
.filter(m -> m.getMemberName().toLowerCase(Locale.ENGLISH)
.equals(trait.getRequestAlgorithmMember().get().toLowerCase(Locale.ENGLISH)))
.findFirst();
if (!memberShape.isPresent()) {
throw new CodegenException(String.format(
"Found no matching input member named %s modeled with HttpChecksum trait",
trait.getRequestAlgorithmMember().get()));
}
String memberName = memberShape.get().getMemberName();
String funcName = getRequestAlgorithmAccessorFuncName(operationSymbol.getName());
writer.writeDocs(
String.format("%s gets the request checksum algorithm value provided as input.", funcName));
getInputTemplate(writer, symbolProvider, input, funcName, memberName);
writer.insertTrailingNewline();
}
// Output parameter for validating response payload's checksum
if (trait.getRequestValidationModeMember().isPresent()) {
Optional<MemberShape> memberShape = input.getAllMembers().values().stream()
.filter(m -> m.getMemberName().toLowerCase(Locale.ENGLISH)
.equals(trait.getRequestValidationModeMember().get().toLowerCase(Locale.ENGLISH)))
.findFirst();
if (!memberShape.isPresent()) {
throw new CodegenException(String.format(
"Found no matching input member named %s modeled with HttpChecksum trait",
trait.getRequestValidationModeMember().get()));
}
String memberName = memberShape.get().getMemberName();
String funcName = getRequestValidationModeAccessorFuncName(operationSymbol.getName());
writer.writeDocs(
String.format("%s gets the request checksum validation mode provided as input.", funcName));
getInputTemplate(writer, symbolProvider, input, funcName, memberName);
writer.insertTrailingNewline();
}
}
private void getInputTemplate(
GoWriter writer,
SymbolProvider symbolProvider,
StructureShape input,
String funcName,
String memberName
) {
writer.openBlock("func $L(input interface{}) (string, bool) {", "}", funcName,
() -> {
writer.write("in := input.($P)", symbolProvider.toSymbol(input));
writer.openBlock("if len(in.$L) == 0 {", "}", memberName, () -> {
writer.write("return \"\", false");
});
writer.write("return string(in.$L), true", memberName);
});
writer.write("");
}
private void generateInputComputedChecksumMetadataHelpers(
GoWriter writer,
Model model,
SymbolProvider symbolProvider,
ServiceShape service
) {
String metadataStructName = "ComputedInputChecksumsMetadata";
writer.writeDocs(String.format("""
%s provides information about the algorithms used to compute the checksum(s) of the
input payload.
""", metadataStructName));
writer.openBlock("type $L struct {", "}", metadataStructName, () -> {
writer.writeDocs("""
ComputedChecksums is a map of algorithm name to checksum value of the computed
input payload's checksums.
""");
writer.write("ComputedChecksums map[string]string");
});
Symbol metadataStructSymbol =
SymbolUtils.createValueSymbolBuilder(metadataStructName).build();
String metadataGetterFuncName = "Get" + metadataStructName;
Symbol getAlgorithmUsed = SymbolUtils.createValueSymbolBuilder(
"GetComputedInputChecksums", AwsGoDependency.SERVICE_INTERNAL_CHECKSUM).build();
writer.writeDocs(String.format("""
%s retrieves from the result metadata the map of algorithms and input payload checksums values.
""", metadataGetterFuncName));
writer.openBlock("func $L(m $T) ($T, bool) {", "}",
metadataGetterFuncName,
SymbolUtils.createValueSymbolBuilder("Metadata", SmithyGoDependency.SMITHY_MIDDLEWARE).build(),
metadataStructSymbol,
() -> {
writer.write("values, ok := $T(m)", getAlgorithmUsed);
writer.write("if !ok { return $T{}, false }", metadataStructSymbol);
writer.write("""
return $T{
ComputedChecksums: values,
}, true
""", metadataStructSymbol);
});
writer.write("");
}
private void generateOutputChecksumValidationMetadataHelpers(
GoWriter writer,
Model model,
SymbolProvider symbolProvider,
ServiceShape service
) {
String metadataStructName = "ChecksumValidationMetadata";
writer.writeDocs(String.format(
"%s contains metadata such as the checksum algorithm used for data integrity validation.",
metadataStructName));
writer.openBlock("type $L struct {", "}", metadataStructName, () -> {
writer.writeDocs("""
AlgorithmsUsed is the set of the checksum algorithms used to validate the response payload.
The response payload must be completely read in order for the checksum validation to be
performed. An error is returned by the operation output's response io.ReadCloser
if the computed checksums are invalid.
""");
writer.write("AlgorithmsUsed []string");
});
Symbol metadataStructSymbol =
SymbolUtils.createValueSymbolBuilder(metadataStructName).build();
String metadataGetterFuncName = "Get" + metadataStructName;
Symbol getAlgorithmUsed = SymbolUtils.createValueSymbolBuilder(
"GetOutputValidationAlgorithmsUsed", AwsGoDependency.SERVICE_INTERNAL_CHECKSUM).build();
writer.writeDocs(String.format("""
%s returns the set of algorithms that will be used to validate the response payload with. The
response payload must be completely read in order for the checksum validation to be performed.
An error is returned by the operation output's response io.ReadCloser if the computed checksums
are invalid. Returns false if no checksum algorithm used metadata was found.
""", metadataGetterFuncName));
writer.openBlock("func $L(m $T) ($T, bool) {", "}", metadataGetterFuncName,
SymbolUtils.createValueSymbolBuilder("Metadata", SmithyGoDependency.SMITHY_MIDDLEWARE).build(),
metadataStructSymbol,
() -> {
writer.write("values, ok := $T(m)", getAlgorithmUsed);
writer.write("if !ok { return $T{}, false }", metadataStructSymbol);
writer.write("""
return $T{
AlgorithmsUsed: append(make([]string, 0, len(values)), values...),
}, true
""", metadataStructSymbol);
});
writer.write("");
}
}
| 8,324 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AWSResponseErrorWrapper.java | package software.amazon.smithy.aws.go.codegen;
import java.util.List;
import software.amazon.smithy.aws.traits.ServiceTrait;
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.SymbolUtils;
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.shapes.ServiceShape;
import software.amazon.smithy.utils.ListUtils;
/**
* wraps a smithy request error with an AWS Request error.
*/
public class AWSResponseErrorWrapper implements GoIntegration {
private static final String ADD_ERROR_MIDDLEWARE = "addResponseErrorMiddleware";
private static final String ADD_ERROR_MIDDLEWARE_INTERNAL = "AddResponseErrorMiddleware";
/**
* Gets the sort order of the customization from -128 to 127, with lowest
* executed first.
*
* @return Returns the sort order, defaults to -40.
*/
@Override
public byte getOrder() {
return 127;
}
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
ServiceShape service = settings.getService(model);
// S3 doesn't need aws specific wrapper
if (requiresS3Customization(model, service)) {return;}
goDelegator.useShapeWriter(service, this::writeMiddlewareHelper);
}
private void writeMiddlewareHelper(GoWriter writer) {
writer.openBlock("func $L(stack *middleware.Stack) error {", "}", ADD_ERROR_MIDDLEWARE, () -> {
writer.write("return $T(stack)",
SymbolUtils.createValueSymbolBuilder(ADD_ERROR_MIDDLEWARE_INTERNAL,
AwsGoDependency.AWS_HTTP_TRANSPORT).build()
);
});
writer.insertTrailingNewline();
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return ListUtils.of(
RuntimeClientPlugin.builder()
.servicePredicate(((model, serviceShape) -> !requiresS3Customization(model,serviceShape)))
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(ADD_ERROR_MIDDLEWARE).build())
.build())
.build()
);
}
// returns true if service is either s3 or s3 control and needs s3 customization
private static boolean requiresS3Customization(Model model, ServiceShape service) {
String serviceId= service.expectTrait(ServiceTrait.class).getSdkId();
return serviceId.equalsIgnoreCase("S3") || serviceId.equalsIgnoreCase("S3 Control");
}
}
| 8,325 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsFnProvider.java | package software.amazon.smithy.aws.go.codegen;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.go.codegen.SymbolUtils;
import software.amazon.smithy.go.codegen.endpoints.FnProvider;
import software.amazon.smithy.rulesengine.language.syntax.expressions.functions.FunctionDefinition;
public class AwsFnProvider implements FnProvider {
@Override
public Symbol fnFor(String name) {
return switch (name) {
case "aws.partition" -> SymbolUtils.createValueSymbolBuilder("GetPartition",
AwsGoDependency.AWS_ENDPOINT_RULESFN).build();
case "aws.parseArn" -> SymbolUtils.createValueSymbolBuilder("ParseARN",
AwsGoDependency.AWS_ENDPOINT_RULESFN).build();
case "aws.isVirtualHostableS3Bucket" ->
SymbolUtils.createValueSymbolBuilder("IsVirtualHostableS3Bucket",
AwsGoDependency.AWS_ENDPOINT_RULESFN).build();
default -> null;
};
}
static boolean isFnResultOptional(FunctionDefinition fn) {
return switch (fn.getId()) {
case "aws.partition" -> true;
case "aws.parseArn" -> true;
case "aws.isVirtualHostableS3Bucket" -> true;
default -> false;
};
}
}
| 8,326 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/JsonMemberDeserVisitor.java | /*
* 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.aws.go.codegen;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.go.codegen.CodegenUtils;
import software.amazon.smithy.go.codegen.GoWriter;
import software.amazon.smithy.go.codegen.SmithyGoDependency;
import software.amazon.smithy.go.codegen.integration.ProtocolGenerator;
import software.amazon.smithy.go.codegen.integration.ProtocolGenerator.GenerationContext;
import software.amazon.smithy.go.codegen.integration.ProtocolUtils;
import software.amazon.smithy.go.codegen.knowledge.GoPointableIndex;
import software.amazon.smithy.model.shapes.BigDecimalShape;
import software.amazon.smithy.model.shapes.BigIntegerShape;
import software.amazon.smithy.model.shapes.BlobShape;
import software.amazon.smithy.model.shapes.BooleanShape;
import software.amazon.smithy.model.shapes.ByteShape;
import software.amazon.smithy.model.shapes.CollectionShape;
import software.amazon.smithy.model.shapes.DocumentShape;
import software.amazon.smithy.model.shapes.DoubleShape;
import software.amazon.smithy.model.shapes.FloatShape;
import software.amazon.smithy.model.shapes.IntegerShape;
import software.amazon.smithy.model.shapes.ListShape;
import software.amazon.smithy.model.shapes.LongShape;
import software.amazon.smithy.model.shapes.MapShape;
import software.amazon.smithy.model.shapes.MemberShape;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ResourceShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.SetShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.ShapeVisitor;
import software.amazon.smithy.model.shapes.ShortShape;
import software.amazon.smithy.model.shapes.StringShape;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.model.shapes.TimestampShape;
import software.amazon.smithy.model.shapes.UnionShape;
import software.amazon.smithy.model.traits.EnumTrait;
import software.amazon.smithy.model.traits.TimestampFormatTrait.Format;
/**
* Visitor to generate member values for aggregate types deserialized from documents.
*/
public class JsonMemberDeserVisitor implements ShapeVisitor<Void> {
private final GenerationContext context;
private final MemberShape member;
private final String dataDest;
private final Format timestampFormat;
private final GoPointableIndex pointableIndex;
public JsonMemberDeserVisitor(
GenerationContext context,
MemberShape member,
String dataDest,
Format timestampFormat
) {
this.context = context;
this.member = member;
this.dataDest = dataDest;
this.timestampFormat = timestampFormat;
this.pointableIndex = GoPointableIndex.of(context.getModel());
}
@Override
public Void blobShape(BlobShape shape) {
GoWriter writer = context.getWriter().get();
ServiceShape service = context.getService();
writer.addUseImports(SmithyGoDependency.FMT);
writer.addUseImports(SmithyGoDependency.BASE64);
final String typeError = "return fmt.Errorf(\"expected $L to be []byte, got %T instead\", value)";
writer.openBlock("if value != nil {", "}", () -> {
writer.write("jtv, ok := value.(string)");
writer.openBlock("if !ok {", "}", () -> {
writer.write(typeError, shape.getId().getName(service));
});
writer.write("dv, err := base64.StdEncoding.DecodeString(jtv)");
writer.openBlock("if err != nil {", "}", () -> {
writer.write("return fmt.Errorf(\"failed to base64 decode $L, %w\", err)",
shape.getId().getName(service));
});
writer.write("$L = $L", dataDest, CodegenUtils.getAsPointerIfPointable(context.getModel(),
context.getWriter().get(), pointableIndex, member, "dv"));
});
return null;
}
@Override
public Void booleanShape(BooleanShape shape) {
GoWriter writer = context.getWriter().get();
ServiceShape service = context.getService();
writer.addUseImports(SmithyGoDependency.FMT);
writer.openBlock("if value != nil {", "}", () -> {
writer.write("jtv, ok := value.(bool)");
writer.openBlock("if !ok {", "}", () -> {
writer.write("return fmt.Errorf(\"expected $L to be of type *bool, got %T instead\", value)",
shape.getId().getName(service));
});
writer.write("$L = $L", dataDest, CodegenUtils.getAsPointerIfPointable(context.getModel(),
writer, pointableIndex, member, "jtv"));
});
return null;
}
@Override
public Void byteShape(ByteShape shape) {
GoWriter writer = context.getWriter().get();
// Smithy's byte shape represents a signed 8-bit int, which doesn't line up with Go's unsigned byte
handleInteger(shape, CodegenUtils.getAsPointerIfPointable(context.getModel(), writer,
pointableIndex, member, "int8(i64)"));
return null;
}
@Override
public Void shortShape(ShortShape shape) {
GoWriter writer = context.getWriter().get();
handleInteger(shape, CodegenUtils.getAsPointerIfPointable(context.getModel(), writer,
pointableIndex, member, "int16(i64)"));
return null;
}
@Override
public Void integerShape(IntegerShape shape) {
GoWriter writer = context.getWriter().get();
handleInteger(shape, CodegenUtils.getAsPointerIfPointable(context.getModel(), writer,
pointableIndex, member, "int32(i64)"));
return null;
}
@Override
public Void longShape(LongShape shape) {
handleInteger(shape, CodegenUtils.getAsPointerIfPointable(context.getModel(), context.getWriter().get(),
pointableIndex, member, "i64"));
return null;
}
/**
* Deserializes a number without a fractional value.
* <p>
* The 64-bit integer representation of the number is stored in the variable {@code i64}.
*
* @param shape The shape being deserialized.
* @param cast A wrapping of {@code i64} to cast it to the proper type.
*/
private void handleInteger(Shape shape, String cast) {
GoWriter writer = context.getWriter().get();
handleNumber(shape, () -> {
writer.write("i64, err := jtv.Int64()");
writer.write("if err != nil { return err }");
writer.write("$L = $L", dataDest, cast);
});
}
/**
* Deserializes a json number into a json token.
* <p>
* The number token is stored under the variable {@code jtv}.
*
* @param shape The shape being deserialized.
* @param r A runnable that runs after the value has been parsed, before the scope closes.
*/
private void handleNumber(Shape shape, Runnable r) {
GoWriter writer = context.getWriter().get();
ServiceShape service = context.getService();
writer.addUseImports(SmithyGoDependency.FMT);
writer.openBlock("if value != nil {", "}", () -> {
writer.write("jtv, ok := value.(json.Number)");
writer.openBlock("if !ok {", "}", () -> {
writer.write("return fmt.Errorf(\"expected $L to be json.Number, got %T instead\", value)",
shape.getId().getName(service));
});
r.run();
});
}
/**
* Deserializes a json arbitrary precision number into a json token.
* <p>
* The number token is stored under the variable {@code jtv}.
*
* @param shape The shape being deserialized.
* @param jsonNumber A runnable that runs after the value has been parsed to a json.Number, before the scope closes.
* @param jsonString A runnable that runs after the value has been parsed to a string, before the scope closes.
*/
private void handleDecimal(Shape shape, Runnable jsonNumber, Runnable jsonString) {
GoWriter writer = context.getWriter().get();
ServiceShape service = context.getService();
writer.addUseImports(SmithyGoDependency.FMT);
writer.openBlock("if value != nil {", "}", () -> {
writer.openBlock("switch jtv := value.(type) {", "}", () -> {
writer.openBlock("case json.Number:", "", jsonNumber);
if (jsonString != null) {
writer.openBlock("case string:", "", jsonString);
}
writer.openBlock("default:", "", () -> {
writer.write("return fmt.Errorf(\"expected $L to be a JSON Number, got %T instead\", value)",
shape.getId().getName(service));
});
});
});
}
@Override
public Void floatShape(FloatShape shape) {
handleFloat(shape, CodegenUtils.getAsPointerIfPointable(context.getModel(), context.getWriter().get(),
pointableIndex, member, "float32(f64)"), true);
return null;
}
@Override
public Void doubleShape(DoubleShape shape) {
handleFloat(shape, CodegenUtils.getAsPointerIfPointable(context.getModel(), context.getWriter().get(),
pointableIndex, member, "f64"), true);
return null;
}
/**
* Deserializes a number with a fractional value.
* <p>
* The 64-bit float representation of the number is stored in the variable {@code f64}.
*
* @param shape The shape being deserialized.
* @param cast A wrapping of {@code f64} to cast it to the proper type.
*/
private void handleFloat(Shape shape, String cast, boolean handleNonNumbers) {
GoWriter writer = context.getWriter().get();
Runnable jsonString = null;
if (handleNonNumbers) {
jsonString = () -> {
writer.addUseImports(SmithyGoDependency.STRINGS);
writer.addUseImports(SmithyGoDependency.MATH);
writer.write("var f64 float64");
writer.openBlock("switch {", "}", () -> {
writer.openBlock("case strings.EqualFold(jtv, \"NaN\"):", "", () -> {
writer.write("f64 = math.NaN()");
});
writer.openBlock("case strings.EqualFold(jtv, \"Infinity\"):", "", () -> {
writer.write("f64 = math.Inf(1)");
});
writer.openBlock("case strings.EqualFold(jtv, \"-Infinity\"):", "", () -> {
writer.write("f64 = math.Inf(-1)");
});
writer.openBlock("default:", "", () -> {
writer.addUseImports(SmithyGoDependency.FMT);
writer.write("return fmt.Errorf(\"unknown JSON number value: %s\", jtv)");
});
});
writer.write("$L = $L", dataDest, cast);
};
}
handleDecimal(shape, () -> {
writer.write("f64, err := jtv.Float64()");
writer.write("if err != nil { return err }");
writer.write("$L = $L", dataDest, cast);
}, jsonString);
}
@Override
public Void stringShape(StringShape shape) {
GoWriter writer = context.getWriter().get();
Symbol symbol = context.getSymbolProvider().toSymbol(shape);
if (shape.hasTrait(EnumTrait.class)) {
handleString(shape, () -> writer.write("$L = $P(jtv)", dataDest, symbol));
} else {
handleString(shape, () -> writer.write("$L = $L", dataDest, CodegenUtils.getAsPointerIfPointable(
context.getModel(), context.getWriter().get(), pointableIndex, member, "jtv")));
}
return null;
}
/**
* Deserializes a json string into a json token.
* <p>
* The number token is stored under the variable {@code jtv}.
*
* @param shape The shape being deserialized.
* @param r A runnable that runs after the value has been parsed, before the scope closes.
*/
private void handleString(Shape shape, Runnable r) {
GoWriter writer = context.getWriter().get();
ServiceShape service = context.getService();
writer.addUseImports(SmithyGoDependency.FMT);
writer.openBlock("if value != nil {", "}", () -> {
writer.write("jtv, ok := value.(string)");
writer.openBlock("if !ok {", "}", () -> {
writer.write("return fmt.Errorf(\"expected $L to be of type string, got %T instead\", value)",
shape.getId().getName(service));
});
r.run();
});
}
@Override
public Void timestampShape(TimestampShape shape) {
GoWriter writer = context.getWriter().get();
writer.addUseImports(SmithyGoDependency.SMITHY_TIME);
switch (timestampFormat) {
case DATE_TIME:
handleString(shape, () -> {
writer.write("t, err := smithytime.ParseDateTime(jtv)");
writer.write("if err != nil { return err }");
writer.write("$L = $L", dataDest, CodegenUtils.getAsPointerIfPointable(context.getModel(),
context.getWriter().get(), pointableIndex, member, "t"));
});
break;
case HTTP_DATE:
handleString(shape, () -> {
writer.write("t, err := smithytime.ParseHTTPDate(jtv)");
writer.write("if err != nil { return err }");
writer.write("$L = $L", dataDest, CodegenUtils.getAsPointerIfPointable(context.getModel(),
context.getWriter().get(), pointableIndex, member, "t"));
});
break;
case EPOCH_SECONDS:
writer.addUseImports(SmithyGoDependency.SMITHY_PTR);
handleFloat(shape, CodegenUtils.getAsPointerIfPointable(context.getModel(), context.getWriter().get(),
pointableIndex, member, "smithytime.ParseEpochSeconds(f64)"), false);
break;
default:
throw new CodegenException(String.format("Unknown timestamp format %s", timestampFormat));
}
return null;
}
@Override
public Void bigIntegerShape(BigIntegerShape shape) {
// Fail instead of losing precision through Number.
unsupportedShape(shape);
return null;
}
@Override
public Void bigDecimalShape(BigDecimalShape shape) {
// Fail instead of losing precision through Number.
unsupportedShape(shape);
return null;
}
private String unsupportedShape(Shape shape) {
throw new CodegenException(String.format("Cannot deserialize shape type %s on protocol, shape: %s.",
shape.getType(), shape.getId()));
}
@Override
public Void operationShape(OperationShape shape) {
throw new CodegenException("Operation shapes cannot be bound to documents.");
}
@Override
public Void resourceShape(ResourceShape shape) {
throw new CodegenException("Resource shapes cannot be bound to documents.");
}
@Override
public Void serviceShape(ServiceShape shape) {
throw new CodegenException("Service shapes cannot be bound to documents.");
}
@Override
public Void memberShape(MemberShape shape) {
throw new CodegenException("Member shapes cannot be bound to documents.");
}
@Override
public Void documentShape(DocumentShape shape) {
writeDelegateFunction(shape);
return null;
}
@Override
public Void structureShape(StructureShape shape) {
writeDelegateFunction(shape);
return null;
}
@Override
public Void unionShape(UnionShape shape) {
writeDelegateFunction(shape);
return null;
}
@Override
public Void listShape(ListShape shape) {
return collectionShape(shape);
}
@Override
public Void setShape(SetShape shape) {
return collectionShape(shape);
}
private Void collectionShape(CollectionShape shape) {
writeDelegateFunction(shape);
return null;
}
@Override
public Void mapShape(MapShape shape) {
writeDelegateFunction(shape);
return null;
}
private void writeDelegateFunction(Shape shape) {
String functionName = ProtocolGenerator.getDocumentDeserializerFunctionName(shape, context.getService(), context.getProtocolName());
GoWriter writer = context.getWriter().get();
ProtocolUtils.writeDeserDelegateFunction(context, writer, member, dataDest, (destVar) -> {
writer.openBlock("if err := $L(&$L, value); err != nil {", "}", functionName, destVar, () -> {
writer.write("return err");
});
});
}
}
| 8,327 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsRetryMiddlewareHelper.java | /*
* 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.aws.go.codegen;
import software.amazon.smithy.codegen.core.Symbol;
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.GoIntegration;
import software.amazon.smithy.model.Model;
public class AwsRetryMiddlewareHelper implements GoIntegration {
public static final String ADD_RETRY_MIDDLEWARES_HELPER = "addRetryMiddlewares";
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator delegator
) {
delegator.useShapeWriter(settings.getService(model), this::generateRetryMiddlewareHelpers);
}
private void generateRetryMiddlewareHelpers(GoWriter writer) {
Symbol stackSymbol = SymbolUtils.createPointableSymbolBuilder("Stack", SmithyGoDependency.SMITHY_MIDDLEWARE)
.build();
Symbol addRetryMiddlewares = SymbolUtils.createValueSymbolBuilder("AddRetryMiddlewares",
AwsGoDependency.AWS_RETRY).build();
Symbol addOptions = SymbolUtils.createValueSymbolBuilder("AddRetryMiddlewaresOptions",
AwsGoDependency.AWS_RETRY).build();
writer.openBlock("func $L(stack $P, o Options) error {", "}", ADD_RETRY_MIDDLEWARES_HELPER, stackSymbol,
() -> {
writer.openBlock("mo := $T{", "}", addOptions, () -> {
writer.write("$L: o.$L,", AddAwsConfigFields.RETRYER_CONFIG_NAME,
AddAwsConfigFields.RETRYER_CONFIG_NAME);
writer.write("LogRetryAttempts: o.$L.IsRetries(),",
AddAwsConfigFields.LOG_MODE_CONFIG_NAME);
});
writer.write("return $T(stack, mo)", addRetryMiddlewares);
});
}
}
| 8,328 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsEndpointResolverInitializerGenerator.java | package software.amazon.smithy.aws.go.codegen;
import static software.amazon.smithy.go.codegen.GoWriter.goTemplate;
import software.amazon.smithy.aws.traits.ServiceTrait;
import software.amazon.smithy.codegen.core.SymbolProvider;
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.TriConsumer;
import software.amazon.smithy.go.codegen.endpoints.EndpointResolutionGenerator;
import software.amazon.smithy.go.codegen.integration.ConfigField;
import software.amazon.smithy.go.codegen.integration.ConfigFieldResolver;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.go.codegen.integration.RuntimeClientPlugin;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.utils.ListUtils;
import software.amazon.smithy.utils.MapUtils;
import software.amazon.smithy.utils.SetUtils;
import java.util.List;
import java.util.function.Consumer;
import java.util.Map;
public class AwsEndpointResolverInitializerGenerator implements GoIntegration {
public static final String RESOLVE_ENDPOINT_RESOLVER_V2 = "resolve" + EndpointResolutionGenerator.RESOLVER_INTERFACE_NAME;
public static final String RESOLVE_BASE_ENDPOINT = "resolveBaseEndpoint";
private Map<String, Object> commonCodegenArgs;
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
TriConsumer<String, String, Consumer<GoWriter>> writerFactory
) {
String sdkId = settings.getService(model).expectTrait(ServiceTrait.class).getSdkId();
this.commonCodegenArgs = MapUtils.of(
"envSdkId", sdkId.toUpperCase().replaceAll(" ", "_"),
"configSdkId", sdkId.toLowerCase().replaceAll(" ", "_"),
"urlSdkId", sdkId.toLowerCase().replaceAll(" ", "-"),
"testing", SymbolUtils.createPointableSymbolBuilder("T", SmithyGoDependency.TESTING).build(),
"awsString", SymbolUtils.createValueSymbolBuilder("String", AwsGoDependency.AWS_CORE).build()
);
writerFactory.accept("endpoints.go", settings.getModuleName(), writer -> {
writer.write(
"""
$W
$W
"""
,
generateResolveMethod(),
generateConfigResolverMethod(
settings.getService(model).expectTrait(ServiceTrait.class).getSdkId())
);
});
}
private GoWriter.Writable generateConfigResolverMethod(String sdkId) {
return goTemplate(
"""
func $resolveMethodName:L(cfg $awsConfig:T, o *Options) {
if cfg.BaseEndpoint != nil {
o.BaseEndpoint = cfg.BaseEndpoint
}
_, g := $lookupEnv:T("AWS_ENDPOINT_URL")
_, s := $lookupEnv:T("AWS_ENDPOINT_URL_$envSdkId:L")
if g && !s {
return
}
value, found, err := $resolveServiceEndpoint:T(context.Background(), "$sdkId:L", cfg.ConfigSources)
if found && err == nil {
o.BaseEndpoint = &value
}
}
""",
MapUtils.of(
"resolveMethodName", RESOLVE_BASE_ENDPOINT,
"awsConfig", SymbolUtils.createValueSymbolBuilder("Config", AwsGoDependency.AWS_CORE).build(),
"lookupEnv", SymbolUtils.createValueSymbolBuilder("LookupEnv", SmithyGoDependency.OS).build(),
"resolveServiceEndpoint", SymbolUtils.createValueSymbolBuilder(
"ResolveServiceBaseEndpoint", AwsGoDependency.SERVICE_INTERNAL_CONFIG).build(),
"sdkId", sdkId
),
this.commonCodegenArgs
);
}
private GoWriter.Writable generateResolveMethod() {
return goTemplate(
"""
func $resolveMethodName:L(options *Options) {
if options.EndpointResolverV2 == nil {
options.EndpointResolverV2 = $newResolverFuncName:L()
}
}
""",
MapUtils.of(
"resolveMethodName", RESOLVE_ENDPOINT_RESOLVER_V2,
"newResolverFuncName", EndpointResolutionGenerator.NEW_RESOLVER_FUNC_NAME
));
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return ListUtils.of(
RuntimeClientPlugin.builder()
.configFields(SetUtils.of(
ConfigField.builder()
.name(EndpointResolutionGenerator.RESOLVER_INTERFACE_NAME)
.type(SymbolUtils.createValueSymbolBuilder(EndpointResolutionGenerator.RESOLVER_INTERFACE_NAME)
.build())
.documentation(String.format(
"""
Resolves the endpoint used for a particular service. This should be used over the
deprecated %s
""",
EndpointGenerator.RESOLVER_INTERFACE_NAME
))
.withHelper(true)
.build()
))
.addConfigFieldResolver(ConfigFieldResolver.builder()
.location(ConfigFieldResolver.Location.OPERATION)
.target(ConfigFieldResolver.Target.INITIALIZATION)
.resolver(SymbolUtils.createValueSymbolBuilder(
RESOLVE_ENDPOINT_RESOLVER_V2).build())
.build())
.build());
}
}
| 8,329 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsJsonRpc1_1.java | /*
* 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.aws.go.codegen;
import software.amazon.smithy.aws.traits.protocols.AwsJson1_1Trait;
import software.amazon.smithy.model.shapes.ShapeId;
/**
* Handles generating the awsJson1_1 protocol for services.
*
* @inheritDoc
*
* @see JsonRpcProtocolGenerator
*/
public class AwsJsonRpc1_1 extends JsonRpcProtocolGenerator {
@Override
protected String getDocumentContentType() {
return "application/x-amz-json-1.1";
}
@Override
public ShapeId getProtocol() {
return AwsJson1_1Trait.ID;
}
}
| 8,330 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/LegacyEndpointContextSetter.java | package software.amazon.smithy.aws.go.codegen;
import java.util.ArrayList;
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.GoStackStepMiddlewareGenerator;
import software.amazon.smithy.go.codegen.GoWriter;
import software.amazon.smithy.go.codegen.MiddlewareIdentifier;
import software.amazon.smithy.go.codegen.SmithyGoDependency;
import software.amazon.smithy.go.codegen.SymbolUtils;
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;
public class LegacyEndpointContextSetter implements GoIntegration {
private final List<RuntimeClientPlugin> runtimeClientPlugins = new ArrayList<>();
public static final String MIDDLEWARE_ID = "legacyEndpointContextSetter";
public static final String MIDDLEWARE_ADDER = String.format("add%s", MIDDLEWARE_ID);
/**
* Gets the sort order of the customization from -128 to 127, with lowest
* executed first. Needs to execute after Rules Engine endpoint
* resolution middleware insertion.
*
* @return Returns the sort order, defaults to 127.
*/
@Override
public byte getOrder() {
return -128;
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return runtimeClientPlugins;
}
@Override
public void processFinalizedModel(GoSettings settings, Model model) {
var serviceShape = settings.getService(model);
runtimeClientPlugins.add(RuntimeClientPlugin.builder()
.servicePredicate((m, s) -> s.equals(serviceShape))
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(
MIDDLEWARE_ADDER)
.build())
.useClientOptions()
.build())
.build());
}
@Override
public void renderPreEndpointResolutionHook(GoSettings settings, GoWriter writer, Model model) {
writer.write(
"""
if $T(ctx) {
return next.HandleSerialize(ctx, in)
}
""",
SymbolUtils.createValueSymbolBuilder("GetRequiresLegacyEndpoints", AwsGoDependency.AWS_MIDDLEWARE).build()
);
}
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator) {
var serviceShape = settings.getService(model);
goDelegator.useShapeWriter(serviceShape, writer -> {
GoStackStepMiddlewareGenerator middleware = GoStackStepMiddlewareGenerator
.createInitializeStepMiddleware(
MIDDLEWARE_ID,
MiddlewareIdentifier.string(MIDDLEWARE_ID));
middleware.writeMiddleware(writer, this::generateMiddlewareResolverBody,
this::generateMiddlewareStructureMembers);
writer.write(
"""
func $L(stack $P, o Options) error {
return stack.Initialize.Add(&$L{
LegacyResolver: o.EndpointResolver,
}, middleware.Before)
}
""",
MIDDLEWARE_ADDER,
SymbolUtils.createPointableSymbolBuilder("Stack",
SmithyGoDependency.SMITHY_MIDDLEWARE).build(),
MIDDLEWARE_ID);
writer.write("");
});
}
private void generateMiddlewareResolverBody(GoStackStepMiddlewareGenerator g, GoWriter writer) {
writer.write(
"""
if m.LegacyResolver != nil {
ctx = $T(ctx, true)
}
return next.HandleInitialize(ctx, in)
""",
SymbolUtils.createValueSymbolBuilder("SetRequiresLegacyEndpoints", AwsGoDependency.AWS_MIDDLEWARE).build()
);
}
private void generateMiddlewareStructureMembers(GoStackStepMiddlewareGenerator g, GoWriter writer) {
writer.write("LegacyResolver $L", "EndpointResolver");
}
}
| 8,331 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AWSRequestIDRetriever.java | package software.amazon.smithy.aws.go.codegen;
import java.util.List;
import software.amazon.smithy.aws.traits.ServiceTrait;
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.SymbolUtils;
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.shapes.ServiceShape;
import software.amazon.smithy.utils.ListUtils;
/**
* Retrieves request id from response header of deserialized response shapes
*/
public class AWSRequestIDRetriever implements GoIntegration {
private static final String ADD_REQUEST_ID_RETRIEVER = "addRequestIDRetrieverMiddleware";
private static final String ADD_REQUEST_ID_RETRIEVER_INTERNAL = "AddRequestIDRetrieverMiddleware";
/**
* Gets the sort order of the customization from -128 to 127, with lowest
* executed first.
*
* @return Returns the sort order, defaults to -40.
*/
@Override
public byte getOrder() {
return 127;
}
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
ServiceShape service = settings.getService(model);
// S3 doesn't need aws specific wrapper
if (requiresS3Customization(model, service)) {return;}
goDelegator.useShapeWriter(service, this::writeMiddlewareHelper);
}
private void writeMiddlewareHelper(GoWriter writer) {
writer.openBlock("func $L(stack *middleware.Stack) error {", "}", ADD_REQUEST_ID_RETRIEVER, () -> {
writer.write("return $T(stack)",
SymbolUtils.createValueSymbolBuilder(ADD_REQUEST_ID_RETRIEVER_INTERNAL,
AwsGoDependency.AWS_MIDDLEWARE).build()
);
});
writer.insertTrailingNewline();
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return ListUtils.of(
RuntimeClientPlugin.builder()
.servicePredicate(((model, serviceShape) -> !requiresS3Customization(model,serviceShape)))
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(ADD_REQUEST_ID_RETRIEVER).build())
.build())
.build()
);
}
// returns true if service is either s3 or s3 control and needs s3 customization
private static boolean requiresS3Customization(Model model, ServiceShape service) {
String serviceId= service.expectTrait(ServiceTrait.class).getSdkId();
return serviceId.equalsIgnoreCase("S3") || serviceId.equalsIgnoreCase("S3 Control");
}
}
| 8,332 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsEventStreamUtils.java | package software.amazon.smithy.aws.go.codegen;
import java.util.Set;
import java.util.TreeSet;
import java.util.stream.Collectors;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.go.codegen.CodegenUtils;
import software.amazon.smithy.go.codegen.EventStreamGenerator;
import software.amazon.smithy.go.codegen.GoDependency;
import software.amazon.smithy.go.codegen.GoEventStreamIndex;
import software.amazon.smithy.go.codegen.GoSettings;
import software.amazon.smithy.go.codegen.GoStackStepMiddlewareGenerator;
import software.amazon.smithy.go.codegen.GoValueAccessUtils;
import software.amazon.smithy.go.codegen.GoWriter;
import software.amazon.smithy.go.codegen.MiddlewareIdentifier;
import software.amazon.smithy.go.codegen.SmithyGoDependency;
import software.amazon.smithy.go.codegen.SymbolUtils;
import software.amazon.smithy.go.codegen.integration.ProtocolGenerator.GenerationContext;
import software.amazon.smithy.go.codegen.knowledge.GoPointableIndex;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.knowledge.EventStreamIndex;
import software.amazon.smithy.model.knowledge.EventStreamInfo;
import software.amazon.smithy.model.shapes.BlobShape;
import software.amazon.smithy.model.shapes.BooleanShape;
import software.amazon.smithy.model.shapes.ByteShape;
import software.amazon.smithy.model.shapes.IntegerShape;
import software.amazon.smithy.model.shapes.LongShape;
import software.amazon.smithy.model.shapes.MemberShape;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.ShapeVisitor;
import software.amazon.smithy.model.shapes.ShortShape;
import software.amazon.smithy.model.shapes.StringShape;
import software.amazon.smithy.model.shapes.TimestampShape;
import software.amazon.smithy.model.shapes.ToShapeId;
import software.amazon.smithy.model.shapes.UnionShape;
import software.amazon.smithy.model.traits.ErrorTrait;
import software.amazon.smithy.model.traits.EventHeaderTrait;
import software.amazon.smithy.model.traits.EventPayloadTrait;
import software.amazon.smithy.model.traits.HttpTrait;
import software.amazon.smithy.utils.StringUtils;
public final class AwsEventStreamUtils {
private static final String EVENT_STREAM_SERIALIZER_HELPER = "eventStreamSerializerHelper";
private static final String EVENT_STREAM_SIGNER_INTERFACE = "eventStreamSigner";
private static final String CONTEXT_GET_EVENT_STREAM_INPUT = "getEventStreamInput";
private static final String CONTEXT_WITH_EVENT_STREAM_INPUT = "withEventStreamInput";
private AwsEventStreamUtils() {
}
public static void generateEventStreamComponents(GenerationContext context) {
Model model = context.getModel();
GoWriter writer = context.getWriter().get();
ServiceShape serviceShape = context.getService();
GoSettings settings = context.getSettings();
boolean isHttpBindingProto = model.getOperationShapesWithTrait(HttpTrait.class).size() > 0;
EventStreamIndex streamIndex = EventStreamIndex.of(model);
var inputEventStreams = GoEventStreamIndex.of(model).getInputEventStreams(serviceShape);
var outputEventStreams = GoEventStreamIndex.of(model).getOutputEventStreams(serviceShape);
if (inputEventStreams.isEmpty() && outputEventStreams.isEmpty()) {
return;
}
final var operationShapes = new TreeSet<OperationShape>();
if (inputEventStreams.isPresent()) {
generateEventSignerInterface(settings, writer);
if (!isHttpBindingProto) {
generateInputMiddlewareHelper(settings, writer);
}
inputEventStreams.get().forEach((shapeId, eventStreamInfos) -> {
generateEventStreamWriter(context, model.expectShape(shapeId, UnionShape.class), eventStreamInfos,
!isHttpBindingProto);
eventStreamInfos.forEach(info -> operationShapes.add(info.getOperation()));
});
}
if (outputEventStreams.isPresent()) {
outputEventStreams.get().forEach((shapeId, eventStreamInfos) -> {
generateEventStreamReader(context, model.expectShape(shapeId, UnionShape.class), eventStreamInfos,
!isHttpBindingProto);
eventStreamInfos.forEach(info -> operationShapes.add(info.getOperation()));
});
}
for (OperationShape operationShape : operationShapes) {
if (streamIndex.getInputInfo(operationShape).isEmpty()
&& streamIndex.getOutputInfo(operationShape).isEmpty()) {
continue;
}
generateEventStreamMiddleware(context, operationShape, !isHttpBindingProto);
}
generateUnknownEventMessageError(context);
generateEventStreamClientLogModeFinalizer(context, operationShapes);
generateToggleClientLogModeFinalizer(context);
}
private static void generateInputMiddlewareHelper(GoSettings settings, GoWriter writer) {
writer.pushState();
writer.putContext("context", SymbolUtils.createValueSymbolBuilder("Context",
SmithyGoDependency.CONTEXT).build());
writer.putContext("errorf", SymbolUtils.createValueSymbolBuilder("Errorf",
SmithyGoDependency.FMT).build());
var middleware = GoStackStepMiddlewareGenerator.createSerializeStepMiddleware(
EVENT_STREAM_SERIALIZER_HELPER,
MiddlewareIdentifier.builder()
.name("OperationEventStreamSerializer")
.build());
writer.putContext("keyType", SymbolUtils.createValueSymbolBuilder("eventStreamInputKey").build());
writer.putContext("withValue", SymbolUtils.createValueSymbolBuilder("WithValue",
SmithyGoDependency.CONTEXT).build());
writer.putContext("contextGetter", CONTEXT_GET_EVENT_STREAM_INPUT);
writer.putContext("contextSetter", CONTEXT_WITH_EVENT_STREAM_INPUT);
writer.putContext("smithyRequest", getSymbol("Request", SmithyGoDependency.SMITHY_HTTP_TRANSPORT));
writer.write("""
type $keyType:T struct{}
func $contextGetter:L(ctx $context:P) interface{} {
return ctx.Value($keyType:T{})
}
func $contextSetter:L(ctx $context:P, value interface{}) $context:T {
return $withValue:T(ctx, $keyType:T{}, value)
}
""");
middleware.writeMiddleware(writer, (mg, wr) -> {
wr.putContext("nextMethod", mg.getHandleMethodName());
wr.write("return next.$nextMethod:L($contextSetter:L(ctx, in.Parameters), in)");
});
writer.popState();
}
private static void generateUnknownEventMessageError(GenerationContext context) {
var writer = context.getWriter().get();
var symbol = getUnknownEventMessageErrorSymbol();
var message = getEventStreamSymbol("Message");
writer.write("""
// $T provides an error when a message is received from the stream,
// but the reader is unable to determine what kind of message it is.
type $T struct {
Type string
Message $P
}
// Error retruns the error message string.
func (e $P) Error() string {
return "unknown event stream message type, " + e.Type
}
""", symbol, symbol, message, symbol);
}
private static Symbol getUnknownEventMessageErrorSymbol() {
return SymbolUtils.createPointableSymbolBuilder("UnknownEventMessageError").build();
}
private static void generateEventStreamClientLogModeFinalizer(
GenerationContext context,
Set<OperationShape> operationShapes
) {
var writer = context.getWriter().get();
var streamIndex = EventStreamIndex.of(context.getModel());
writer.openBlock("func $T(o *Options, operation string) {", "}",
getEventStreamClientLogModeFinalizerSymbol(), () -> {
writer.openBlock("switch operation {", "}", () -> {
operationShapes.forEach(operationShape -> {
var requestStream = streamIndex
.getInputInfo(operationShape).isPresent();
var responseStream = streamIndex
.getOutputInfo(operationShape).isPresent();
writer.write("""
case $S:
$T(o, $L, $L)
return
""", operationShape.getId().getName(),
getToggleEventStreamClientLogModeSymbol(), requestStream,
responseStream);
});
writer.write("""
default:
return
""");
});
});
}
private static void generateToggleClientLogModeFinalizer(GenerationContext context) {
var writer = context.getWriter().get();
var logRequest = SymbolUtils.createValueSymbolBuilder("LogRequest",
AwsGoDependency.AWS_CORE).build();
var logResponse = SymbolUtils.createValueSymbolBuilder("LogResponse",
AwsGoDependency.AWS_CORE).build();
writer.openBlock("func $T(o *Options, request, response bool) {", "}",
getToggleEventStreamClientLogModeSymbol(), () -> {
writer.write("""
mode := o.ClientLogMode
if request && mode.IsRequestWithBody() {
mode.ClearRequestWithBody()
mode |= $T
}
if response && mode.IsResponseWithBody() {
mode.ClearResponseWithBody()
mode |= $T
}
o.ClientLogMode = mode
""", logRequest, logResponse
);
}).write("");
}
public static Symbol getEventStreamClientLogModeFinalizerSymbol() {
return SymbolUtils.createValueSymbolBuilder("setSafeEventStreamClientLogMode")
.build();
}
private static Symbol getToggleEventStreamClientLogModeSymbol() {
return SymbolUtils.createValueSymbolBuilder("toggleEventStreamClientLogMode")
.build();
}
public static Symbol getAddEventStreamOperationMiddlewareSymbol(OperationShape operationShape) {
return SymbolUtils.createValueSymbolBuilder(String.format("addEventStream%sMiddleware",
StringUtils.capitalize(operationShape.getId().getName())))
.build();
}
private static void generateEventStreamMiddleware(
GenerationContext context,
OperationShape operationShape,
boolean withInitialMessages
) {
var serviceShape = context.getService();
var middlewareName = getSerDeName(operationShape, serviceShape, context.getProtocolName(),
"_deserializeOpEventStream");
var errorf = getSymbol("Errorf", SmithyGoDependency.FMT, false);
var getSignedRequestSignature = getSymbol("GetSignedRequestSignature", AwsGoDependency.AWS_SIGNER_V4, false);
var symbolProvider = context.getSymbolProvider();
var model = context.getModel();
var outputShape = model.expectShape(operationShape.getOutput().get());
var inputInfo = EventStreamIndex.of(model).getInputInfo(operationShape);
var outputInfo = EventStreamIndex.of(model).getOutputInfo(operationShape);
var writer = context.getWriter().get();
var middleware = GoStackStepMiddlewareGenerator.createDeserializeStepMiddleware(middlewareName, MiddlewareIdentifier.builder()
.name("OperationEventStreamDeserializer")
.build());
middleware.writeMiddleware(writer,
(mg, w) -> {
w.write("""
defer func() {
if err == nil {
return
}
m.closeResponseBody(out)
}()
logger := $T(ctx)
""", getSymbol("GetLogger",
SmithyGoDependency.SMITHY_MIDDLEWARE, false));
w.write("""
request, ok := in.Request.($P)
if !ok {
return out, metadata, $T("unknown transport type: %T", in.Request)
}
_ = request
""", getSymbol("Request", SmithyGoDependency.SMITHY_HTTP_TRANSPORT), errorf);
if (inputInfo.isPresent()) {
w.write("""
if err := $T(request); err != nil {
return out, metadata, err
}
""", getEventStreamApiSymbol("ApplyHTTPTransportFixes"))
.write("");
w.write("""
requestSignature, err := $T(request.Request)
if err != nil {
return out, metadata, $T("failed to get event stream seed signature: %v", err)
}
""", getSignedRequestSignature, errorf).write("")
.openBlock("signer := $T(", ")", getSymbol("NewStreamSigner",
AwsGoDependency.AWS_SIGNER_V4, false), () -> w
.write("""
$T(ctx),
$T(ctx),
$T(ctx),
requestSignature,
""", getSymbol("GetSigningCredentials",
AwsGoDependency.AWS_MIDDLEWARE, false),
getSymbol("GetSigningName",
AwsGoDependency.AWS_MIDDLEWARE, false),
getSymbol("GetSigningRegion",
AwsGoDependency.AWS_MIDDLEWARE, false)
)).write("");
var events = inputInfo.get().getEventStreamTarget().asUnionShape()
.get();
var constructorName = getEventStreamWriterImplConstructorName(events,
serviceShape);
var newEncoder = getEventStreamSymbol("NewEncoder", false);
var encoderOptions = getEventStreamSymbol("EncoderOptions");
w.openBlock("eventWriter := $L(", ")", constructorName, () -> {
w.write("$T(ctx),", getEventStreamApiSymbol("GetInputStreamWriter",
false))
.openBlock("$T(func(options $P) {", "}),", newEncoder,
encoderOptions, () -> w
.write("""
options.Logger = logger
options.LogMessages = m.LogEventStreamWrites
"""))
.write("signer,");
if (withInitialMessages) {
w.write("$L,", getEventStreamMessageRequestSerializerName(
operationShape.getInput().get(), serviceShape,
context.getProtocolName()));
}
})
.write("""
defer func() {
if err == nil {
return
}
_ = eventWriter.Close()
}()
""");
if (withInitialMessages) {
var inputShape = model.expectShape(operationShape.getInput().get());
w.write("""
params, ok := $L(ctx).($P)
if !ok || params == nil {
return out, metadata, $T("unexpected nil type: %T", params)
}
reqSend := make(chan error, 1)
go func() {
defer close(reqSend)
sErr := eventWriter.send(ctx, &$T{Value: params})
reqSend <- sErr
}()
""", CONTEXT_GET_EVENT_STREAM_INPUT, symbolProvider.toSymbol(inputShape),
errorf, getWriterEventWrapperInitialRequestType(symbolProvider,
inputInfo.get().getEventStreamTarget().asUnionShape().get(), serviceShape));
}
}
var outputSymbol = symbolProvider.toSymbol(outputShape);
w.write("out, metadata, err = next.HandleDeserialize(ctx, in)");
writer.openBlock("if err != nil {", "}", () -> {
if (withInitialMessages && inputInfo.isPresent()) {
w.write("""
select {
case sErr := <-reqSend:
if sErr != nil {
err = $T("%v: %w", err, sErr)
}
default:
}""", errorf);
}
writer.write("return out, metadata, err");
}).write("");
if (withInitialMessages && inputInfo.isPresent()) {
w.write("""
if err := <-reqSend; err != nil {
return out, metadata, err
}
""");
}
w.write("""
deserializeOutput, ok := out.RawResponse.($P)
if !ok {
return out, metadata, $T("unknown transport type: %T", out.RawResponse)
}
_ = deserializeOutput
output, ok := out.Result.($P)
if out.Result != nil && !ok {
return out, metadata, $T("unexpected output result type: %T", out.Result)
} else if out.Result == nil {
output = &$T{}
out.Result = output
}
""", getSymbol("Response", SmithyGoDependency.SMITHY_HTTP_TRANSPORT), errorf,
outputSymbol, errorf, outputSymbol
);
if (outputInfo.isPresent()) {
var events = outputInfo.get().getEventStreamTarget().asUnionShape()
.get();
var constructorName = getEventStreamReaderImplConstructorName(events,
serviceShape);
var newDecoder = getEventStreamSymbol("NewDecoder", false);
var decoderOptions = getEventStreamSymbol("DecoderOptions");
w.openBlock("eventReader := $L(", ")", constructorName, () -> {
w.write("deserializeOutput.Body,")
.openBlock("$T(func(options $P) {", "}),", newDecoder,
decoderOptions, () -> w
.write("""
options.Logger = logger
options.LogMessages = m.LogEventStreamReads
"""));
if (withInitialMessages) {
w.write("$L,", getEventStreamMessageResponseDeserializerName(
operationShape.getOutput().get(), serviceShape,
context.getProtocolName()));
}
})
.write("""
defer func() {
if err == nil {
return
}
_ = eventReader.Close()
}()
""");
if (withInitialMessages) {
w.write("""
ir := <-eventReader.initialResponse
irv, ok := ir.($P)
if !ok {
return out, metadata, $T("unexpected output result type: %T", ir)
}
*output = *irv
""", outputSymbol, errorf);
}
}
var streamConstructor = EventStreamGenerator.getEventStreamOperationStructureConstructor(
serviceShape, operationShape);
var operationStream = EventStreamGenerator.getEventStreamOperationStructureSymbol(
serviceShape, operationShape);
w.openBlock("output.eventStream = $T(func(stream $P) {", "})", streamConstructor,
operationStream, () -> {
inputInfo.ifPresent(eventStreamInfo -> {
w.write("stream.Writer = eventWriter");
});
outputInfo.ifPresent(eventStreamInfo -> {
w.write("stream.Reader = eventReader");
});
}).write("")
.write("go output.eventStream.waitStreamClose()").write("")
.write("return out, metadata, nil");
},
(mg, w) -> w.write("""
LogEventStreamWrites bool
LogEventStreamReads bool
"""));
var deserializeOutput = getSymbol("DeserializeOutput", SmithyGoDependency.SMITHY_MIDDLEWARE);
var httpResponse = getSymbol("Response", SmithyGoDependency.SMITHY_HTTP_TRANSPORT);
var copy = getSymbol("Copy", SmithyGoDependency.IO);
var discard = getSymbol("Discard", SmithyGoDependency.IOUTIL);
writer.write("""
func ($P) closeResponseBody(out $T) {
if resp, ok := out.RawResponse.($P); ok && resp != nil && resp.Body != nil {
_, _ = $T($T, resp.Body)
_ = resp.Body.Close()
}
}
""", middleware.getMiddlewareSymbol(), deserializeOutput, httpResponse, copy, discard);
var stack = getSymbol("Stack", SmithyGoDependency.SMITHY_MIDDLEWARE);
var after = getSymbol("After", SmithyGoDependency.SMITHY_MIDDLEWARE);
var before = getSymbol("Before", SmithyGoDependency.SMITHY_MIDDLEWARE);
writer.openBlock("func $T(stack $P, options Options) error {", "}",
getAddEventStreamOperationMiddlewareSymbol(operationShape), stack,
() -> {
if (withInitialMessages && inputInfo.isPresent()) {
writer.write("""
if err := stack.Serialize.Insert(&$T{}, "OperationSerializer", $T); err != nil {
return err
}
""", getModuleSymbol(context.getSettings(), EVENT_STREAM_SERIALIZER_HELPER),
after);
}
writer.write("""
if err := stack.Deserialize.Insert(&$T{
LogEventStreamWrites: options.ClientLogMode.IsRequestEventMessage(),
LogEventStreamReads: options.ClientLogMode.IsResponseEventMessage(),
}, "OperationDeserializer", $T); err != nil {
return err
}
return nil
""", middleware.getMiddlewareSymbol(), before);
});
}
private static void generateEventSignerInterface(GoSettings settings, GoWriter writer) {
writer.openBlock("type $T interface {", "}", getModuleSymbol(settings, EVENT_STREAM_SIGNER_INTERFACE),
() -> {
writer.write("GetSignature(ctx context.Context, headers, payload []byte, signingTime time.Time, "
+ "optFns ...func($P)) ([]byte, error)",
SymbolUtils.createPointableSymbolBuilder("StreamSignerOptions",
AwsGoDependency.AWS_SIGNER_V4)
.build());
}).write("");
}
private static void generateEventStreamReader(
GenerationContext context,
UnionShape eventStream,
Set<EventStreamInfo> operationShapes,
boolean withInitialMessages
) {
var settings = context.getSettings();
var service = context.getService();
var symbolProvider = context.getSymbolProvider();
var writer = context.getWriter().get();
var eventUnionSymbol = symbolProvider.toSymbol(eventStream);
var eventSymbol = withInitialMessages ? getReaderEventWrapperInterface(symbolProvider,
eventStream, service) : eventUnionSymbol;
var readerImplName = getEventStreamReaderImplName(eventStream, service);
var readerSymbol = getModuleSymbol(settings, readerImplName);
var decoderSymbol = getEventStreamSymbol("Decoder");
var messageSymbol = SymbolUtils.createPointableSymbolBuilder("Message",
AwsGoDependency.SERVICE_INTERNAL_EVENTSTREAM).build();
var readCloser = getSymbol("ReadCloser", SmithyGoDependency.IO, false);
if (withInitialMessages) {
generateEventStreamReaderMessageWrapper(eventStream, service, symbolProvider, writer, eventUnionSymbol);
}
writer.openBlock("type $T struct {", "}", readerSymbol, () -> {
var onceErr = getSymbol("OnceErr", SmithyGoDependency.SMITHY_SYNC);
var syncOnce = getSymbol("Once", SmithyGoDependency.SYNC, false);
writer.write("""
stream chan $T
decoder $P
eventStream $T
err $P
payloadBuf []byte
done chan struct{}
closeOnce $T""", eventUnionSymbol, decoderSymbol, readCloser, onceErr, syncOnce);
if (withInitialMessages) {
writer.write("initialResponseDeserializer func($P) (interface{}, error)", messageSymbol);
writer.write("initialResponse chan interface{}");
}
}).write("");
writer.writeInline("func $L(readCloser $T, decoder $P",
getEventStreamReaderImplConstructorName(eventStream, service), readCloser,
getSymbol("Decoder", AwsGoDependency.SERVICE_INTERNAL_EVENTSTREAM));
if (withInitialMessages) {
writer.writeInline(", ird func($P) (interface{}, error)", messageSymbol);
}
writer.openBlock(") $P {", "}",
readerSymbol, () -> {
var newOnceErr = getSymbol("NewOnceErr", SmithyGoDependency.SMITHY_SYNC, false);
writer.openBlock("w := &$T{", "}", readerSymbol, () -> {
writer.write("""
stream: make(chan $T),
decoder: decoder,
eventStream: readCloser,
err: $T(),
done: make(chan struct{}),
payloadBuf: make([]byte, 10*1024),""", eventUnionSymbol, newOnceErr);
if (withInitialMessages) {
writer.write("initialResponseDeserializer: ird,");
writer.write("initialResponse: make(chan interface{}, 1),");
}
}).write("");
writer.write("""
go w.readEventStream()
return w""");
}).write("");
writer.openBlock("func (r $P) Events() <-chan $T {", "}", readerSymbol, eventUnionSymbol, () -> writer
.write("return r.stream")).write("");
writer.openBlock("func (r $P) readEventStream() {", "}", readerSymbol, () -> {
writer.write("""
defer r.Close()
defer close(r.stream)
""");
if (withInitialMessages) {
writer.write("""
defer close(r.initialResponse)
""");
}
writer.openBlock("for {", "}", () -> {
writer.write("""
r.payloadBuf = r.payloadBuf[0:0]
decodedMessage, err := r.decoder.Decode(r.eventStream, r.payloadBuf)
if err != nil {
if err == $T {
return
}
select {
case <-r.done:
return
default:
r.err.SetError(err)
return
}
}
event, err := r.deserializeEventMessage(&decodedMessage)
if err != nil {
r.err.SetError(err)
return
}
""", SymbolUtils.createValueSymbolBuilder("EOF",
SmithyGoDependency.IO).build());
if (withInitialMessages) {
writer.write("""
switch ev := event.(type) {
case $P:
select {
case r.initialResponse <- ev.Value:
case <-r.done:
return
default:
}
case $P:
select {
case r.stream <- ev.Value:
case <-r.done:
return
}
default:
r.err.SetError($T("unexpected event wrapper: %T", event))
return
}
""",
getReaderEventWrapperInitialResponseType(symbolProvider, eventStream, service),
getReaderEventWrapperMessageType(symbolProvider, eventStream, service),
getSymbol("Errorf", SmithyGoDependency.FMT, false));
} else {
writer.write("""
select {
case r.stream <- event:
case <-r.done:
return
}
""");
}
});
}
).write("");
var errorf = SymbolUtils.createValueSymbolBuilder("Errorf", SmithyGoDependency.FMT).build();
writer.openBlock("func (r $P) deserializeEventMessage(msg $P) ($T, error) {", "}", readerSymbol, messageSymbol,
eventSymbol, () -> {
var messageTypeHeader = getEventStreamApiSymbol("MessageTypeHeader", false);
var eventMessageType = getEventStreamApiSymbol("EventMessageType", false);
var exceptionMessageType = getEventStreamApiSymbol("ExceptionMessageType", false);
var errorMessageType = getEventStreamApiSymbol("ErrorMessageType", false);
writer.write("""
messageType := msg.Headers.Get($T)
if messageType == nil {
return nil, $T("%s event header not present", $T)
}
""", messageTypeHeader, errorf, messageTypeHeader)
.openBlock("switch messageType.String() {", "}", () -> writer
.openBlock("case $T:", "", eventMessageType, () -> {
if (withInitialMessages) {
var eventTypeHeader = getEventStreamApiSymbol("EventTypeHeader",
false);
writer.write("""
eventType := msg.Headers.Get($T)
if eventType == nil {
return nil, $T("%s event header not present", $T)
}
if eventType.String() == "initial-response" {
v, err := r.initialResponseDeserializer(msg)
if err != nil {
return nil, err
}
return &$T{Value: v}, nil
}
""", eventTypeHeader, errorf, eventTypeHeader,
getReaderEventWrapperInitialResponseType(symbolProvider,
eventStream, service));
}
writer.write("""
var v $T
if err := $L(&v, msg); err != nil {
return nil, err
}""",
eventUnionSymbol, getEventStreamDeserializerName(eventStream,
service, context.getProtocolName()));
if (withInitialMessages) {
writer.write("return &$T{Value: v}, nil",
getReaderEventWrapperMessageType(symbolProvider,
eventStream, service));
} else {
writer.write("return v, nil");
}
})
.openBlock("case $T:", "", exceptionMessageType, () -> writer
.write("return nil, $L(msg)",
getEventStreamExceptionDeserializerName(eventStream, service,
context.getProtocolName())))
.openBlock("case $T:", "", errorMessageType, () -> writer
.write("""
errorCode := "UnknownError"
errorMessage := errorCode
if header := msg.Headers.Get($T); header != nil {
errorCode = header.String()
}
if header := msg.Headers.Get($T); header != nil {
errorMessage = header.String()
}
return nil, &$T{
Code: errorCode,
Message: errorMessage,
}
""", getEventStreamApiSymbol("ErrorCodeHeader", false),
getEventStreamApiSymbol("ErrorMessageHeader", false),
getSymbol("GenericAPIError", SmithyGoDependency.SMITHY, false)))
.write("""
default:
mc := msg.Clone()
return nil, &$T{
Type: messageType.String(),
Message: &mc,
}
""", getUnknownEventMessageErrorSymbol()));
}).write("");
writer.openBlock("func (r $P) ErrorSet() <-chan struct{} {", "}", readerSymbol, () -> writer
.write("return r.err.ErrorSet()")).write("");
writer.openBlock("func (r $P) Close() error {", "}", readerSymbol, () -> writer
.write("r.closeOnce.Do(r.safeClose)")
.write("return r.Err()")).write("");
writer.openBlock("func (r $P) safeClose() {", "}", readerSymbol, () -> writer
.write("""
close(r.done)
r.eventStream.Close()
""")).write("");
writer.openBlock("func (r $P) Err() error {", "}", readerSymbol, () -> writer
.write("return r.err.Err()")).write("");
writer.openBlock("func (r $P) Closed() <-chan struct{} {", "}", readerSymbol,
() -> writer.write("return r.done")).write("");
}
private static void generateEventStreamReaderMessageWrapper(
UnionShape eventStream,
ServiceShape service,
SymbolProvider symbolProvider,
GoWriter writer,
Symbol eventUnionSymbol
) {
var readerEventWrapperInterface = getReaderEventWrapperInterface(symbolProvider, eventStream, service);
var interfaceMethod = "is" + StringUtils.capitalize(readerEventWrapperInterface.getName());
writer.write("""
type $T interface {
$L()
}
""", readerEventWrapperInterface, interfaceMethod);
var readerEventWrapperMessageType = getReaderEventWrapperMessageType(symbolProvider, eventStream, service);
writer.write("""
type $T struct {
Value $P
}
func ($P) $L() {}
""", readerEventWrapperMessageType, eventUnionSymbol, readerEventWrapperMessageType,
interfaceMethod);
var readerEventWrapperInitialResponseType = getReaderEventWrapperInitialResponseType(symbolProvider,
eventStream, service);
writer.write("""
type $T struct {
Value interface{}
}
func ($P) $L() {}
""", readerEventWrapperInitialResponseType, readerEventWrapperInitialResponseType,
interfaceMethod);
}
private static void generateEventStreamWriter(
GenerationContext context,
UnionShape eventStream,
Set<EventStreamInfo> eventStreamInfos,
boolean withInitialMessages
) {
var settings = context.getSettings();
var service = context.getService();
var symbolProvider = context.getSymbolProvider();
var writer = context.getWriter().get();
var eventUnionSymbol = symbolProvider.toSymbol(eventStream);
var asyncEventSymbol = getModuleSymbol(settings, getAsyncWriteReporterName(eventStream,
service));
var eventSymbol = withInitialMessages ? getWriterEventWrapperInterface(symbolProvider,
eventStream, service) : eventUnionSymbol;
generateAsyncWriteReporter(writer, eventSymbol, asyncEventSymbol);
var writerImplName = getEventStreamWriterImplName(eventStream, service);
var writerSymbol = getModuleSymbol(settings, writerImplName);
var encoderSymbol = getSymbol("Encoder", AwsGoDependency.SERVICE_INTERNAL_EVENTSTREAM);
var writeCloser = getSymbol("WriteCloser", SmithyGoDependency.IO);
var signerInterface = getModuleSymbol(settings, EVENT_STREAM_SIGNER_INTERFACE);
var messageSymbol = getEventStreamSymbol("Message", true);
if (withInitialMessages) {
generateEventStreamWriterMessageWrapper(eventStream, service, symbolProvider, writer, eventUnionSymbol);
}
writer.openBlock("type $T struct {", "}", writerSymbol, () -> {
var bytesBufferSymbol = SymbolUtils.createPointableSymbolBuilder("Buffer",
SmithyGoDependency.BYTES).build();
var syncOnce = getSymbol("Once", SmithyGoDependency.SYNC);
var onceErr = getSymbol("OnceErr", SmithyGoDependency.SMITHY_SYNC);
writer.write("""
encoder $P
signer $T
stream chan $T
serializationBuffer $P
signingBuffer $P
eventStream $T
done chan struct{}
closeOnce $T
err $P
""", encoderSymbol, signerInterface, asyncEventSymbol, bytesBufferSymbol, bytesBufferSymbol,
writeCloser, syncOnce, onceErr);
if (withInitialMessages) {
writer.write("initialRequestSerializer func(interface{}, $P) error", messageSymbol);
}
}).write("");
Symbol bytesNewBuffer = SymbolUtils.createValueSymbolBuilder("NewBuffer",
SmithyGoDependency.BYTES).build();
writer.writeInline("func $L(stream $T, encoder $P, signer $T",
getEventStreamWriterImplConstructorName(eventStream, service), writeCloser, encoderSymbol,
signerInterface);
if (withInitialMessages) {
writer.writeInline(", irs func(interface{}, $P) error", messageSymbol);
}
writer.openBlock(") $P {", "}", writerSymbol, () -> writer
.openBlock("w := &$T{", "}", writerSymbol, () -> {
var onceErr = SymbolUtils.createValueSymbolBuilder("NewOnceErr",
SmithyGoDependency.SMITHY_SYNC).build();
writer.write("""
encoder: encoder,
signer: signer,
stream: make(chan $T),
eventStream: stream,
done: make(chan struct{}),
err: $T(),
serializationBuffer: $T(nil),
signingBuffer: $T(nil),
""", asyncEventSymbol, onceErr, bytesNewBuffer, bytesNewBuffer);
if (withInitialMessages) {
writer.write("initialRequestSerializer: irs,");
}
}).write("")
.write("""
go w.writeStream()
return w
""")).write("");
Symbol contextSymbol = SymbolUtils.createValueSymbolBuilder("Context", SmithyGoDependency.CONTEXT).build();
writer.openBlock("func (w $P) Send(ctx $P, event $P) error {", "}", writerSymbol, contextSymbol,
eventUnionSymbol, () -> {
if (withInitialMessages) {
writer.write("return w.send(ctx, &$T{Value: event})",
getWriterEventWrapperMessageType(symbolProvider, eventStream, service));
} else {
writer.write("return w.send(ctx, event)");
}
}).write("");
writer.openBlock("func (w $P) send(ctx $P, event $P) error {", "}", writerSymbol, contextSymbol,
eventSymbol, () -> {
writer.write("""
if err := w.err.Err(); err != nil {
return err
}
resultCh := make(chan error)
wrapped := $T{
Event: event,
Result: resultCh,
}
""", asyncEventSymbol);
Symbol errorfSymbol = SymbolUtils.createValueSymbolBuilder("Errorf", SmithyGoDependency.FMT)
.build();
final String streamClosedError = "stream closed, unable to send event";
writer.openBlock("select {", "}", () -> writer
.write("""
case w.stream <- wrapped:
case <-ctx.Done():
return ctx.Err()
case <-w.done:
return $T($S)
""", errorfSymbol, streamClosedError)).write("");
writer.openBlock("select {", "}", () -> writer
.write("""
case err := <-resultCh:
return err
case <-ctx.Done():
return ctx.Err()
case <-w.done:
return $T($S)
""", errorfSymbol, streamClosedError)).write("");
}).write("");
writer.openBlock("func (w $P) writeStream() {", "}", writerSymbol, () -> writer
.write("defer w.Close()").write("")
.openBlock("for {", "}", () -> writer
.openBlock("select {", "}", () -> writer
.openBlock("case wrapper := <-w.stream:", "", () -> writer
.write("err := w.writeEvent(wrapper.Event)")
.write("wrapper.ReportResult(w.done, err)")
.openBlock("if err != nil {", "}", () -> writer
.write("w.err.SetError(err)")
.write("return")))
.openBlock("case <-w.done:", "", () -> writer
.openBlock("if err := w.closeStream(); err != nil {", "}",
() -> writer.write("w.err.SetError(err)"))
.write("return"))))).write("");
writer.openBlock("func (w $P) writeEvent(event $P) error {", "}", writerSymbol, eventSymbol, () -> {
Runnable returnErr = () -> writer.openBlock("if err != nil {", "}", () -> writer.write("return err"))
.write("");
writer.writeDocs("""
serializedEvent returned bytes refers to an underlying byte buffer and must not escape
this writeEvent scope without first copying. Any previous bytes stored in the buffer
are cleared by this call.
""");
writer.write("serializedEvent, err := w.serializeEvent(event)");
returnErr.run();
writer.writeDocs("""
signedEvent returned bytes refers to an underlying byte buffer and must not escape
this writeEvent scope without first copying. Any previous bytes stored in the buffer
are cleared by this call.
""");
writer.write("signedEvent, err := w.signEvent(serializedEvent)");
returnErr.run();
writer.writeDocs("bytes are now copied to the underlying stream writer");
writer.write("_, err = io.Copy(w.eventStream, bytes.NewReader(signedEvent))")
.write("return err");
}).write("");
writer.openBlock("func (w $P) serializeEvent(event $P) ([]byte, error) {", "}", writerSymbol, eventSymbol,
() -> {
writer.write("w.serializationBuffer.Reset()").write("")
.write("eventMessage := $T{}", messageSymbol).write("");
var eventStreamSerializerName = getEventStreamSerializerName(eventStream, service,
context.getProtocolName());
if (withInitialMessages) {
var initialRequestType = getWriterEventWrapperInitialRequestType(symbolProvider, eventStream,
service);
var messageEventType = getWriterEventWrapperMessageType(symbolProvider, eventStream,
service);
var errorf = getSymbol("Errorf", SmithyGoDependency.FMT, false);
writer.write("""
switch ev := event.(type) {
case $P:
if err := w.initialRequestSerializer(ev.Value, &eventMessage); err != nil {
return nil, err
}
case $P:
if err := $L(ev.Value, &eventMessage); err != nil {
return nil, err
}
default:
return nil, $T("unknown event wrapper type: %v", event)
}
""", initialRequestType, messageEventType, eventStreamSerializerName, errorf);
} else {
writer.write("""
if err := $L(event, &eventMessage); err != nil {
return nil, err
}
""",
eventStreamSerializerName);
}
writer.write("""
if err := w.encoder.Encode(w.serializationBuffer, eventMessage); err != nil {
return nil, err
}
return w.serializationBuffer.Bytes(), nil""");
}).write("");
writer.openBlock("func (w $P) signEvent(payload []byte) ([]byte, error) {", "}", writerSymbol, () -> {
var timestampValue = getEventStreamSymbol("TimestampValue", false);
var dateHeader = getEventStreamApiSymbol("DateHeader", false);
var chunkSignatureHeader = getEventStreamApiSymbol("ChunkSignatureHeader", false);
var bytesValue = getEventStreamSymbol("BytesValue", false);
writer.addUseImports(SmithyGoDependency.TIME);
writer.write("w.signingBuffer.Reset()").write("")
.write("date := time.Now().UTC()").write("")
.write("var msg $T", messageSymbol)
.write("msg.Headers.Set($T, $T(date))", dateHeader, timestampValue)
.write("msg.Payload = payload").write("")
.write("var headers bytes.Buffer")
.openBlock("if err := $T(&headers, msg.Headers); err != nil {", "}",
getEventStreamSymbol("EncodeHeaders", false),
() -> writer.write("return nil, err")).write("")
.write("sig, err := w.signer.GetSignature(context.Background(), headers.Bytes(), "
+ "msg.Payload, date)")
.openBlock("if err != nil {", "}", () -> writer
.write("return nil, err")).write("")
.write("msg.Headers.Set($T, $T(sig))", chunkSignatureHeader, bytesValue).write("")
.openBlock("if err := w.encoder.Encode(w.signingBuffer, msg); err != nil {", "}", () -> writer
.write("return nil, err")).write("")
.write("return w.signingBuffer.Bytes(), nil");
}).write("");
writer.openBlock("func (w $P) closeStream() (err error) {", "}", writerSymbol, () -> writer
.openBlock("defer func() {", "}()", () -> writer
.openBlock("if cErr := w.eventStream.Close(); cErr != nil && err == nil {", "}",
() -> writer.write("err = cErr"))).write("")
.write("""
// Per the protocol, a signed empty message is used to indicate the end of the stream,
// and that no subsequent events will be sent.
signedEvent, err := w.signEvent([]byte{})""")
.openBlock("if err != nil {", "}", () -> writer.write("return err")).write("")
.write("_, err = io.Copy(w.eventStream, bytes.NewReader(signedEvent))")
.write("return err")).write("");
writer.openBlock("func (w $P) ErrorSet() <-chan struct{} {", "}", writerSymbol, () -> writer
.write("return w.err.ErrorSet()")).write("");
writer.openBlock("func (w $P) Close() error {", "}", writerSymbol, () -> writer
.write("w.closeOnce.Do(w.safeClose)")
.write("return w.Err()")).write("");
writer.openBlock("func (w $P) safeClose() {", "}", writerSymbol, () -> writer
.write("close(w.done)")).write("");
writer.openBlock("func (w $P) Err() error {", "}", writerSymbol, () -> writer
.write("return w.err.Err()")).write("");
}
private static void generateEventStreamWriterMessageWrapper(
UnionShape eventStream,
ServiceShape service,
SymbolProvider symbolProvider,
GoWriter writer,
Symbol eventUnionSymbol
) {
var writerEventWrapperInterface = getWriterEventWrapperInterface(symbolProvider, eventStream, service);
var interfaceMethod = "is" + StringUtils.capitalize(writerEventWrapperInterface.getName());
writer.write("""
type $T interface {
$L()
}
""", writerEventWrapperInterface, interfaceMethod);
var writerEventWrapperMessageType = getWriterEventWrapperMessageType(symbolProvider, eventStream, service);
writer.write("""
type $T struct {
Value $P
}
func ($P) $L() {}
""", writerEventWrapperMessageType, eventUnionSymbol, writerEventWrapperMessageType,
interfaceMethod);
var writerEventWrapperInitialRequestType = getWriterEventWrapperInitialRequestType(symbolProvider, eventStream,
service);
writer.write("""
type $T struct {
Value interface{}
}
func ($P) $L() {}
""", writerEventWrapperInitialRequestType, writerEventWrapperInitialRequestType, interfaceMethod);
}
private static Symbol getWriterEventWrapperInterface(
SymbolProvider symbolProvider,
UnionShape eventStream,
ServiceShape service
) {
var name = StringUtils.uncapitalize(eventStream.toShapeId().getName(service)) + "WriteEvent";
return SymbolUtils.createValueSymbolBuilder(name, symbolProvider.toSymbol(service).getNamespace()).build();
}
private static Symbol getWriterEventWrapperMessageType(
SymbolProvider symbolProvider,
UnionShape eventStream,
ServiceShape service
) {
var interfaceSymbol = getWriterEventWrapperInterface(symbolProvider, eventStream, service);
var name = interfaceSymbol.getName() + "Message";
return SymbolUtils.createPointableSymbolBuilder(name, symbolProvider.toSymbol(service).getNamespace())
.build();
}
private static Symbol getWriterEventWrapperInitialRequestType(
SymbolProvider symbolProvider,
UnionShape eventStream,
ServiceShape service
) {
var interfaceSymbol = getWriterEventWrapperInterface(symbolProvider, eventStream, service);
var name = interfaceSymbol.getName() + "InitialRequest";
return SymbolUtils.createPointableSymbolBuilder(name, symbolProvider.toSymbol(service).getNamespace())
.build();
}
private static Symbol getReaderEventWrapperInterface(
SymbolProvider symbolProvider,
UnionShape eventStream,
ServiceShape service
) {
var name = StringUtils.uncapitalize(eventStream.toShapeId().getName(service)) + "ReadEvent";
return SymbolUtils.createValueSymbolBuilder(name, symbolProvider.toSymbol(service).getNamespace()).build();
}
private static Symbol getReaderEventWrapperMessageType(
SymbolProvider symbolProvider,
UnionShape eventStream,
ServiceShape service
) {
var interfaceSymbol = getReaderEventWrapperInterface(symbolProvider, eventStream, service);
var name = interfaceSymbol.getName() + "Message";
return SymbolUtils.createPointableSymbolBuilder(name, symbolProvider.toSymbol(service).getNamespace())
.build();
}
private static Symbol getReaderEventWrapperInitialResponseType(
SymbolProvider symbolProvider,
UnionShape eventStream,
ServiceShape service
) {
var interfaceSymbol = getReaderEventWrapperInterface(symbolProvider, eventStream, service);
var name = interfaceSymbol.getName() + "InitialResponse";
return SymbolUtils.createPointableSymbolBuilder(name, symbolProvider.toSymbol(service).getNamespace())
.build();
}
public static void generateEventStreamSerializer(
GenerationContext context,
UnionShape eventUnion
) {
GoWriter writer = context.getWriter().get();
SymbolProvider symbolProvider = context.getSymbolProvider();
ServiceShape serviceShape = context.getService();
Symbol eventUnionSymbol = symbolProvider.toSymbol(eventUnion);
Model model = context.getModel();
GoPointableIndex pointableIndex = GoPointableIndex.of(model);
var eventTypeHeader = getEventStreamApiSymbol("EventTypeHeader", false);
var stringValue = getEventStreamSymbol("StringValue", false);
writer.openBlock("func $L(v $P, msg $P) error {", "}", getEventStreamSerializerName(eventUnion,
serviceShape, context.getProtocolName()), eventUnionSymbol,
getEventStreamSymbol("Message"), () -> {
Symbol errof = getSymbol("Errorf", SmithyGoDependency.FMT, false);
writer.write("""
if v == nil {
return $T("unexpected serialization of nil %T", v)
}
""", errof)
.write("")
.openBlock("switch vv := v.(type) {", "}", () -> {
for (MemberShape member : eventUnion.members()) {
Symbol memberSymbol = SymbolUtils.createPointableSymbolBuilder(
symbolProvider.toMemberName(member),
eventUnionSymbol.getNamespace())
.build();
writer.openBlock("case $P:", "", memberSymbol, () -> writer
.write("msg.Headers.Set($T, $T($S))", eventTypeHeader, stringValue,
member.getMemberName())
.write("return $L($L, msg)",
getEventStreamMessageSerializerName(member.getTarget(),
serviceShape, context.getProtocolName()),
CodegenUtils.getAsPointerIfPointable(model, writer, pointableIndex,
model.expectShape(member.getTarget()), "vv.Value")));
}
writer.write("""
default:
return $T("unexpected event message type: %v", v)
""", errof);
});
});
}
public static void generateEventMessageSerializer(
GenerationContext context,
Shape targetShape,
MessageSerDelegator messageSerDelegator
) {
var writer = context.getWriter().get();
var model = context.getModel();
var serviceShape = context.getService();
var serializerName = getEventStreamMessageSerializerName(targetShape, serviceShape,
context.getProtocolName());
var errorf = getSymbol("Errorf", SmithyGoDependency.FMT, false);
var messageTypeHeader = getEventStreamApiSymbol("MessageTypeHeader");
var stringValue = getEventStreamSymbol("StringValue", false);
var eventMessageType = getEventStreamApiSymbol("EventMessageType", false);
var contentTypeHeader = getEventStreamApiSymbol("ContentTypeHeader", false);
var symbolProvider = context.getSymbolProvider();
writer.openBlock("func $L(v $P, msg $P) error {", "}", serializerName, symbolProvider.toSymbol(targetShape),
getEventStreamSymbol("Message"), () -> {
writer.write("""
if v == nil {
return $T("unexpected serialization of nil %T", v)
}
""", errorf).write("")
.write("msg.Headers.Set($T, $T($T))", messageTypeHeader, stringValue, eventMessageType);
var headerBindings = targetShape.members().stream()
.filter(memberShape -> memberShape.hasTrait(EventHeaderTrait.class))
.collect(Collectors.toSet());
var payloadBinding = targetShape.members().stream()
.filter(memberShape -> memberShape.hasTrait(EventPayloadTrait.class))
.reduce((memberShape, memberShape2) -> {
throw new CodegenException("expect only one EventPayloadTrait targetShape");
});
if (!headerBindings.isEmpty() || payloadBinding.isPresent()) {
for (var headerBinding : headerBindings) {
new HeaderShapeSerVisitor(writer, model, headerBinding, "msg",
headerBinding.getMemberName(), "v." + symbolProvider.toMemberName(headerBinding))
.writeHeaderSerializer();
}
if (payloadBinding.isPresent()) {
var memberShape = payloadBinding.get();
var payloadTarget = model.expectShape(memberShape.getTarget());
switch (payloadTarget.getType()) {
case STRUCTURE:
case UNION:
messageSerDelegator.writeSerPayloadDelegation(context, payloadTarget,
"v." + symbolProvider.toMemberName(memberShape));
break;
case STRING:
GoValueAccessUtils.writeIfNonZeroValueMember(model, symbolProvider, writer,
memberShape, "v", operand -> {
writer.write("msg.Headers.Set($T, $T(\"text/plain\"))",
contentTypeHeader, stringValue);
writer.write("msg.Payload = []byte($L)", operand);
});
writer.write("return nil");
break;
case BLOB:
GoValueAccessUtils.writeIfNonZeroValueMember(model, symbolProvider, writer,
memberShape, "v", operand -> {
writer.write("msg.Headers.Set($T, $T(\"application/octet-stream\"))",
contentTypeHeader, stringValue);
writer.write("msg.Payload = $L", operand);
});
writer.write("return nil");
break;
default:
throw new CodegenException("unexpected event payload shape: "
+ payloadTarget.getType());
}
} else {
writer.write("return nil");
}
} else {
messageSerDelegator.writeSerPayloadDelegation(context, targetShape, "v");
}
}).write("");
}
public static void generateEventStreamDeserializer(GenerationContext context, UnionShape eventUnion) {
var writer = context.getWriter().get();
var symbolProvider = context.getSymbolProvider();
var serviceShape = context.getService();
var eventUnionSymbol = symbolProvider.toSymbol(eventUnion);
var model = context.getModel();
var deserializerName = getEventStreamDeserializerName(eventUnion,
serviceShape, context.getProtocolName());
writer.openBlock("func $L(v *$T, msg $P) error {", "}", deserializerName, eventUnionSymbol,
getEventStreamSymbol("Message"), () -> {
var errof = getSymbol("Errorf", SmithyGoDependency.FMT, false);
var eventTypeHeader = getEventStreamApiSymbol("EventTypeHeader", false);
var equalFold = SymbolUtils.createValueSymbolBuilder("EqualFold",
SmithyGoDependency.STRINGS).build();
writer.write("""
if v == nil {
return $T("unexpected serialization of nil %T", v)
}
""", errof)
.write("")
.write("""
eventType := msg.Headers.Get($T)
if eventType == nil {
return $T("%s event header not present", $T)
}
""", eventTypeHeader, errof, eventTypeHeader).write("")
.openBlock("switch {", "}", () -> {
var members = eventUnion.members().stream()
.filter(ms -> ms.getMemberTrait(model, ErrorTrait.class).isEmpty())
.collect(Collectors.toCollection(TreeSet::new));
for (var member : members) {
writer.openBlock("case $T($S, eventType.String()):", "", equalFold,
member.getMemberName(), () -> {
var messageDeserializerName =
getEventStreamMessageDeserializerName(
model.expectShape(member.getTarget()), serviceShape,
context.getProtocolName());
var memberSymbol = SymbolUtils.createValueSymbolBuilder(
symbolProvider.toMemberName(member),
eventUnionSymbol.getNamespace())
.build();
writer.write("""
vv := &$T{}
if err := $L(&vv.Value, msg); err != nil {
return err
}
*v = vv
return nil
""", memberSymbol, messageDeserializerName);
});
}
var newBuffer = getSymbol("NewBuffer", SmithyGoDependency.BYTES);
var newEncoder = getEventStreamSymbol("NewEncoder");
writer.write("""
default:
buffer := $T(nil)
$T().Encode(buffer, *msg)
*v = &$T{
Tag: eventType.String(),
Value: buffer.Bytes(),
}
return nil
""", newBuffer, newEncoder, SymbolUtils.
createValueSymbolBuilder("UnknownUnionMember",
eventUnionSymbol.getNamespace()).build());
});
}).write("");
}
public static void generateEventStreamExceptionDeserializer(
GenerationContext context,
UnionShape eventUnion,
UnknownExceptionDeserDelegator unknownExceptionDeserDelegator
) {
var writer = context.getWriter().get();
var model = context.getModel();
var serviceShape = context.getService();
var protocolName = context.getProtocolName();
var deserializerName = getEventStreamExceptionDeserializerName(eventUnion, serviceShape,
protocolName);
var errorf = getSymbol("Errorf", SmithyGoDependency.FMT, false);
var exceptionTypeHeader = getEventStreamApiSymbol("ExceptionTypeHeader", false);
var equalFold = SymbolUtils.createValueSymbolBuilder("EqualFold", SmithyGoDependency.STRINGS).build();
writer.openBlock("func $L(msg $P) error {", "}", deserializerName, getEventStreamSymbol("Message"), () -> {
writer.write("""
exceptionType := msg.Headers.Get($T)
if exceptionType == nil {
return $T("%s event header not present", $T)
}
""", exceptionTypeHeader, errorf, exceptionTypeHeader).write("");
var errorMemberShapes = eventUnion.members().stream()
.filter(ms -> ms.getMemberTrait(model, ErrorTrait.class).isPresent())
.collect(Collectors.toCollection(TreeSet::new));
writer.openBlock("switch {", "}", () -> {
for (MemberShape memberShape : errorMemberShapes) {
writer.openBlock("case $T($S, exceptionType.String()):", "", equalFold,
memberShape.getMemberName(), () -> {
writer.write("return $L(msg)",
getEventMessageExceptionDeserializerName(memberShape.getTarget(),
serviceShape, protocolName));
});
}
writer.openBlock("default:", "", () -> {
unknownExceptionDeserDelegator.writeUnknownExceptionDelegator(context);
});
});
}).write("");
}
private static String getEventMessageExceptionDeserializerName(
ToShapeId toShapeId,
ServiceShape serviceShape,
String protocolName
) {
return getSerDeName(toShapeId, serviceShape, protocolName, "_deserializeEventMessageException");
}
private static String getEventStreamExceptionDeserializerName(
ToShapeId toShapeId,
ServiceShape serviceShape,
String protocolName
) {
return getSerDeName(toShapeId, serviceShape, protocolName, "_deserializeEventStreamException");
}
private static String getEventStreamMessageDeserializerName(
ToShapeId toShapeId,
ServiceShape serviceShape,
String protocolName
) {
return getSerDeName(toShapeId, serviceShape, protocolName, "_deserializeEventMessage");
}
private static String getEventStreamDeserializerName(
ToShapeId toShapeId,
ServiceShape serviceShape,
String protocolName
) {
return getSerDeName(toShapeId, serviceShape, protocolName, "_deserializeEventStream");
}
public static void generateEventMessageDeserializer(
GenerationContext context,
Shape targetShape,
MessageDeserDelegator messageDeserDelegator
) {
var writer = context.getWriter().get();
var model = context.getModel();
var serviceShape = context.getService();
var deserializerName = getEventStreamMessageDeserializerName(targetShape, serviceShape,
context.getProtocolName());
var errorf = getSymbol("Errorf", SmithyGoDependency.FMT, false);
var pointableIndex = GoPointableIndex.of(model);
var symbolProvider = context.getSymbolProvider();
writer.openBlock("func $L(v $P, msg $P) error {", "}", deserializerName, symbolProvider.toSymbol(targetShape),
getEventStreamSymbol("Message"), () -> {
writer.write("""
if v == nil {
return $T("unexpected serialization of nil %T", v)
}
""", errorf).write("");
var headerBindings = targetShape.members().stream()
.filter(memberShape -> memberShape.hasTrait(EventHeaderTrait.class))
.collect(Collectors.toSet());
var payloadBinding = targetShape.members().stream()
.filter(memberShape -> memberShape.hasTrait(EventPayloadTrait.class))
.reduce((memberShape, memberShape2) -> {
throw new CodegenException("expect only one EventPayloadTrait targetShape");
});
if (!headerBindings.isEmpty() || payloadBinding.isPresent()) {
for (var headerBinding : headerBindings) {
var dest = String.format("v.%s",
symbolProvider.toMemberName(headerBinding));
new HeaderShapeDeserVisitor(writer, model, headerBinding, dest,
headerBinding.getMemberName(), "msg.Headers").writeDeserializer();
}
if (payloadBinding.isPresent()) {
var memberShape = payloadBinding.get();
var payloadTarget = model.expectShape(memberShape.getTarget());
switch (payloadTarget.getType()) {
case STRUCTURE:
case UNION:
messageDeserDelegator.writeDeserPayloadDelegation(context, payloadTarget,
"v." + symbolProvider.toMemberName(memberShape));
break;
case STRING:
writer.openBlock("if msg.Payload != nil {", "}", () -> {
var pointable = CodegenUtils.getAsPointerIfPointable(model, writer,
pointableIndex, memberShape, "string(msg.Payload)");
writer.write("$L = $L", String.format("v.%s",
symbolProvider.toMemberName(memberShape)), pointable);
});
writer.write("return nil");
break;
case BLOB:
writer.openBlock("if msg.Payload != nil {", "}", () -> {
writer.write("""
bsv := make([]byte, len(msg.Payload))
copy(bsv, msg.Payload)
""");
var pointable = CodegenUtils.getAsPointerIfPointable(model, writer,
pointableIndex, memberShape, "bsv");
writer.write("$L = $L", String.format("v.%s",
symbolProvider.toMemberName(memberShape)), pointable);
});
writer.write("return nil");
break;
default:
throw new CodegenException("unexpected event payload shape: "
+ payloadTarget.getType());
}
} else {
writer.write("return nil");
}
} else {
messageDeserDelegator.writeDeserPayloadDelegation(context, targetShape, "v");
}
}).write("");
}
public static void generateEventMessageExceptionDeserializer(
GenerationContext context,
Shape exceptionShape,
ExceptionDeserDelegator exceptionDeserDelegator
) {
var writer = context.getWriter().get();
var serviceShape = context.getService();
var protocolName = context.getProtocolName();
var deserializerName = getEventMessageExceptionDeserializerName(exceptionShape, serviceShape,
protocolName);
writer.openBlock("func $L(msg $P) error {", "}", deserializerName, getEventStreamSymbol("Message"), () -> {
exceptionDeserDelegator.writeDeserExceptionDelegator(context, exceptionShape);
}).write("");
}
private static String getEventStreamSerializerName(
ToShapeId toShapeId,
ServiceShape serviceShape,
String protocolName
) {
return getSerDeName(toShapeId, serviceShape, protocolName, "_serializeEventStream");
}
private static String getEventStreamMessageSerializerName(
ToShapeId toShapeId,
ServiceShape serviceShape,
String protocolName
) {
return getSerDeName(toShapeId, serviceShape, protocolName, "_serializeEventMessage");
}
private static String getEventStreamWriterImplConstructorName(
UnionShape unionShape, ServiceShape
serviceShape
) {
return "new" + StringUtils.capitalize(getEventStreamWriterImplName(unionShape, serviceShape));
}
private static String getEventStreamReaderImplConstructorName(
UnionShape unionShape, ServiceShape
serviceShape
) {
return "new" + StringUtils.capitalize(getEventStreamReaderImplName(unionShape, serviceShape));
}
private static void generateAsyncWriteReporter(GoWriter writer, Symbol eventSymbol, Symbol asyncEventSymbol) {
writer.openBlock("type $T struct {", "}", asyncEventSymbol, () -> {
writer.write("Event $T", eventSymbol);
writer.write("Result chan<- error");
}).write("");
writer.openBlock("func (e $T) ReportResult(cancel <-chan struct{}, err error) bool {", "}", asyncEventSymbol,
() -> writer.openBlock("select {", "}", () -> writer
.openBlock("case e.Result <- err:", "", () -> writer.write("return true"))
.openBlock("case <-cancel:", "", () -> writer.write("return false"))
)).write("");
}
public static String getAsyncWriteReporterName(Shape shape, ServiceShape serviceShape) {
var name = shape.getId().getName(serviceShape);
return "async" + StringUtils.capitalize(name);
}
public static String getEventStreamWriterImplName(Shape shape, ServiceShape serviceShape) {
var name = shape.getId().getName(serviceShape);
return StringUtils.uncapitalize(name) + "Writer";
}
public static String getEventStreamReaderImplName(Shape shape, ServiceShape serviceShape) {
var name = shape.getId().getName(serviceShape);
return StringUtils.uncapitalize(name) + "Reader";
}
private static Symbol getEventStreamSymbol(String name) {
return getEventStreamSymbol(name, true);
}
private static Symbol getEventStreamSymbol(String name, boolean pointable) {
return getSymbol(name, AwsGoDependency.SERVICE_INTERNAL_EVENTSTREAM, pointable);
}
private static Symbol getEventStreamApiSymbol(String name) {
return getEventStreamApiSymbol(name, true);
}
private static Symbol getEventStreamApiSymbol(String name, boolean pointable) {
return getSymbol(name, AwsGoDependency.SERVICE_INTERNAL_EVENTSTREAMAPI, pointable);
}
private static Symbol getSymbol(String name, GoDependency dependency) {
return getSymbol(name, dependency, true);
}
private static Symbol getSymbol(String name, GoDependency dependency, boolean pointable) {
if (pointable) {
return SymbolUtils.createPointableSymbolBuilder(name, dependency).build();
}
return SymbolUtils.createValueSymbolBuilder(name, dependency).build();
}
private static Symbol getModuleSymbol(GoSettings settings, String name) {
return getModuleSymbol(settings, name, true);
}
private static Symbol getModuleSymbol(GoSettings settings, String name, boolean pointable) {
if (pointable) {
return SymbolUtils.createPointableSymbolBuilder(name, settings.getModuleName()).build();
}
return SymbolUtils.createValueSymbolBuilder(name, settings.getModuleName()).build();
}
public static void generateEventMessageRequestSerializer(
GenerationContext context,
Shape inputShape,
MessageSerDelegator messageSerDelegator
) {
var writer = context.getWriter().get();
var model = context.getModel();
var serviceShape = context.getService();
var serializerName = getEventStreamMessageRequestSerializerName(inputShape, serviceShape,
context.getProtocolName());
var errorf = getSymbol("Errorf", SmithyGoDependency.FMT, false);
var messageTypeHeader = getEventStreamApiSymbol("MessageTypeHeader");
var stringValue = getEventStreamSymbol("StringValue", false);
var eventMessageType = getEventStreamApiSymbol("EventMessageType", false);
var eventTypeHeader = getEventStreamApiSymbol("EventTypeHeader", false);
var symbolProvider = context.getSymbolProvider();
writer.openBlock("func $L(i interface{}, msg $P) error {", "}", serializerName, getEventStreamSymbol("Message"),
() -> {
var inputSymbol = symbolProvider.toSymbol(inputShape);
writer.write("""
if i == nil {
return $T("event message serializer expects non-nil %T", ($P)(nil))
}
v, ok := i.($P)
if !ok {
return $T("unexpected serialization of %T", i)
}
""", errorf, inputSymbol, inputSymbol, errorf).write("")
.write("""
msg.Headers.Set($T, $T($T))
msg.Headers.Set($T, $T($S))
""",
messageTypeHeader, stringValue, eventMessageType,
eventTypeHeader, stringValue, "initial-request"
).write("");
messageSerDelegator.writeSerPayloadDelegation(context, inputShape, "v");
}).write("");
}
public static void generateEventMessageRequestDeserializer(
GenerationContext context,
Shape inputShape,
MessageSerDelegator messageSerDelegator
) {
var writer = context.getWriter().get();
var model = context.getModel();
var serviceShape = context.getService();
var serializerName = getEventStreamMessageResponseDeserializerName(inputShape, serviceShape,
context.getProtocolName());
var errorf = getSymbol("Errorf", SmithyGoDependency.FMT, false);
var symbolProvider = context.getSymbolProvider();
writer.openBlock("func $L(msg $P) (interface{}, error) {", "}", serializerName, getEventStreamSymbol("Message"),
() -> {
var inputSymbol = symbolProvider.toSymbol(inputShape);
writer.write("v := &$T{}", inputSymbol).write("");
messageSerDelegator.writeSerPayloadDelegation(context, inputShape, "v");
}).write("");
}
private static String getEventStreamMessageRequestSerializerName(
ToShapeId toShapeId,
ServiceShape serviceShape,
String protocolName
) {
return getSerDeName(toShapeId, serviceShape, protocolName, "_serializeEventMessageRequest");
}
private static String getEventStreamMessageResponseDeserializerName(
ToShapeId toShapeId, ServiceShape serviceShape, String protocolName
) {
return getSerDeName(toShapeId, serviceShape, protocolName, "_deserializeEventMessageResponse");
}
private static String getSerDeName(
ToShapeId toShapeId, ServiceShape serviceShape, String protocolName, String name
) {
return StringUtils.uncapitalize(protocolName) + name
+ toShapeId.toShapeId().getName(serviceShape);
}
public static void writeOperationSerializerMiddlewareEventStreamSetup(
GenerationContext context,
EventStreamInfo info,
String encoderIdentifier
) {
context.getWriter().get()
.write("$L.SetHeader(\"Content-Type\").String($S)", encoderIdentifier,
"application/vnd.amazon.eventstream")
.write("");
}
interface MessageSerDelegator {
void writeSerPayloadDelegation(GenerationContext context, Shape payloadTarget, String operand);
}
interface MessageDeserDelegator {
void writeDeserPayloadDelegation(GenerationContext context, Shape payloadTarget, String operand);
}
interface ExceptionDeserDelegator {
void writeDeserExceptionDelegator(GenerationContext context, Shape payloadTarget);
}
interface UnknownExceptionDeserDelegator {
void writeUnknownExceptionDelegator(GenerationContext context);
}
private static class HeaderShapeSerVisitor extends ShapeVisitor.Default<Void> {
private final GoWriter writer;
private final Model model;
private final MemberShape memberShape;
private final String target;
private final String headerName;
private final String dataSource;
private final GoPointableIndex pointableIndex;
public HeaderShapeSerVisitor(
GoWriter writer,
Model model,
MemberShape memberShape,
String target,
String headerName,
String dataSource
) {
this.writer = writer;
this.model = model;
this.memberShape = memberShape;
this.target = target;
this.headerName = headerName;
this.dataSource = dataSource;
this.pointableIndex = GoPointableIndex.of(this.model);
}
@Override
public Void blobShape(BlobShape shape) {
writeSetter("BytesValue");
return null;
}
@Override
public Void booleanShape(BooleanShape shape) {
writeSetter("BoolValue");
return null;
}
@Override
public Void byteShape(ByteShape shape) {
writeSetter("Int8Value");
return null;
}
@Override
public Void shortShape(ShortShape shape) {
writeSetter("Int16Value");
return null;
}
@Override
public Void integerShape(IntegerShape shape) {
writeSetter("Int32Value");
return null;
}
@Override
public Void longShape(LongShape shape) {
writeSetter("Int64Value");
return null;
}
@Override
public Void stringShape(StringShape shape) {
writeSetter("StringValue");
return null;
}
@Override
public Void timestampShape(TimestampShape shape) {
writeSetter("TimestampValue");
return null;
}
@Override
protected Void getDefault(Shape shape) {
throw new CodegenException("unsupported event stream header shape: " + shape.getType().toString());
}
private void writeSetter(String valueTypeSymbolName) {
var ds = CodegenUtils.getAsValueIfDereferencable(pointableIndex, memberShape, dataSource);
writer.write("$L.Headers.Set($S, $T($L))", target, headerName,
getEventStreamSymbol(valueTypeSymbolName, false), ds);
}
public void writeHeaderSerializer() {
GoValueAccessUtils.writeIfNonZeroValue(model, writer, memberShape, dataSource,
() -> model.expectShape(memberShape.getTarget()).accept(this));
}
}
private static class HeaderShapeDeserVisitor extends ShapeVisitor.Default<Void> {
private final GoWriter writer;
private final Model model;
private final MemberShape memberShape;
private final String dest;
private final String headerName;
private final String dataSource;
private final GoPointableIndex pointableIndex;
public HeaderShapeDeserVisitor(
GoWriter writer,
Model model,
MemberShape memberShape,
String dest,
String headerName,
String dataSource
) {
this.writer = writer;
this.model = model;
this.memberShape = memberShape;
this.dest = dest;
this.headerName = headerName;
this.dataSource = dataSource;
this.pointableIndex = GoPointableIndex.of(this.model);
}
@Override
public Void blobShape(BlobShape shape) {
var sliceSymbol = SymbolUtils.createValueSymbolBuilder("[]byte")
.putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true).build();
writeTypeDeserializer(getEventStreamSymbol("BytesValue", false), sliceSymbol);
return null;
}
@Override
public Void booleanShape(BooleanShape shape) {
var boolSymbol = SymbolUtils.createValueSymbolBuilder("bool")
.putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true).build();
writeTypeDeserializer(getEventStreamSymbol("BoolValue"), boolSymbol);
return null;
}
@Override
public Void byteShape(ByteShape shape) {
var int8Symbol = SymbolUtils.createValueSymbolBuilder("int8")
.putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true).build();
writeTypeDeserializer(getEventStreamSymbol("Int8Value"), int8Symbol);
return null;
}
@Override
public Void shortShape(ShortShape shape) {
var int16Symbol = SymbolUtils.createValueSymbolBuilder("int16")
.putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true).build();
writeTypeDeserializer(getEventStreamSymbol("Int16Value"), int16Symbol);
return null;
}
@Override
public Void integerShape(IntegerShape shape) {
var int32Symbol = SymbolUtils.createValueSymbolBuilder("int32")
.putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true).build();
writeTypeDeserializer(getEventStreamSymbol("Int32Value"), int32Symbol);
return null;
}
@Override
public Void longShape(LongShape shape) {
var int64Symbol = SymbolUtils.createValueSymbolBuilder("int64")
.putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true).build();
writeTypeDeserializer(getEventStreamSymbol("Int64Value"), int64Symbol);
return null;
}
@Override
public Void stringShape(StringShape shape) {
var stringSymbol = SymbolUtils.createValueSymbolBuilder("string")
.putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true).build();
writeTypeDeserializer(getEventStreamSymbol("StringValue"), stringSymbol);
return null;
}
@Override
public Void timestampShape(TimestampShape shape) {
var timeSymbol = SymbolUtils.createValueSymbolBuilder("Time", SmithyGoDependency.TIME).build();
writeTypeDeserializer(getEventStreamSymbol("TimestampValue"), timeSymbol);
return null;
}
@Override
protected Void getDefault(Shape shape) {
throw new CodegenException("unsupported event stream header shape: " + shape.getType().toString());
}
private void writeTypeDeserializer(Symbol apiHeaderType, Symbol concreteType) {
writeTypeDeserializer(apiHeaderType, concreteType, () -> {
var pointable = CodegenUtils.getAsPointerIfPointable(model, writer, pointableIndex, memberShape,
"ihv");
writer.write("$L = $L", dest, pointable);
});
}
private void writeTypeDeserializer(Symbol apiHeaderType, Symbol concreteType, Runnable setter) {
writer.openBlock("{", "}", () -> {
var errorf = SymbolUtils.createValueSymbolBuilder("Errorf", SmithyGoDependency.FMT).build();
writer.write("headerValue := $L.Get($S)", dataSource, headerName)
.openBlock("if headerValue != nil {", "}", () -> {
writer.write("hv, ok := headerValue.($P)", apiHeaderType)
.write("""
if !ok {
return $T("unexpected event header %s with type %T:", $S, headerValue)
}
""", errorf, headerName).write("")
.write("ihv := hv.Get().($P)", concreteType);
setter.run();
});
}).write("");
}
public void writeDeserializer() {
model.expectShape(memberShape.getTarget()).accept(this);
}
}
}
| 8,333 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsEndpointAuthSchemeGenerator.java | /*
* Copyright 2023 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.aws.go.codegen;
import java.util.Optional;
import software.amazon.smithy.aws.go.codegen.customization.AwsCustomGoDependency;
import software.amazon.smithy.aws.traits.ServiceTrait;
import software.amazon.smithy.aws.traits.auth.SigV4Trait;
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.GoIntegration;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
/**
* Used by integrations to generate an AWS
* authentication scheme resolution.
*
*/
public class AwsEndpointAuthSchemeGenerator implements GoIntegration {
@Override
public void renderPostEndpointResolutionHook(
GoSettings settings, GoWriter writer, Model model, Optional<OperationShape> operation
) {
ServiceShape serviceShape = settings.getService(model);
writer.write(
"""
$W
for _, authScheme := range authSchemes {
switch authScheme.(type) {
case $P:
$W
break
case $P:
$W
break
case $P:
break
}
}
""",
generateAuthSchemeDetection(serviceShape),
SymbolUtils.createPointableSymbolBuilder("AuthenticationSchemeV4", AwsGoDependency.INTERNAL_AUTH).build(),
generateSigV4Resolution(serviceShape),
SymbolUtils.createPointableSymbolBuilder("AuthenticationSchemeV4A", AwsGoDependency.INTERNAL_AUTH).build(),
generateSigV4AResolution(serviceShape),
SymbolUtils.createPointableSymbolBuilder("AuthenticationSchemeNone", AwsGoDependency.INTERNAL_AUTH).build()
);
}
private GoWriter.Writable generateAuthSchemeDetection(ServiceShape serviceShape) {
GoWriter.Writable signerVersion = (GoWriter writer) -> {
String serviceId = serviceShape.expectTrait(ServiceTrait.class).getSdkId();
if (serviceId.equalsIgnoreCase("S3")) {
writer.write(
"""
ctx = $T(ctx, $T)
""",
SymbolUtils.createValueSymbolBuilder("SetSignerVersion", AwsCustomGoDependency.S3_CUSTOMIZATION).build(),
SymbolUtils.createValueSymbolBuilder("SigV4", AwsGoDependency.INTERNAL_AUTH).build()
);
} else if (serviceId.equalsIgnoreCase("EventBridge")) {
writer.write(
"""
ctx = $T(ctx, $T)
""",
SymbolUtils.createValueSymbolBuilder("SetSignerVersion", AwsCustomGoDependency.EVENTBRIDGE_CUSTOMIZATION).build(),
SymbolUtils.createValueSymbolBuilder("SigV4", AwsGoDependency.INTERNAL_AUTH).build()
); } else {
writer.write("");
}
};
return (GoWriter writer) -> {
var signingNameDefaultOpt = getDefaultSigningName(serviceShape);
var signingNameDefault = signingNameDefaultOpt.isPresent() ? signingNameDefaultOpt.get() : "";
writer.write(
"""
authSchemes, err := $T(&resolvedEndpoint.Properties)
if err != nil {
var nfe $P
if $T(err, &nfe) {
// if no auth scheme is found, default to sigv4
signingName := \"$L\"
signingRegion := m.BuiltInResolver.(*$L).Region
ctx = $T(ctx, signingName)
ctx = $T(ctx, signingRegion)
$W
}
var ue $P
if errors.As(err, &ue) {
return out, metadata, $T(
\"This operation requests signer version(s) %v but the client only supports %v\",
ue.UnsupportedSchemes,
$T,
)
}
}
""",
SymbolUtils.createValueSymbolBuilder("GetAuthenticationSchemes", AwsGoDependency.INTERNAL_AUTH).build(),
SymbolUtils.createPointableSymbolBuilder("NoAuthenticationSchemesFoundError", AwsGoDependency.INTERNAL_AUTH).build(),
SymbolUtils.createValueSymbolBuilder("As", SmithyGoDependency.ERRORS).build(),
signingNameDefault,
AwsEndpointResolverBuiltInGenerator.BUILTIN_RESOLVER_IMPLEMENTATION_TYPE,
SymbolUtils.createValueSymbolBuilder("SetSigningName", AwsGoDependency.AWS_MIDDLEWARE).build(),
SymbolUtils.createValueSymbolBuilder("SetSigningRegion", AwsGoDependency.AWS_MIDDLEWARE).build(),
signerVersion,
SymbolUtils.createPointableSymbolBuilder("UnSupportedAuthenticationSchemeSpecifiedError", AwsGoDependency.INTERNAL_AUTH).build(),
SymbolUtils.createValueSymbolBuilder("Errorf", SmithyGoDependency.FMT).build(),
SymbolUtils.createValueSymbolBuilder("SupportedSchemes", AwsGoDependency.INTERNAL_AUTH).build()
);
};
}
private GoWriter.Writable generateSigV4Resolution(ServiceShape serviceShape) {
GoWriter.Writable signerVersion = (GoWriter writer) -> {
String serviceId = serviceShape.expectTrait(ServiceTrait.class).getSdkId();
if (serviceId.equalsIgnoreCase("S3")) {
writer.write(
"""
ctx = $T(ctx, v4Scheme.Name)
""",
SymbolUtils.createValueSymbolBuilder("SetSignerVersion", AwsCustomGoDependency.S3_CUSTOMIZATION).build()
);
} else if (serviceId.equalsIgnoreCase("EventBridge")) {
writer.write(
"""
ctx = $T(ctx, v4Scheme.Name)
""",
SymbolUtils.createValueSymbolBuilder("SetSignerVersion", AwsCustomGoDependency.EVENTBRIDGE_CUSTOMIZATION).build()
); } else {
writer.write("");
}
};
return (GoWriter writer) -> {
var signingNameDefaultOpt = getDefaultSigningName(serviceShape);
var signingNameDefault = signingNameDefaultOpt.isPresent() ? signingNameDefaultOpt.get() : "";
writer.write(
"""
v4Scheme, _ := authScheme.($P)
var signingName, signingRegion string
if v4Scheme.SigningName == nil {
signingName = \"$L\"
} else {
signingName = *v4Scheme.SigningName
}
if v4Scheme.SigningRegion == nil {
signingRegion = m.BuiltInResolver.(*$L).Region
} else {
signingRegion = *v4Scheme.SigningRegion
}
if v4Scheme.DisableDoubleEncoding != nil {
// The signer sets an equivalent value at client initialization time.
// Setting this context value will cause the signer to extract it
// and override the value set at client initialization time.
ctx = $T(ctx, *v4Scheme.DisableDoubleEncoding)
}
ctx = $T(ctx, signingName)
ctx = $T(ctx, signingRegion)
$W
""",
SymbolUtils.createPointableSymbolBuilder("AuthenticationSchemeV4", AwsGoDependency.INTERNAL_AUTH).build(),
signingNameDefault,
AwsEndpointResolverBuiltInGenerator.BUILTIN_RESOLVER_IMPLEMENTATION_TYPE,
SymbolUtils.createValueSymbolBuilder("SetDisableDoubleEncoding", AwsGoDependency.INTERNAL_AUTH).build(),
SymbolUtils.createValueSymbolBuilder("SetSigningName", AwsGoDependency.AWS_MIDDLEWARE).build(),
SymbolUtils.createValueSymbolBuilder("SetSigningRegion", AwsGoDependency.AWS_MIDDLEWARE).build(),
signerVersion
);
};
}
private GoWriter.Writable generateSigV4AResolution(ServiceShape serviceShape) {
GoWriter.Writable signerVersion = (GoWriter writer) -> {
String serviceId = serviceShape.expectTrait(ServiceTrait.class).getSdkId();
if (serviceId.equalsIgnoreCase("S3")) {
writer.write(
"""
ctx = $T(ctx, $T)
""",
SymbolUtils.createValueSymbolBuilder("SetSignerVersion", AwsCustomGoDependency.S3_CUSTOMIZATION).build(),
SymbolUtils.createValueSymbolBuilder("Version", AwsGoDependency.INTERNAL_SIGV4A).build()
);
} else if (serviceId.equalsIgnoreCase("EventBridge")) {
writer.write(
"""
ctx = $T(ctx, $T)
""",
SymbolUtils.createValueSymbolBuilder("SetSignerVersion", AwsCustomGoDependency.EVENTBRIDGE_CUSTOMIZATION).build(),
SymbolUtils.createValueSymbolBuilder("Version", AwsGoDependency.INTERNAL_SIGV4A).build()
);
} else {
writer.write("");
}
};
return (GoWriter writer) -> {
var signingNameDefaultOpt = getDefaultSigningName(serviceShape);
var signingNameDefault = signingNameDefaultOpt.isPresent() ? signingNameDefaultOpt.get() : "";
writer.write(
"""
v4aScheme, _ := authScheme.($P)
if v4aScheme.SigningName == nil {
v4aScheme.SigningName = $T(\"$L\")
}
if v4aScheme.DisableDoubleEncoding != nil {
// The signer sets an equivalent value at client initialization time.
// Setting this context value will cause the signer to extract it
// and override the value set at client initialization time.
ctx = $T(ctx, *v4aScheme.DisableDoubleEncoding)
}
ctx = $T(ctx, *v4aScheme.SigningName)
ctx = $T(ctx, v4aScheme.SigningRegionSet[0])
$W
""",
SymbolUtils.createPointableSymbolBuilder("AuthenticationSchemeV4A", AwsGoDependency.INTERNAL_AUTH).build(),
SymbolUtils.createValueSymbolBuilder("String", AwsGoDependency.AWS_CORE).build(),
SymbolUtils.createValueSymbolBuilder(signingNameDefault).build(),
SymbolUtils.createValueSymbolBuilder("SetDisableDoubleEncoding", AwsGoDependency.INTERNAL_AUTH).build(),
SymbolUtils.createValueSymbolBuilder("SetSigningName", AwsGoDependency.AWS_MIDDLEWARE).build(),
SymbolUtils.createValueSymbolBuilder("SetSigningRegion", AwsGoDependency.AWS_MIDDLEWARE).build(),
signerVersion
);
};
}
private Optional<String> getDefaultSigningName(ServiceShape serviceShape) {
var sigV4TraitOpt = serviceShape.getTrait(SigV4Trait.class);
String signingNameDefault = "";
if (sigV4TraitOpt.isPresent()) {
signingNameDefault = sigV4TraitOpt.get().getName();
return Optional.of(signingNameDefault);
}
return Optional.empty();
}
}
| 8,334 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/JsonProtocolDocumentUtils.java | package software.amazon.smithy.aws.go.codegen;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.go.codegen.GoWriter;
import software.amazon.smithy.go.codegen.ProtocolDocumentGenerator;
import software.amazon.smithy.go.codegen.SmithyGoDependency;
import software.amazon.smithy.go.codegen.SymbolUtils;
import software.amazon.smithy.go.codegen.integration.ProtocolGenerator;
public final class JsonProtocolDocumentUtils {
public static void generateProtocolDocumentMarshalerUnmarshalDocument(ProtocolGenerator.GenerationContext context) {
GoWriter writer = context.getWriter().get();
writer.write("mBytes, err := m.$L()", ProtocolDocumentGenerator.MARSHAL_SMITHY_DOCUMENT_METHOD);
writer.write("if err != nil { return err }").write("");
writer.write("jDecoder := $T($T(mBytes))", SymbolUtils.createValueSymbolBuilder("NewDecoder",
SmithyGoDependency.JSON).build(), SymbolUtils.createValueSymbolBuilder("NewReader",
SmithyGoDependency.BYTES).build());
writer.write("jDecoder.UseNumber()").write("");
writer.write("var jv interface{}");
writer.openBlock("if err := jDecoder.Decode(&v); err != nil {", "}", () -> writer.write("return err"))
.write("");
Symbol newUnmarshaler = ProtocolDocumentGenerator.Utilities.getInternalDocumentSymbolBuilder(
context.getSettings(), ProtocolDocumentGenerator.INTERNAL_NEW_DOCUMENT_UNMARSHALER_FUNC)
.build();
writer.write("return $T(v).$L(&jv)", newUnmarshaler,
ProtocolDocumentGenerator.UNMARSHAL_SMITHY_DOCUMENT_METHOD);
}
public static void generateProtocolDocumentMarshalerMarshalDocument(ProtocolGenerator.GenerationContext context) {
GoWriter writer = context.getWriter().get();
Symbol newEncoder = SymbolUtils.createValueSymbolBuilder("NewEncoder", SmithyGoDependency.SMITHY_DOCUMENT_JSON)
.build();
writer.write("return $T().Encode(m.value)", newEncoder);
}
public static void generateProtocolDocumentUnmarshalerUnmarshalDocument(
ProtocolGenerator.GenerationContext context
) {
GoWriter writer = context.getWriter().get();
Symbol newDecoder = SymbolUtils.createValueSymbolBuilder("NewDecoder", SmithyGoDependency.SMITHY_DOCUMENT_JSON)
.build();
writer.write("decoder := $T()", newDecoder);
writer.write("return decoder.DecodeJSONInterface(m.value, v)");
}
public static void generateProtocolDocumentUnmarshalerMarshalDocument(
ProtocolGenerator.GenerationContext context
) {
GoWriter writer = context.getWriter().get();
writer.write("return $T(m.value)",
SymbolUtils.createValueSymbolBuilder("Marshal", SmithyGoDependency.JSON).build());
}
}
| 8,335 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/XmlShapeSerVisitor.java | package software.amazon.smithy.aws.go.codegen;
import java.util.Collections;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.function.Predicate;
import java.util.logging.Logger;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.go.codegen.GoValueAccessUtils;
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.DocumentShapeSerVisitor;
import software.amazon.smithy.go.codegen.integration.ProtocolGenerator.GenerationContext;
import software.amazon.smithy.go.codegen.trait.NoSerializeTrait;
import software.amazon.smithy.model.shapes.CollectionShape;
import software.amazon.smithy.model.shapes.DocumentShape;
import software.amazon.smithy.model.shapes.MapShape;
import software.amazon.smithy.model.shapes.MemberShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.model.shapes.UnionShape;
import software.amazon.smithy.model.traits.TimestampFormatTrait;
import software.amazon.smithy.model.traits.XmlFlattenedTrait;
import software.amazon.smithy.model.traits.XmlNameTrait;
import software.amazon.smithy.model.traits.XmlNamespaceTrait;
import software.amazon.smithy.utils.FunctionalUtils;
final class XmlShapeSerVisitor extends DocumentShapeSerVisitor {
private static final TimestampFormatTrait.Format DEFAULT_TIMESTAMP_FORMAT = TimestampFormatTrait.Format.DATE_TIME;
private static final Logger LOGGER = Logger.getLogger(XmlShapeSerVisitor.class.getName());
private final Predicate<MemberShape> memberFilter;
public XmlShapeSerVisitor(GenerationContext context) {
this(context, NoSerializeTrait.excludeNoSerializeMembers().and(FunctionalUtils.alwaysTrue()));
}
public XmlShapeSerVisitor(GenerationContext context, Predicate<MemberShape> memberFilter) {
super(context);
this.memberFilter = NoSerializeTrait.excludeNoSerializeMembers().and(memberFilter);
}
private DocumentMemberSerVisitor getMemberSerVisitor(MemberShape member, String source, String dest) {
// Get the timestamp format to be used, defaulting to date-time format.
TimestampFormatTrait.Format format = member.getMemberTrait(getContext().getModel(), TimestampFormatTrait.class)
.map(TimestampFormatTrait::getFormat).orElse(DEFAULT_TIMESTAMP_FORMAT);
return new DocumentMemberSerVisitor(getContext(), member, source, dest, format);
}
@Override
protected Map<String, String> getAdditionalSerArguments() {
return Collections.singletonMap("value", "smithyxml.Value");
}
@Override
protected void serializeCollection(GenerationContext context, CollectionShape shape) {
GoWriter writer = context.getWriter().get();
Shape target = context.getModel().expectShape(shape.getMember().getTarget());
MemberShape member = shape.getMember();
writer.write("var array *smithyxml.Array");
writer.openBlock("if !value.IsFlattened() {", "}", () -> {
writer.write("defer value.Close()");
});
if (member.hasTrait(XmlNameTrait.class) || member.hasTrait(XmlNamespaceTrait.class)) {
XmlProtocolUtils.generateXMLStartElement(context, member, "customMemberName", "v");
writer.write("array = value.ArrayWithCustomName(customMemberName)");
} else {
writer.write("array = value.Array()");
}
writer.insertTrailingNewline();
writer.openBlock("for i := range v {", "}", () -> {
// Serialize zero members as empty values.
GoValueAccessUtils.writeIfZeroValue(context.getModel(), writer, member, "v[i]", () -> {
writer.write("am := array.Member()");
writer.write("am.Close()");
writer.write("continue");
});
writer.write("am := array.Member()");
target.accept(getMemberSerVisitor(shape.getMember(), "v[i]", "am"));
});
writer.write("return nil");
}
@Override
protected void serializeMap(GenerationContext context, MapShape shape) {
GoWriter writer = context.getWriter().get();
Shape targetKey = context.getModel().expectShape(shape.getKey().getTarget());
Shape targetValue = context.getModel().expectShape(shape.getValue().getTarget());
writer.openBlock("if !value.IsFlattened() {", "}", () -> {
writer.write("defer value.Close()");
});
writer.write("m := value.Map()");
writer.insertTrailingNewline();
writer.openBlock("for key := range v {", "}", () -> {
writer.write("entry := m.Entry()");
writer.insertTrailingNewline();
// Serialize zero values as empty values.
GoValueAccessUtils.writeIfZeroValue(context.getModel(), writer, shape.getValue(), "v[key]", () -> {
writer.write("entry.Close()");
writer.write("continue");
});
// map entry key
XmlProtocolUtils.generateXMLStartElement(context, shape.getKey(), "keyElement", "v");
targetKey.accept(getMemberSerVisitor(shape.getKey(), "key", "entry.MemberElement(keyElement)"));
writer.insertTrailingNewline();
// map entry value
XmlProtocolUtils.generateXMLStartElement(context, shape.getValue(), "valueElement", "v");
String dest = "entry.MemberElement(valueElement)";
if (shape.getValue().hasTrait(XmlFlattenedTrait.class)) {
dest = "entry.FlattenedElement(valueElement)";
}
targetValue.accept(getMemberSerVisitor(shape.getValue(), "v[key]", dest));
// close the map entry
writer.write("entry.Close()");
writer.insertTrailingNewline();
});
writer.write("return nil");
}
@Override
protected void serializeStructure(GenerationContext context, StructureShape shape) {
GoWriter writer = context.getWriter().get();
// defer close xml.value
writer.write("defer value.Close()");
writer.insertTrailingNewline();
// Use a tree sort to sort the members.
Set<MemberShape> members = new TreeSet<>(shape.getAllMembers().values());
for (MemberShape member : members) {
if (!memberFilter.test(member)) {
continue;
}
Shape target = context.getModel().expectShape(member.getTarget());
writer.addUseImports(SmithyGoDependency.SMITHY_XML);
GoValueAccessUtils.writeIfNonZeroValueMember(context.getModel(), context.getSymbolProvider(), writer,
member, "v", true, member.isRequired(), (operand) -> {
XmlProtocolUtils.generateXMLStartElement(context, member, "root", "v");
// check if member shape has flattened trait
if (member.hasTrait(XmlFlattenedTrait.class)) {
writer.write("el := value.FlattenedElement($L)", "root");
} else {
writer.write("el := value.MemberElement($L)", "root");
}
target.accept(getMemberSerVisitor(member, operand, "el"));
});
writer.insertTrailingNewline();
}
writer.write("return nil");
}
@Override
protected void serializeUnion(GenerationContext context, UnionShape shape) {
GoWriter writer = context.getWriter().get();
SymbolProvider symbolProvider = context.getSymbolProvider();
Symbol symbol = symbolProvider.toSymbol(shape);
writer.addUseImports(SmithyGoDependency.FMT);
writer.write("defer value.Close()");
writer.insertTrailingNewline();
writer.openBlock("switch uv := v.(type) {", "}", () -> {
// Use a TreeSet to sort the members.
Set<MemberShape> members = new TreeSet<>(shape.getAllMembers().values());
for (MemberShape member : members) {
Shape target = context.getModel().expectShape(member.getTarget());
Symbol memberSymbol = SymbolUtils.createValueSymbolBuilder(
symbolProvider.toMemberName(member),
symbol.getNamespace()
).build();
writer.openBlock("case *$T:", "", memberSymbol, () -> {
XmlProtocolUtils.generateXMLStartElement(context, member, "customMemberName", "v");
writer.write("av := value.MemberElement(customMemberName)");
target.accept(getMemberSerVisitor(member, "uv.Value", "av"));
});
}
// Handle unknown union values
writer.openBlock("default:", "", () -> {
writer.write("return fmt.Errorf(\"attempted to serialize unknown member type %T"
+ " for union %T\", uv, v)");
});
});
writer.write("return nil");
}
@Override
protected void serializeDocument(GenerationContext context, DocumentShape shape) {
// TODO: implement document serialization
LOGGER.warning("Document type is currently unsupported for XML serialization.");
context.getWriter().get().writeDocs("TODO: implement document serialization.");
context.getWriter().get().write("return nil");
}
}
| 8,336 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/RegisterServiceMetadataMiddleware.java | package software.amazon.smithy.aws.go.codegen;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import software.amazon.smithy.aws.traits.auth.SigV4Trait;
import software.amazon.smithy.codegen.core.Symbol;
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.SymbolUtils;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.go.codegen.integration.MiddlewareRegistrar;
import software.amazon.smithy.go.codegen.integration.MiddlewareStackStep;
import software.amazon.smithy.go.codegen.integration.RuntimeClientPlugin;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.knowledge.ServiceIndex;
import software.amazon.smithy.model.knowledge.TopDownIndex;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.shapes.ToShapeId;
import software.amazon.smithy.model.traits.Trait;
import software.amazon.smithy.utils.ListUtils;
public final class RegisterServiceMetadataMiddleware implements GoIntegration {
List<RuntimeClientPlugin> runtimeClientPlugins = new ArrayList<>();
@Override
public byte getOrder() {
return 30;
}
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
ServiceShape service = settings.getService(model);
Symbol serviceMetadataProvider = SymbolUtils.createPointableSymbolBuilder(
"RegisterServiceMetadata", AwsGoDependency.AWS_MIDDLEWARE).build();
ServiceIndex serviceIndex = ServiceIndex.of(model);
TopDownIndex topDownIndex = TopDownIndex.of(model);
for (ToShapeId operation : topDownIndex.getContainedOperations(service)) {
String middlewareName = getServiceMetadataMiddlewareName(service, operation.toShapeId());
OperationShape operationShape = model.expectShape(operation.toShapeId(), OperationShape.class);
goDelegator.useShapeWriter(operationShape, writer -> {
writer.openBlock("func $L(region string) $P {", "}",
middlewareName, serviceMetadataProvider, () -> {
StringBuilder builder = new StringBuilder();
builder.append(" return &$T{\n");
builder.append("Region: region,\n");
builder.append("ServiceID: ServiceID,\n");
Map<ShapeId, Trait> authSchemes = serviceIndex.getEffectiveAuthSchemes(service, operationShape);
if (authSchemes.containsKey(SigV4Trait.ID)) {
SigV4Trait trait = (SigV4Trait) authSchemes.get(SigV4Trait.ID);
builder.append(String.format("SigningName: \"%s\",\n", trait.getName()));
}
builder.append(String.format("OperationName: \"%s\",\n",
operationShape.getId().getName(service)));
builder.append("}");
writer.write(builder.toString(), serviceMetadataProvider);
});
});
}
}
@Override
public void processFinalizedModel(GoSettings settings, Model model) {
ServiceShape service = settings.getService(model);
TopDownIndex index = TopDownIndex.of(model);
for (ToShapeId operation : index.getContainedOperations(service)) {
String middlewareName = getServiceMetadataMiddlewareName(service, operation.toShapeId());
OperationShape operationShape = model.expectShape(operation.toShapeId(), OperationShape.class);
RuntimeClientPlugin runtimeClientPlugin = RuntimeClientPlugin.builder()
.operationPredicate((m, s, o) -> {
if (!s.equals(service)) {
return false;
}
return operationShape.equals(o);
})
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(
middlewareName).build())
.registerBefore(MiddlewareStackStep.INITIALIZE)
.functionArguments(ListUtils.of(
SymbolUtils.createValueSymbolBuilder("options.Region").build()
))
.build())
.build();
runtimeClientPlugins.add(runtimeClientPlugin);
}
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return runtimeClientPlugins;
}
private String getServiceMetadataMiddlewareName(ServiceShape service, ShapeId operationID) {
return "newServiceMetadataMiddleware_op" + operationID.getName(service);
}
}
| 8,337 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/XmlShapeDeserVisitor.java | package software.amazon.smithy.aws.go.codegen;
import java.util.Collections;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.TreeSet;
import java.util.function.Predicate;
import java.util.logging.Logger;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.codegen.core.SymbolProvider;
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.UnionGenerator;
import software.amazon.smithy.go.codegen.integration.DocumentShapeDeserVisitor;
import software.amazon.smithy.go.codegen.integration.ProtocolGenerator;
import software.amazon.smithy.go.codegen.integration.ProtocolGenerator.GenerationContext;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.shapes.CollectionShape;
import software.amazon.smithy.model.shapes.DocumentShape;
import software.amazon.smithy.model.shapes.ListShape;
import software.amazon.smithy.model.shapes.MapShape;
import software.amazon.smithy.model.shapes.MemberShape;
import software.amazon.smithy.model.shapes.SetShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.SimpleShape;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.model.shapes.UnionShape;
import software.amazon.smithy.model.traits.EnumTrait;
import software.amazon.smithy.model.traits.TimestampFormatTrait;
import software.amazon.smithy.model.traits.XmlAttributeTrait;
import software.amazon.smithy.model.traits.XmlNameTrait;
import software.amazon.smithy.utils.FunctionalUtils;
/**
* Visitor to generate deserialization functions for shapes in XML protocol
* document bodies.
* <p>
* This class handles function body generation for all types expected by the
* {@code DocumentShapeDeserVisitor}. No other shape type serialization is overwritten.
* <p>
* Timestamps are serialized to {@link TimestampFormatTrait.Format}.DATE_TIME by default.
*/
public class XmlShapeDeserVisitor extends DocumentShapeDeserVisitor {
private static final TimestampFormatTrait.Format DEFAULT_TIMESTAMP_FORMAT = TimestampFormatTrait.Format.DATE_TIME;
private static final Logger LOGGER = Logger.getLogger(XmlShapeDeserVisitor.class.getName());
private final Predicate<MemberShape> memberFilter;
/**
* @param context The generation context.
*/
public XmlShapeDeserVisitor(GenerationContext context) {
this(context, FunctionalUtils.alwaysTrue());
}
/**
* @param context The generation context.
* @param memberFilter A filter that is applied to structure members. This is useful for
* members that won't be in the body.
*/
public XmlShapeDeserVisitor(GenerationContext context, Predicate<MemberShape> memberFilter) {
super(context);
this.memberFilter = memberFilter;
}
@Override
protected Map<String, String> getAdditionalArguments() {
return Collections.singletonMap("decoder", "smithyxml.NodeDecoder");
}
private XmlMemberDeserVisitor getMemberDeserVisitor(
MemberShape member,
String dataDest,
boolean isXmlAttributeMember
) {
// Get the timestamp format to be used, defaulting to rfc 3339 date-time format.
TimestampFormatTrait.Format format = member.getMemberTrait(getContext().getModel(), TimestampFormatTrait.class)
.map(TimestampFormatTrait::getFormat).orElse(DEFAULT_TIMESTAMP_FORMAT);
return new XmlMemberDeserVisitor(getContext(), member, dataDest, format, isXmlAttributeMember);
}
// generates code to define and initialize output variable for an aggregate shape
private void generatesInitializerForOutputVariable(GenerationContext context, Shape shape) {
GoWriter writer = context.getWriter().get();
Symbol shapeSymbol = context.getSymbolProvider().toSymbol(shape);
writer.write("var sv $P", shapeSymbol);
writer.openBlock("if *v == nil {", "", () -> {
if (shape.isStructureShape()) {
writer.write("sv = &$T{}", shapeSymbol);
} else {
writer.write("sv = make($P, 0)", shapeSymbol);
}
writer.openBlock("} else {", "}", () -> {
writer.write("sv = *v");
});
});
}
@Override
public Void mapShape(MapShape shape) {
super.mapShape(shape);
generateFlattenedMapDeserializer(getContext(), shape);
return null;
}
@Override
public Void setShape(SetShape shape) {
super.setShape(shape);
generateFlattenedCollectionDeserializer(getContext(), shape);
return null;
}
@Override
public Void listShape(ListShape shape) {
super.listShape(shape);
generateFlattenedCollectionDeserializer(getContext(), shape);
return null;
}
/**
* Deserializes the collection shapes.
* <p>
* In case of nested collections we will have nested `Member` element tags.
* for eg: <ParentList><Member><ChildList><Member>abc</Member></ChildList></Member></ParentList>
* <p>
* The XMLNodeDecoder decodes per xml element node level and exits when it encounters an end element
* with xml name that matches the xml name of start element.
* <p>
* For simple type members their is no function scoping, instead we use a loop to provide appropriate scoping.
* This helps ensure we do not exit early when we have nested tags with same element name.
*
* @param context the generation context.
* @param shape the Collection shape to be deserialized.
*/
@Override
protected void deserializeCollection(GenerationContext context, CollectionShape shape) {
GoWriter writer = context.getWriter().get();
// initialize the output member variable
generatesInitializerForOutputVariable(context, shape);
writer.write("originalDecoder := decoder");
// Iterate through the decoder. The member visitor will handle popping xml tokens
// enclosed within a xml start and end element.
writer.openBlock("for {", "}", () -> {
writer.write("t, done, err := decoder.Token()");
writer.write("if err != nil { return err }");
writer.write("if done { break }");
MemberShape member = shape.getMember();
Shape target = context.getModel().expectShape(member.getTarget());
String serializedMemberName = getSerializedMemberName(member);
// If target is a simple shape, we must get an explicit member decoder to handle `member` element tag for
// each member element of the list. This is not needed for the aggregate shapes as visitor handles it directly.
if (target instanceof SimpleShape) {
writer.write("memberDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)");
writer.write("decoder = memberDecoder");
}
writer.addUseImports(SmithyGoDependency.STRINGS);
writer.openBlock("switch {", "}", () -> {
writer.openBlock("case strings.EqualFold($S, t.Name.Local):", "", serializedMemberName, () -> {
writer.write("var col $P", context.getSymbolProvider().toSymbol(member));
target.accept(getMemberDeserVisitor(member, "col", false));
writer.write("sv = append(sv, col)");
});
writer.openBlock("default:", "", () -> {
writer.write("err = decoder.Decoder.Skip()");
writer.write("if err != nil { return err }");
});
});
writer.write("decoder = originalDecoder");
});
writer.write("*v = sv");
writer.write("return nil");
}
// Generates deserializer function for collection shapes with xml flattened trait.
public void generateFlattenedCollectionDeserializer(GenerationContext context, CollectionShape shape) {
GoWriter writer = context.getWriter().get();
SymbolProvider symbolProvider = context.getSymbolProvider();
Symbol symbol = symbolProvider.toSymbol(shape);
MemberShape member = shape.getMember();
Symbol memberSymbol = symbolProvider.toSymbol(member);
Shape target = context.getModel().expectShape(member.getTarget());
writer.openBlock("func $L(v *$P, decoder smithyxml.NodeDecoder) error {", "}",
getUnwrappedMapDelegateFunctionName(context, shape), symbol, () -> {
// initialize the output member variable
generatesInitializerForOutputVariable(context, shape);
writer.openBlock(" switch { default: ", "}", () -> {
writer.write("var mv $P", memberSymbol);
writer.write("t := decoder.StartEl");
writer.write("_ = t");
target.accept(getMemberDeserVisitor(member, "mv", false));
writer.write("sv = append(sv, mv)");
});
writer.write("*v = sv");
writer.write("return nil");
});
}
@Override
protected void deserializeMap(GenerationContext context, MapShape shape) {
GoWriter writer = context.getWriter().get();
// initialize the output member variable
generatesInitializerForOutputVariable(context, shape);
// Iterate through the decoder. The member visitor will handle popping xml tokens
// enclosed within a xml start and end element.
writer.openBlock("for {", "}", () -> {
writer.write("t, done, err := decoder.Token()");
writer.write("if err != nil { return err }");
writer.write("if done { break }");
// non-flattened maps
writer.addUseImports(SmithyGoDependency.STRINGS);
writer.openBlock("switch {", "}", () -> {
writer.openBlock("case strings.EqualFold(\"entry\", t.Name.Local):", "", () -> {
writer.write("entryDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)");
// delegate to unwrapped map deserializer function
writer.openBlock("if err := $L(&sv, entryDecoder); err != nil {", "}",
getUnwrappedMapDelegateFunctionName(context, shape), () -> {
writer.write("return err");
});
});
writer.openBlock("default:", "", () -> {
writer.write("err = decoder.Decoder.Skip()");
writer.write("if err != nil { return err }");
});
});
});
writer.write("*v = sv");
writer.write("return nil");
}
// Generates deserializer function for flattened maps.
protected void generateFlattenedMapDeserializer(GenerationContext context, MapShape shape) {
GoWriter writer = context.getWriter().get();
SymbolProvider symbolProvider = context.getSymbolProvider();
Symbol symbol = symbolProvider.toSymbol(shape);
writer.addUseImports(SmithyGoDependency.SMITHY_XML);
writer.openBlock("func $L(v *$P, decoder smithyxml.NodeDecoder) error {", "}",
getUnwrappedMapDelegateFunctionName(context, shape), symbol, () -> {
// initialize the output member variable
generatesInitializerForOutputVariable(context, shape);
MemberShape valueShape = shape.getValue();
MemberShape keyShape = shape.getKey();
Symbol keySymbol = context.getSymbolProvider().toSymbol(keyShape);
Symbol valueSymbol = context.getSymbolProvider().toSymbol(valueShape);
Shape targetKey = context.getModel().expectShape(keyShape.getTarget());
writer.write("var ek $P", keySymbol);
writer.write("var ev $P", valueSymbol);
writer.insertTrailingNewline();
// Iterate through the decoder. The member visitor will handle popping xml tokens
// enclosed within a xml start and end element.
writer.openBlock("for {", "}", () -> {
writer.write("t, done, err := decoder.Token()");
writer.write("if err != nil { return err }");
writer.openBlock("if done {", "}", () -> {
// set the key value pair in map
if (keyShape.hasTrait(EnumTrait.class) || targetKey.hasTrait(EnumTrait.class)) {
writer.write("sv[string(ek)] = ev");
} else {
writer.write("sv[ek] = ev");
}
writer.write("break");
});
writer.write("originalDecoder := decoder");
writer.write("decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)");
writer.insertTrailingNewline();
writer.openBlock("switch {", "}", () -> {
writer.addUseImports(SmithyGoDependency.STRINGS);
writer.openBlock("case strings.EqualFold($S, t.Name.Local):", "", getSerializedMemberName(keyShape), () -> {
String dest = "ek";
context.getModel().expectShape(keyShape.getTarget()).accept(
getMemberDeserVisitor(keyShape, dest, false));
});
writer.openBlock("case strings.EqualFold($S, t.Name.Local):", "", getSerializedMemberName(valueShape), () -> {
String dest = "ev";
context.getModel().expectShape(valueShape.getTarget()).accept(
getMemberDeserVisitor(valueShape, dest, false));
});
writer.openBlock("default:", "", () -> {
writer.write("err = decoder.Decoder.Skip()");
writer.write("if err != nil { return err }");
});
});
writer.write("decoder = originalDecoder");
});
writer.write("*v = sv");
writer.write("return nil");
});
}
private String getUnwrappedMapDelegateFunctionName(GenerationContext context, Shape shape) {
return ProtocolGenerator.getDocumentDeserializerFunctionName(shape, context.getService(), context.getProtocolName()) + "Unwrapped";
}
@Override
protected void deserializeStructure(GenerationContext context, StructureShape shape) {
GoWriter writer = context.getWriter().get();
SymbolProvider symbolProvider = context.getSymbolProvider();
Model model = context.getModel();
// initialize the output member variable
generatesInitializerForOutputVariable(context, shape);
// Deserialize member shapes modeled with xml attribute trait
if (hasXmlAttributeTraitMember(shape)) {
writer.openBlock("for _, attr := range decoder.StartEl.Attr {", "}", () -> {
writer.write("name := attr.Name.Local");
writer.openBlock("if len(attr.Name.Space) != 0 {", "}", () -> {
writer.addUseImports(SmithyGoDependency.STRINGS);
writer.write("name = attr.Name.Space + `:` + attr.Name.Local");
});
writer.openBlock("switch {", "}", () -> {
Set<MemberShape> members = new TreeSet<>(shape.members());
for (MemberShape member : members) {
// check if member does not conform with the member filter or does not have a xmlAttribute trait
if (!memberFilter.test(member) || !member.hasTrait(XmlAttributeTrait.ID)) {
continue;
}
String memberName = symbolProvider.toMemberName(member);
String serializedMemberName = getSerializedMemberName(member);
writer.addUseImports(SmithyGoDependency.STRINGS);
writer.openBlock("case strings.EqualFold($S, name):", "", serializedMemberName, () -> {
String dest = "sv." + memberName;
context.getModel().expectShape(member.getTarget()).accept(
getMemberDeserVisitor(member, dest, true));
});
}
});
});
}
// Iterate through the decoder. The member visitor will handle popping xml tokens
// enclosed within a xml start and end element.
writer.openBlock("for {", "}", () -> {
writer.write("t, done, err := decoder.Token()");
writer.write("if err != nil { return err }");
writer.write("if done { break }");
// Create a new decoder for each member
writer.write("originalDecoder := decoder");
writer.write("decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)");
writer.insertTrailingNewline();
writer.openBlock("switch {", "}", () -> {
Set<MemberShape> members = new TreeSet<>(shape.members());
for (MemberShape member : members) {
// check if member is not a document binding or has a xmlAttribute trait
if (!memberFilter.test(member) || member.hasTrait(XmlAttributeTrait.ID)) {
continue;
}
String memberName = symbolProvider.toMemberName(member);
String serializedMemberName = getSerializedMemberName(member);
writer.addUseImports(SmithyGoDependency.STRINGS);
writer.openBlock("case strings.EqualFold($S, t.Name.Local):", "", serializedMemberName, () -> {
String dest = "sv." + memberName;
model.expectShape(member.getTarget()).accept(
getMemberDeserVisitor(member, dest, false));
});
}
writer.openBlock("default:", "", () -> {
writer.writeDocs("Do nothing and ignore the unexpected tag element");
writer.write("err = decoder.Decoder.Skip()");
writer.write("if err != nil { return err }");
});
});
// re-assign the original decoder
writer.write("decoder = originalDecoder");
});
writer.write("*v = sv");
writer.write("return nil");
}
// return true if any member of the shape is decorated with XmlAttributeTrait
private boolean hasXmlAttributeTraitMember(Shape shape) {
for (MemberShape member : shape.members()) {
if (member.hasTrait(XmlAttributeTrait.ID)) {
return true;
}
}
return false;
}
private String getSerializedMemberName(MemberShape memberShape) {
Optional<XmlNameTrait> xmlNameTrait = memberShape.getTrait(XmlNameTrait.class);
return xmlNameTrait.isPresent() ? xmlNameTrait.get().getValue() : memberShape.getMemberName();
}
@Override
protected void deserializeDocument(GenerationContext context, DocumentShape shape) {
GoWriter writer = context.getWriter().get();
LOGGER.warning("The document type is unsupported for XML protocols.");
writer.addUseImports(SmithyGoDependency.SMITHY);
writer.write("return &smithy.DeserializationError{Err: fmt.Errorf("
+ "\"Document type is unsupported for XML protocols.\")}");
}
@Override
protected void deserializeUnion(GenerationContext context, UnionShape shape) {
GoWriter writer = context.getWriter().get();
SymbolProvider symbolProvider = context.getSymbolProvider();
Symbol symbol = symbolProvider.toSymbol(shape);
Model model = context.getModel();
writer.write("var uv $P", symbol);
writer.write("var memberFound bool");
// Iterate through the decoder. The member visitor will handle popping
// xml tokens enclosed within a xml start and end element.
writer.openBlock("for {", "}", () -> {
writer.write("t, done, err := decoder.Token()");
writer.write("if err != nil { return err }");
writer.write("if done { break }");
writer.openBlock("if memberFound {", "}", () -> {
writer.write("if err = decoder.Decoder.Skip(); err != nil { return err }");
});
// Create a new decoder for each member
writer.write("originalDecoder := decoder");
writer.write("decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)");
writer.insertTrailingNewline();
writer.openBlock("switch {", "}", () -> {
Set<MemberShape> members = new TreeSet<>(shape.members());
for (MemberShape member : members) {
// check if member is not a document binding or has a xmlAttribute trait
if (!memberFilter.test(member) || member.hasTrait(XmlAttributeTrait.ID)) {
continue;
}
Symbol targetSymbol = symbolProvider.toSymbol(member);
Symbol memberSymbol = SymbolUtils.createValueSymbolBuilder(
symbolProvider.toMemberName(member),
symbol.getNamespace()
).build();
writer.addUseImports(SmithyGoDependency.STRINGS);
String serializedMemberName = getSerializedMemberName(member);
writer.openBlock("case strings.EqualFold($S, t.Name.Local):", "", serializedMemberName, () -> {
writer.write("var mv $P", targetSymbol);
model.expectShape(member.getTarget()).accept(getMemberDeserVisitor(member, "mv", false));
writer.write("uv = &$T{Value: mv}", memberSymbol);
writer.write("memberFound = true");
});
}
writer.openBlock("default:", "", () -> {
// This is the function to take a value and convert it to the union type.
Symbol unknownMemberSymbol = SymbolUtils.createValueSymbolBuilder(
UnionGenerator.UNKNOWN_MEMBER_NAME,
symbol.getNamespace()
).build();
writer.write("uv = &$T{Tag: t.Name.Local}", unknownMemberSymbol);
writer.write("memberFound = true");
});
});
// re-assign the original decoder
writer.write("decoder = originalDecoder");
});
writer.write("*v = uv");
writer.write("return nil");
}
}
| 8,338 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AssembleMiddlewareStack.java | package software.amazon.smithy.aws.go.codegen;
import java.util.List;
import software.amazon.smithy.aws.go.codegen.customization.AdjustAwsRestJsonContentType;
import software.amazon.smithy.aws.traits.auth.UnsignedPayloadTrait;
import software.amazon.smithy.go.codegen.SmithyGoDependency;
import software.amazon.smithy.go.codegen.SymbolUtils;
import software.amazon.smithy.go.codegen.integration.ConfigFieldResolver;
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.knowledge.EventStreamIndex;
import software.amazon.smithy.utils.ListUtils;
public class AssembleMiddlewareStack implements GoIntegration {
/**
* Gets the sort order of the customization from -128 to 127, with lowest
* executed first.
*
* @return Returns the sort order, defaults to -40.
*/
@Override
public byte getOrder() {
return -40;
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return ListUtils.of(
// Add RequestInvocationIDMiddleware to operation stack
RuntimeClientPlugin.builder()
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(
"AddClientRequestIDMiddleware", AwsGoDependency.AWS_MIDDLEWARE)
.build())
.build()
)
.build(),
// Add ContentLengthMiddleware to operation stack
RuntimeClientPlugin.builder()
.operationPredicate((model, service, operation) ->
EventStreamIndex.of(model).getInputInfo(operation).isEmpty())
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(
"AddComputeContentLengthMiddleware",
SmithyGoDependency.SMITHY_HTTP_TRANSPORT)
.build())
.build()
)
.build(),
// Add endpoint serialize middleware to operation stack
RuntimeClientPlugin.builder()
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(
EndpointGenerator.ADD_MIDDLEWARE_HELPER_NAME).build())
.useClientOptions()
.build())
.build(),
// Add streaming events payload middleware to operation stack
RuntimeClientPlugin.builder()
.operationPredicate((model, service, operation) -> {
if (!AwsSignatureVersion4.hasSigV4AuthScheme(
model, service, operation)) {
return false;
}
return EventStreamIndex.of(model).getInputInfo(operation).isPresent();
})
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(
"AddStreamingEventsPayload", AwsGoDependency.AWS_SIGNER_V4)
.build())
.build())
.build(),
// Add unsigned payload middleware to operation stack
RuntimeClientPlugin.builder()
.operationPredicate((model, service, operation) -> {
if (!AwsSignatureVersion4.hasSigV4AuthScheme(
model, service, operation)) {
return false;
}
var noEventStream = EventStreamIndex.of(model).getInputInfo(operation).isEmpty();
return operation.hasTrait(UnsignedPayloadTrait.class) && noEventStream;
})
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(
"AddUnsignedPayloadMiddleware", AwsGoDependency.AWS_SIGNER_V4)
.build())
.build())
.build(),
// Add signed payload middleware to operation stack
RuntimeClientPlugin.builder()
.operationPredicate((model, service, operation) -> {
if (!AwsSignatureVersion4.hasSigV4AuthScheme(
model, service, operation)) {
return false;
}
var noEventStream = EventStreamIndex.of(model).getInputInfo(operation).isEmpty();
return !operation.hasTrait(UnsignedPayloadTrait.class) && noEventStream;
})
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(
"AddComputePayloadSHA256Middleware", AwsGoDependency.AWS_SIGNER_V4)
.build())
.build())
.build(),
// Add content-sha256 payload header middleware to operation stack
RuntimeClientPlugin.builder()
.operationPredicate((model, service, operation) -> {
if (!AwsSignatureVersion4.hasSigV4AuthScheme(
model, service, operation)) {
return false;
}
var hasEventStream = EventStreamIndex.of(model).getInputInfo(operation).isPresent();
return operation.hasTrait(UnsignedPayloadTrait.class) || hasEventStream;
})
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(
"AddContentSHA256HeaderMiddleware", AwsGoDependency.AWS_SIGNER_V4)
.build())
.build())
.build(),
// Add retryer middleware to operation stack
RuntimeClientPlugin.builder()
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(
AwsRetryMiddlewareHelper.ADD_RETRY_MIDDLEWARES_HELPER)
.build())
.useClientOptions()
.build())
.build(),
// Add HTTPSigner middleware to operation stack
RuntimeClientPlugin.builder()
.operationPredicate(AwsSignatureVersion4::hasSigV4AuthScheme)
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(
AwsSignatureVersion4.REGISTER_MIDDLEWARE_FUNCTION).build())
.useClientOptions()
.build())
.build(),
// Add middleware to store raw response omn metadata
RuntimeClientPlugin.builder()
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(
"AddRawResponseToMetadata", AwsGoDependency.AWS_MIDDLEWARE)
.build())
.build())
.build(),
// Add recordResponseTiming middleware to operation stack
RuntimeClientPlugin.builder()
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(
"AddRecordResponseTiming", AwsGoDependency.AWS_MIDDLEWARE)
.build())
.build())
.build(),
// Add Client UserAgent
RuntimeClientPlugin.builder()
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createPointableSymbolBuilder(
AwsClientUserAgent.MIDDLEWARE_RESOLVER).build())
.useClientOptions()
.build())
.build(),
// Add REST-JSON Content-Type Adjuster
RuntimeClientPlugin.builder()
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(
AdjustAwsRestJsonContentType.RESOLVER_NAME).build())
.build())
.servicePredicate((model, serviceShape) ->
AdjustAwsRestJsonContentType.isServiceOnShameList(serviceShape))
.build(),
// Add Event Stream Input Writer (must be added AFTER retryer)
RuntimeClientPlugin.builder()
.operationPredicate((model, service, operation) ->
EventStreamIndex.of(model).getInputInfo(operation).isPresent())
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(
"AddInitializeStreamWriter",
AwsGoDependency.SERVICE_INTERNAL_EVENTSTREAMAPI)
.build())
.build())
.build()
);
}
}
| 8,339 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsIdempotencyTokenProvider.java | /*
* 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.aws.go.codegen;
import java.util.List;
import java.util.Map;
import java.util.Optional;
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.ConfigFieldResolver;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.go.codegen.integration.IdempotencyTokenMiddlewareGenerator;
import software.amazon.smithy.go.codegen.integration.RuntimeClientPlugin;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.knowledge.NeighborProviderIndex;
import software.amazon.smithy.model.neighbor.NeighborProvider;
import software.amazon.smithy.model.neighbor.Walker;
import software.amazon.smithy.model.shapes.MemberShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.traits.IdempotencyTokenTrait;
import software.amazon.smithy.utils.ListUtils;
/**
* Registers a client resolver for assigning the AWS default idempotency token provider.
*/
public final class AwsIdempotencyTokenProvider implements GoIntegration {
private static final String RESOLVER_FUNCTION = "resolveIdempotencyTokenProvider";
private boolean isTraitUsed = false;
@Override
public void writeAdditionalFiles(
GoSettings settings, Model model, SymbolProvider symbolProvider, GoDelegator goDelegator
) {
if (!isTraitUsed) {
return;
}
goDelegator.useShapeWriter(settings.getService(model), this::writeResolver);
}
@Override
public void processFinalizedModel(GoSettings settings, Model model) {
Map<ShapeId, MemberShape> map = IdempotencyTokenMiddlewareGenerator.getOperationsWithIdempotencyToken(model,
settings.getService(model));
isTraitUsed = !map.isEmpty();
}
private void writeResolver(GoWriter writer) {
String idempotencyConfigName = IdempotencyTokenMiddlewareGenerator.IDEMPOTENCY_CONFIG_NAME;
writer.openBlock("func $L(o *Options) {", "}", RESOLVER_FUNCTION, () -> {
writer.openBlock("if o.$L != nil {", "}", idempotencyConfigName, () -> writer.write("return"));
writer.write("o.$L = $T($T)", idempotencyConfigName,
SymbolUtils.createValueSymbolBuilder("NewUUIDIdempotencyToken",
SmithyGoDependency.SMITHY_RAND).build(),
SymbolUtils.createValueSymbolBuilder("Reader", SmithyGoDependency.CRYPTORAND).build());
});
writer.write("");
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
if (!isTraitUsed) {
return ListUtils.of();
}
return ListUtils.of(RuntimeClientPlugin.builder()
.addConfigFieldResolver(ConfigFieldResolver.builder()
.location(ConfigFieldResolver.Location.CLIENT)
.target(ConfigFieldResolver.Target.INITIALIZATION)
.resolver(SymbolUtils.createValueSymbolBuilder(RESOLVER_FUNCTION).build())
.build())
.build());
}
}
| 8,340 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsJsonRpc1_0.java | /*
* 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.aws.go.codegen;
import java.util.Set;
import software.amazon.smithy.aws.traits.protocols.AwsJson1_0Trait;
import software.amazon.smithy.aws.traits.protocols.AwsQueryCompatibleTrait;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.go.codegen.GoWriter;
import software.amazon.smithy.go.codegen.SmithyGoDependency;
import software.amazon.smithy.go.codegen.integration.HttpProtocolGeneratorUtils;
import software.amazon.smithy.go.codegen.integration.ProtocolGenerator;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.shapes.StructureShape;
/**
* Handles generating the awsJson1_0 protocol for services.
*
* @inheritDoc
*
* @see JsonRpcProtocolGenerator
*/
final class AwsJsonRpc1_0 extends JsonRpcProtocolGenerator {
@Override
protected String getDocumentContentType() {
return "application/x-amz-json-1.0";
}
@Override
public ShapeId getProtocol() {
return AwsJson1_0Trait.ID;
}
@Override
protected Set<StructureShape> generateErrorShapes(
GenerationContext context, OperationShape operation, Symbol responseType) {
if (isAwsQueryCompatibleTraitFound(context)) {
return HttpProtocolGeneratorUtils.generateErrorDispatcher(
context, operation, responseType, this::writeErrorMessageCodeDeserializer,
this::getOperationErrors, (writer) -> AwsJsonRpc1_0.awsQueryCompatibleDefaultBlockWriter(writer));
} else {
return HttpProtocolGeneratorUtils.generateErrorDispatcher(
context, operation, responseType, this::writeErrorMessageCodeDeserializer,
this::getOperationErrors);
}
}
@Override
protected void deserializeError(GenerationContext context, StructureShape shape) {
GoWriter writer = context.getWriter().get();
Symbol symbol = context.getSymbolProvider().toSymbol(shape);
String functionName = ProtocolGenerator.getDocumentDeserializerFunctionName(shape, context.getService(),
getProtocolName());
AwsProtocolUtils.initializeJsonDecoder(writer, "errorBody");
AwsProtocolUtils.decodeJsonIntoInterface(writer, "");
writer.write("output := &$T{}", symbol);
writer.write("err := $L(&output, shape)", functionName);
writer.write("");
AwsProtocolUtils.handleDecodeError(writer);
writer.write("errorBody.Seek(0, io.SeekStart)");
if (isAwsQueryCompatibleTraitFound(context)) {
writer.write("awsQueryErrorCode := getAwsQueryErrorCode(response)");
writer.openBlock("if awsQueryErrorCode != \"\" {", "}", () -> {
writer.write("output.ErrorCodeOverride = &awsQueryErrorCode");
});
}
writer.write("return output");
}
@Override
public void generateSharedDeserializerComponents(GenerationContext context) {
super.generateSharedDeserializerComponents(context);
if (isAwsQueryCompatibleTraitFound(context)) {
GoWriter writer = context.getWriter().get();
writer.addUseImports(SmithyGoDependency.STRINGS);
writer.addUseImports(SmithyGoDependency.SMITHY_HTTP_TRANSPORT);
writer.openBlock("func getAwsQueryErrorCode(response *smithyhttp.Response) string {", "}", () -> {
writer.write("queryCodeHeader := response.Header.Get(\"x-amzn-query-error\")");
writer.openBlock("if queryCodeHeader != \"\" {", "}", () -> {
writer.write("queryCodeParts := strings.Split(queryCodeHeader, \";\")");
writer.openBlock("if len(queryCodeParts) == 2 {", "}", () -> {
writer.write("return queryCodeParts[0]");
});
});
writer.write("return \"\"");
});
}
}
private static void awsQueryCompatibleDefaultBlockWriter(GoWriter writer) {
writer.openBlock("default:", "", () -> {
writer.write("awsQueryErrorCode := getAwsQueryErrorCode(response)");
writer.openBlock("if awsQueryErrorCode != \"\" {", "}", () -> {
writer.write("errorCode = awsQueryErrorCode");
});
writer.openBlock("genericError := &smithy.GenericAPIError{", "}", () -> {
writer.write("Code: errorCode,");
writer.write("Message: errorMessage,");
});
writer.write("return genericError");
});
}
private boolean isAwsQueryCompatibleTraitFound(GenerationContext context) {
return context.getService().hasTrait(AwsQueryCompatibleTrait.class);
}
}
| 8,341 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3SignatureVersion4a.java | package software.amazon.smithy.aws.go.codegen.customization;
import java.util.List;
import software.amazon.smithy.aws.go.codegen.AddAwsConfigFields;
import software.amazon.smithy.aws.go.codegen.AwsGoDependency;
import software.amazon.smithy.aws.go.codegen.AwsSignatureVersion4;
import software.amazon.smithy.aws.go.codegen.AwsSignatureVersion4aUtils;
import software.amazon.smithy.aws.traits.ServiceTrait;
import software.amazon.smithy.codegen.core.Symbol;
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.ConfigFieldResolver;
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.shapes.ServiceShape;
import software.amazon.smithy.utils.ListUtils;
/**
* This integration configures the S3 client for Signature Version 4a
*/
public class S3SignatureVersion4a implements GoIntegration {
/**
* Return true if service is Amazon S3.
*
* @param model is the generation model.
* @param service is the service shape being audited.
*/
private static boolean isS3Service(Model model, ServiceShape service) {
String serviceId = service.expectTrait(ServiceTrait.class).getSdkId();
return serviceId.equalsIgnoreCase("S3");
}
private static final List<String> DISABLE_URI_PATH_ESCAPE = ListUtils.of("com.amazonaws.s3#AmazonS3");
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
Symbol resolver = SymbolUtils.createValueSymbolBuilder(AwsSignatureVersion4aUtils.RESOLVE_CREDENTIAL_PROVIDER)
.build();
return ListUtils.of(RuntimeClientPlugin.builder()
.addConfigFieldResolver(ConfigFieldResolver.builder()
.location(ConfigFieldResolver.Location.CLIENT)
.target(ConfigFieldResolver.Target.FINALIZATION)
.resolver(resolver)
.build())
.addConfigFieldResolver(ConfigFieldResolver.builder()
.location(ConfigFieldResolver.Location.OPERATION)
.target(ConfigFieldResolver.Target.FINALIZATION)
.resolver(resolver)
.build())
.servicePredicate((model, serviceShape) -> {
if (!S3SignatureVersion4a.isS3Service(model, serviceShape)) {
return false;
}
return AwsSignatureVersion4.isSupportedAuthentication(model, serviceShape);
})
.build(),
// Add HTTPSigner middleware to operation stack
RuntimeClientPlugin.builder()
.servicePredicate(S3SignatureVersion4a::isS3Service)
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(
AwsSignatureVersion4aUtils.REGISTER_MIDDLEWARE_FUNCTION).build())
.useClientOptions()
.build())
.build(),
RuntimeClientPlugin.builder()
.servicePredicate(S3SignatureVersion4a::isS3Service)
.addConfigFieldResolver(
ConfigFieldResolver.builder()
.location(ConfigFieldResolver.Location.CLIENT)
.target(ConfigFieldResolver.Target.INITIALIZATION)
.resolver(SymbolUtils.createValueSymbolBuilder(
AwsSignatureVersion4aUtils.SIGNER_RESOLVER).build())
.build())
.build()
);
}
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
if (!isS3Service(model, model.expectShape(settings.getService(), ServiceShape.class))) {
return;
}
ServiceShape serviceShape = settings.getService(model);
goDelegator.useShapeWriter(serviceShape, writer -> {
writeCredentialProviderResolver(writer);
writeMiddlewareRegister(model, writer, serviceShape);
writerSignerInterface(writer);
writerConfigFieldResolver(writer, serviceShape);
writeNewV4ASignerFunc(writer, serviceShape);
});
}
private void writeCredentialProviderResolver(GoWriter writer) {
AwsSignatureVersion4aUtils.writeCredentialProviderResolver(writer);
}
private void writerSignerInterface(GoWriter writer) {
AwsSignatureVersion4aUtils.writerSignerInterface(writer);
}
private void writerConfigFieldResolver(GoWriter writer, ServiceShape serviceShape) {
AwsSignatureVersion4aUtils.writerConfigFieldResolver(writer, serviceShape);
}
private void writeNewV4ASignerFunc(GoWriter writer, ServiceShape serviceShape) {
AwsSignatureVersion4aUtils.writeNewV4ASignerFunc(writer, serviceShape,
DISABLE_URI_PATH_ESCAPE.contains(serviceShape.getId().toString()));
}
private void writeMiddlewareRegister(Model model, GoWriter writer, ServiceShape serviceShape) {
AwsSignatureVersion4aUtils.writeMiddlewareRegister(model, writer, serviceShape,
AwsCustomGoDependency.S3_CUSTOMIZATION);
}
}
| 8,342 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/AdjustAwsRestJsonContentType.java | /*
* Copyright 2021 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.aws.go.codegen.customization;
import java.util.Set;
import software.amazon.smithy.codegen.core.Symbol;
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.GoStackStepMiddlewareGenerator;
import software.amazon.smithy.go.codegen.GoWriter;
import software.amazon.smithy.go.codegen.MiddlewareIdentifier;
import software.amazon.smithy.go.codegen.SmithyGoDependency;
import software.amazon.smithy.go.codegen.SymbolUtils;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.shapes.ToShapeId;
import software.amazon.smithy.utils.SetUtils;
/**
* Generates a middleware to fix the AWS REST-JSON Content-Type header from the standard protocol header
* to the json 1.1 header.
*/
public class AdjustAwsRestJsonContentType implements GoIntegration {
public static final String RESOLVER_NAME = "addRestJsonContentTypeCustomization";
private static final String MIDDLEWARE_NAME = "customizeRestJsonContentType";
private static final GoStackStepMiddlewareGenerator SERIALIZE_STEP_MIDDLEWARE =
GoStackStepMiddlewareGenerator.createSerializeStepMiddleware(MIDDLEWARE_NAME,
MiddlewareIdentifier.builder().name(MIDDLEWARE_NAME).build());
private static final String CONTENT_TYPE_HEADER = "Content-Type";
private static final String EXPECTED_CONTENT_TYPE = "application/json";
private static final String TARGET_CONTENT_TYPE = "application/x-amz-json-1.1";
private static final String INSERT_AFTER = "OperationSerializer";
private static final Set<ShapeId> SHAME_SET = SetUtils.of(
ShapeId.from("com.amazonaws.finspace#AWSHabaneroManagementService"),
ShapeId.from("com.amazonaws.finspacedata#AWSHabaneroPublicAPI")
);
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
if (!isServiceOnShameList(settings.getService())) {
return;
}
goDelegator.useShapeWriter(settings.getService(model), writer -> {
generateMiddleware(writer);
generateAddMiddleware(writer);
});
}
/**
* Determine if a service should be customized.
* @param service the service shape id
* @return whether the service requires customization
*/
public static boolean isServiceOnShameList(ToShapeId service) {
return SHAME_SET.contains(service.toShapeId());
}
private void generateAddMiddleware(GoWriter writer) {
Symbol stackSymbol = SymbolUtils.createPointableSymbolBuilder("Stack",
SmithyGoDependency.SMITHY_MIDDLEWARE).build();
writer.write("");
writer.openBlock("func $L(stack $P) error {", "}", RESOLVER_NAME, stackSymbol, () -> {
writer.openBlock("return stack.Serialize.Insert(&$T{}, $S, $T)",
SERIALIZE_STEP_MIDDLEWARE.getMiddlewareSymbol(), INSERT_AFTER,
SymbolUtils.createValueSymbolBuilder("After", SmithyGoDependency.SMITHY_MIDDLEWARE).build());
});
}
private void generateMiddleware(GoWriter writer) {
SERIALIZE_STEP_MIDDLEWARE.writeMiddleware(writer, (g, w) -> {
Symbol requestSymbol = SymbolUtils.createPointableSymbolBuilder("Request",
SmithyGoDependency.SMITHY_HTTP_TRANSPORT).build();
w.write("req, ok := in.Request.($P)", requestSymbol);
w.openBlock("if !ok {", "}", () -> {
w.addUseImports(SmithyGoDependency.FMT);
w.write("return out, metadata, fmt.Errorf(\"unknown transport type %T\", in.Request)");
});
w.write("");
w.write("const contentType = $S", CONTENT_TYPE_HEADER);
w.write("const expectedType = $S", EXPECTED_CONTENT_TYPE);
w.write("const targetType = $S", TARGET_CONTENT_TYPE);
w.write("");
w.addUseImports(SmithyGoDependency.STRINGS);
w.openBlock("if strings.EqualFold(req.Header.Get(contentType), expectedType) {", "}",
() -> {
w.write("req.Header.Set(contentType, targetType)");
});
w.write("");
w.write("return next.$L(ctx, in)", g.getHandleMethodName());
});
}
}
| 8,343 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3ModelUtils.java | /*
* Copyright 2021 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.aws.go.codegen.customization;
import software.amazon.smithy.aws.traits.ServiceTrait;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.shapes.ServiceShape;
/**
* Collection of static utilities for working with S3 services.
*/
public final class S3ModelUtils {
public static String SERVICE_S3_MODEL_FILE = "s3.json";
public static String SERVICE_S3_CONTROL_MODEL_FILE = "s3-control.json";
private S3ModelUtils() {}
/**
* Return true if service is S3.
*
* @param model the model used for generation.
* @param service the service shape for which default HTTP Client is generated.
* @return true if service is S3
*/
public static boolean isServiceS3(Model model, ServiceShape service) {
return service.expectTrait(ServiceTrait.class).getSdkId().equalsIgnoreCase("S3");
}
/**
* Return true if service is S3.
*
* @param model the model used for generation.
* @param service the service shape for which default HTTP Client is generated.
* @return true if service is S3
*/
public static boolean isServiceS3Control(Model model, ServiceShape service) {
return service.expectTrait(ServiceTrait.class).getSdkId().equalsIgnoreCase("S3 Control");
}
}
| 8,344 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/GlacierCustomizations.java | package software.amazon.smithy.aws.go.codegen.customization;
import java.util.List;
import java.util.stream.Collectors;
import software.amazon.smithy.aws.traits.ServiceTrait;
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.SymbolUtils;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.go.codegen.integration.MiddlewareRegistrar;
import software.amazon.smithy.go.codegen.integration.ProtocolUtils;
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.MemberShape;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.utils.ListUtils;
public class GlacierCustomizations implements GoIntegration {
private static final String TREE_HASH_ADDER = "AddTreeHashMiddleware";
private static final String API_VERSION_ADDER = "AddGlacierAPIVersionMiddleware";
private static final String ACCOUNT_ID_ADDER = "AddDefaultAccountIDMiddleware";
private static final String SET_DEFAULT_ACCOUNT_ID = "setDefaultAccountID";
@Override
public byte getOrder() {
return 127;
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return ListUtils.of(
RuntimeClientPlugin.builder()
.servicePredicate(GlacierCustomizations::isGlacier)
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(TREE_HASH_ADDER,
AwsCustomGoDependency.GLACIER_CUSTOMIZATION).build())
.build())
.build(),
RuntimeClientPlugin.builder()
.servicePredicate(GlacierCustomizations::isGlacier)
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(API_VERSION_ADDER,
AwsCustomGoDependency.GLACIER_CUSTOMIZATION).build())
.functionArguments(ListUtils.of(
SymbolUtils.createValueSymbolBuilder("ServiceAPIVersion").build()))
.build())
.build(),
RuntimeClientPlugin.builder()
.servicePredicate(GlacierCustomizations::isGlacier)
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(ACCOUNT_ID_ADDER,
AwsCustomGoDependency.GLACIER_CUSTOMIZATION).build())
.functionArguments(ListUtils.of(
SymbolUtils.createValueSymbolBuilder(SET_DEFAULT_ACCOUNT_ID).build()))
.build())
.build()
);
}
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
ServiceShape service = settings.getService(model);
if (!isGlacier(model, service)) {
return;
}
goDelegator.useShapeWriter(service, writer -> {
writeAccountIdSetter(writer, model, symbolProvider, service);
});
}
private void writeAccountIdSetter(
GoWriter writer,
Model model,
SymbolProvider symbolProvider,
ServiceShape service
) {
writer.writeDocs("setDefaultAccountID sets the AccountID to the given value if the current value is nil");
writer.openBlock("func setDefaultAccountID(input interface{}, accountID string) interface{} {", "}", () -> {
writer.openBlock("switch i := input.(type) {", "}", () -> {
for (OperationShape operation : TopDownIndex.of(model).getContainedOperations(service)) {
StructureShape input = ProtocolUtils.expectInput(model, operation);
List<MemberShape> accountId = input.getAllMembers().values().stream()
.filter(m -> m.getMemberName().toLowerCase().equals("accountid"))
.toList();
if (accountId.isEmpty()) {
continue;
}
writer.openBlock("case $P:", "", symbolProvider.toSymbol(input), () -> {
String memberName = symbolProvider.toMemberName(accountId.get(0));
writer.write("if i.$L == nil { i.$L = &accountID }", memberName, memberName);
writer.write("return i");
});
}
writer.write("default: return input");
});
});
}
private static boolean isGlacier(Model model, ServiceShape service) {
return service.expectTrait(ServiceTrait.class).getSdkId().equalsIgnoreCase("Glacier");
}
}
| 8,345 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3UpdateEndpoint.java | /*
* 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.aws.go.codegen.customization;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import java.util.stream.Collectors;
import software.amazon.smithy.aws.go.codegen.AwsSignatureVersion4aUtils;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.go.codegen.GoCodegenPlugin;
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.MemberShape;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.utils.ListUtils;
import software.amazon.smithy.utils.SetUtils;
/**
* S3UpdateEndpoint integration serves to apply customizations for S3 service,
* and modifies the resolved endpoint based on S3 client config or input shape values.
*/
public class S3UpdateEndpoint implements GoIntegration {
// Middleware name
private static final String UPDATE_ENDPOINT_INTERNAL_ADDER = "UpdateEndpoint";
// Middleware options
private static final String UPDATE_ENDPOINT_INTERNAL_OPTIONS =
UPDATE_ENDPOINT_INTERNAL_ADDER + "Options";
private static final String UPDATE_ENDPOINT_INTERNAL_PARAMETER_ACCESSOR =
UPDATE_ENDPOINT_INTERNAL_ADDER + "ParameterAccessor";
// s3 shared option constants
private static final String USE_DUALSTACK_OPTION = "UseDualstack";
private static final String USE_ARNREGION_OPTION = "UseARNRegion";
// list of runtime-client plugins
private final List<RuntimeClientPlugin> runtimeClientPlugins = new ArrayList<>();
private static boolean isS3SharedService(Model model, ServiceShape service) {
return S3ModelUtils.isServiceS3(model, service) || S3ModelUtils.isServiceS3Control(model, service);
}
private static String copyInputFuncName(String inputName) {
return String.format("copy%sForUpdateEndpoint", inputName);
}
private static String getterFuncName(String operationName, String memberName) {
return String.format("get%s%s", operationName, memberName);
}
private static String setterFuncName(String operationName, String memberName) {
return String.format("set%s%s", operationName, memberName);
}
private static String addMiddlewareFuncName(String operationname, String middlewareName) {
return String.format("add%s%s", operationname, middlewareName);
}
/**
* Gets the sort order of the customization from -128 to 127, with lowest
* executed first.
*
* @return Returns the sort order, defaults to -40.
*/
@Override
public byte getOrder() {
return 127;
}
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
ServiceShape service = settings.getService(model);
// if service is s3control
if (S3ModelUtils.isServiceS3Control(model, service)) {
S3control s3control = new S3control(service);
s3control.writeAdditionalFiles(settings, model, symbolProvider, goDelegator);
}
// check if service is s3
if (S3ModelUtils.isServiceS3(model, service)) {
S3 s3 = new S3(service);
s3.writeAdditionalFiles(settings, model, symbolProvider, goDelegator);
}
}
/**
* Builds the set of runtime plugs used by the presign url customization.
*
* @param settings codegen settings
* @param model api model
*/
@Override
public void processFinalizedModel(GoSettings settings, Model model) {
ServiceShape service = settings.getService(model);
for (final OperationShape operation : TopDownIndex.of(model).getContainedOperations(service)) {
// Create a symbol provider because one is not available in this call.
SymbolProvider symbolProvider = GoCodegenPlugin.createSymbolProvider(model, settings);
String helperFuncName = addMiddlewareFuncName(
symbolProvider.toSymbol(operation).getName(),
UPDATE_ENDPOINT_INTERNAL_ADDER
);
runtimeClientPlugins.add(RuntimeClientPlugin.builder()
.operationPredicate((m, s, o) -> {
if (!isS3SharedService(m, s)) {
return false;
}
return o.equals(operation);
})
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(helperFuncName)
.build())
.useClientOptions()
.build())
.build());
}
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
runtimeClientPlugins.addAll(ListUtils.of(
// Add S3 shared config's dualstack option
RuntimeClientPlugin.builder()
.servicePredicate(S3UpdateEndpoint::isS3SharedService)
.configFields(ListUtils.of(
ConfigField.builder()
.name(USE_DUALSTACK_OPTION)
.type(SymbolUtils.createValueSymbolBuilder("bool")
.putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true)
.build())
.documentation("Allows you to enable dual-stack endpoint support for the "
+ "service.")
.deprecated("""
Set dual-stack by setting UseDualStackEndpoint on
EndpointResolverOptions. When EndpointResolverOptions'
UseDualStackEndpoint field is set it overrides this field value.""")
.build(),
ConfigField.builder()
.name(USE_ARNREGION_OPTION)
.type(SymbolUtils.createValueSymbolBuilder("bool")
.putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true)
.build())
.documentation("Allows you to enable arn region support for the service.")
.build()
))
.build()
));
runtimeClientPlugins.addAll(S3.getClientPlugins());
return runtimeClientPlugins;
}
/*
* s3 class is the private class handling s3 goIntegration for endpoint mutations
*/
private static class S3 {
// options to be generated on Client's options type
private static final String USE_PATH_STYLE_OPTION = "UsePathStyle";
private static final String USE_ACCELERATE_OPTION = "UseAccelerate";
private static final String DISABLE_MRAP_OPTION = "DisableMultiRegionAccessPoints";
// private function getter constant
private static final String NOP_BUCKET_ACCESSOR = "nopGetBucketAccessor";
// service shape representing s3
private final ServiceShape service;
// list of operations that take in bucket as input
private final Set<String> SUPPORT_BUCKET_AS_INPUT = new TreeSet<>();
// list of operations that do not support accelerate
private final Set<String> NOT_SUPPORT_ACCELERATE = SetUtils.of(
"ListBuckets", "CreateBucket", "DeleteBucket"
);
private final Set<String> TARGET_OBJECT_LAMBDAS = SetUtils.of("WriteGetObjectResponse");
private S3(ServiceShape service) {
this.service = service;
}
// getClientPlugins returns a list of client plugins for s3 service
private static List<RuntimeClientPlugin> getClientPlugins() {
List<RuntimeClientPlugin> list = ListUtils.of(
// Add S3 config to use path style host addressing.
RuntimeClientPlugin.builder()
.servicePredicate((model, service1) -> S3ModelUtils.isServiceS3(model, service1))
.configFields(ListUtils.of(
ConfigField.builder()
.name(USE_PATH_STYLE_OPTION)
.type(SymbolUtils.createValueSymbolBuilder("bool")
.putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true)
.build())
.documentation(
"Allows you to enable the client to use path-style addressing, "
+ "i.e., `https://s3.amazonaws.com/BUCKET/KEY`. By default, the S3 client "
+ "will use virtual hosted bucket addressing when possible"
+ "(`https://BUCKET.s3.amazonaws.com/KEY`).")
.build(),
ConfigField.builder()
.name(USE_ACCELERATE_OPTION)
.type(SymbolUtils.createValueSymbolBuilder("bool")
.putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true)
.build())
.documentation("Allows you to enable S3 Accelerate feature. All operations "
+ "compatible with S3 Accelerate will use the accelerate endpoint for "
+ "requests. Requests not compatible will fall back to normal S3 requests. "
+ "The bucket must be enabled for accelerate to be used with S3 client with "
+ "accelerate enabled. If the bucket is not enabled for accelerate an error "
+ "will be returned. The bucket name must be DNS compatible to work "
+ "with accelerate.")
.build(),
ConfigField.builder()
.name(DISABLE_MRAP_OPTION)
.type(SymbolUtils.createValueSymbolBuilder("bool")
.putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true)
.build())
.documentation("Allows you to disable S3 Multi-Region access points feature.")
.build(),
ConfigField.builder()
.name(AwsSignatureVersion4aUtils.V4A_SIGNER_INTERFACE_NAME)
.type(SymbolUtils.createValueSymbolBuilder(
AwsSignatureVersion4aUtils.V4A_SIGNER_INTERFACE_NAME)
.build())
.documentation("Signature Version 4a (SigV4a) Signer")
.build()
))
.build()
);
return list;
}
// retrieves function name for get bucket accessor function
private String getBucketAccessorFuncName(String operationName) {
return getterFuncName(operationName, "BucketMember");
}
private void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
for (OperationShape operation : TopDownIndex.of(model).getContainedOperations(service)) {
goDelegator.useShapeWriter(operation, writer -> {
// generate get bucket member helper function
writeGetBucketMemberHelper(writer, model, symbolProvider, operation);
// generate update endpoint middleware helper function
writeMiddlewareHelper(writer, model, symbolProvider, operation);
});
}
goDelegator.useShapeWriter(service, writer -> {
// generate NOP bucket accessor helper
writeNOPBucketAccessorHelper(writer);
});
}
private void writeMiddlewareHelper(
GoWriter writer,
Model model,
SymbolProvider symbolProvider,
OperationShape operationShape
) {
// imports
writer.addUseImports(SmithyGoDependency.SMITHY_MIDDLEWARE);
// operation name
String operationName = symbolProvider.toSymbol(operationShape).getName();
writer.openBlock("func $L(stack *middleware.Stack, options Options) error {", "}",
addMiddlewareFuncName(symbolProvider.toSymbol(operationShape).getName(),
UPDATE_ENDPOINT_INTERNAL_ADDER), () -> {
writer.write("return $T(stack, $T{ \n"
+ "Accessor : $T{\n"
+ "GetBucketFromInput: $L,\n},\n"
+ "UsePathStyle: options.$L,\n"
+ "UseAccelerate: options.$L,\n"
+ "SupportsAccelerate: $L,\n"
+ "TargetS3ObjectLambda: $L,\n"
+ "EndpointResolver: options.EndpointResolver,\n"
+ "EndpointResolverOptions: options.EndpointOptions,\n"
+ "UseARNRegion: options.$L,\n"
+ "DisableMultiRegionAccessPoints: options.$L,\n"
+ "})",
SymbolUtils.createValueSymbolBuilder(UPDATE_ENDPOINT_INTERNAL_ADDER,
AwsCustomGoDependency.S3_CUSTOMIZATION).build(),
SymbolUtils.createValueSymbolBuilder(UPDATE_ENDPOINT_INTERNAL_OPTIONS,
AwsCustomGoDependency.S3_CUSTOMIZATION).build(),
SymbolUtils.createValueSymbolBuilder(UPDATE_ENDPOINT_INTERNAL_PARAMETER_ACCESSOR,
AwsCustomGoDependency.S3_CUSTOMIZATION).build(),
SUPPORT_BUCKET_AS_INPUT.contains(operationName) ?
getBucketAccessorFuncName(operationName) : NOP_BUCKET_ACCESSOR,
USE_PATH_STYLE_OPTION,
USE_ACCELERATE_OPTION,
!NOT_SUPPORT_ACCELERATE.contains(operationName),
TARGET_OBJECT_LAMBDAS.contains(operationName),
USE_ARNREGION_OPTION,
DISABLE_MRAP_OPTION
);
});
writer.insertTrailingNewline();
}
private void writeNOPBucketAccessorHelper(
GoWriter writer
) {
writer.writeDocs(
String.format("%s is no-op accessor for operation that don't support bucket member as input",
NOP_BUCKET_ACCESSOR)
);
writer.openBlock("func $L(input interface{}) (*string, bool) {", "}", NOP_BUCKET_ACCESSOR,
() -> {
writer.write("return nil, false");
});
writer.insertTrailingNewline();
}
private void writeGetBucketMemberHelper(
GoWriter writer,
Model model,
SymbolProvider symbolProvider,
OperationShape operation
) {
Symbol operationSymbol = symbolProvider.toSymbol(operation);
String operationName = operationSymbol.getName();
String funcName = getBucketAccessorFuncName(operationSymbol.getName());
StructureShape input = model.expectShape(operation.getInput().get(), StructureShape.class);
List<MemberShape> targetBucketShape = input.getAllMembers().values().stream()
.filter(m -> m.getTarget().getName(service).equals("BucketName"))
.collect(Collectors.toList());
// if model has multiple top level shapes targeting `BucketName`, we throw a codegen exception
if (targetBucketShape.size() > 1) {
throw new CodegenException(
"BucketName shape should be targeted by only one input member, found " +
targetBucketShape.size() + " for Input shape: " + input.getId());
}
if (targetBucketShape.isEmpty()) {
return;
}
// add operation to set denoting operation supports bucket input member
SUPPORT_BUCKET_AS_INPUT.add(operationName);
writer.writeDocs(
String.format("%s returns a pointer to string denoting a provided bucket member value"
+ "and a boolean indicating if the input has a modeled bucket name,", funcName)
);
writer.openBlock("func $L(input interface{}) (*string, bool) {", "}", funcName,
() -> {
String targetShapeName = targetBucketShape.get(0).getMemberName();
writer.write("in := input.($P)", symbolProvider.toSymbol(input));
writer.openBlock("if in.$L == nil {", "}", targetShapeName, () -> {
writer.write("return nil, false");
});
writer.write("return in.$L, true", targetShapeName);
});
writer.insertTrailingNewline();
}
}
/**
* s3control class is the private class handling s3control goIntegration for endpoint mutations
*/
private static class S3control {
// nop accessor constants
private static final String NOP_GET_ARN_ACCESSOR = "nopGetARNAccessor";
private static final String NOP_SET_ARN_ACCESSOR = "nopSetARNAccessor";
private static final String NOP_BACKFILL_ACCOUNT_ID_HELPER = "nopBackfillAccountIDAccessor";
private static final String NOP_GET_OUTPOST_ID_FROM_INPUT = "nopGetOutpostIDFromInput";
// Map of service, list of operationName that support ARNs as input
private static final Set<String> supportsARN = new TreeSet<>();
// service associated with this class
private final ServiceShape service;
// List of operations that use Accesspoint field as ARN input source.
private final Set<String> LIST_ACCESSPOINT_ARN_INPUT = SetUtils.of(
"GetAccessPoint", "DeleteAccessPoint", "PutAccessPointPolicy",
"GetAccessPointPolicy", "DeleteAccessPointPolicy"
);
// List of operations that use OutpostID to resolve endpoint
private final Set<String> LIST_OUTPOST_ID_INPUT = SetUtils.of(
"CreateBucket", "ListRegionalBuckets"
);
private S3control(ServiceShape service) {
this.service = service;
}
// returns a function identifier string for backfillAccountID function
private static final String backFillAccountIDFuncName(String operation) {
return String.format("backFill%s%s", operation, "AccountID");
}
// returns a function identifier string for arn member setter function
private static final String setARNMemberFuncName(String operation) {
return setterFuncName(operation, "ARNMember");
}
// returns a function identifier string for arn member getter function
private static final String getARNMemberFuncName(String operation) {
return getterFuncName(operation, "ARNMember");
}
// returns a function identifier string for outpost id member getter function
private static final String getOutpostIDMemberFuncName(String operation) {
return getterFuncName(operation, "OutpostIDMember");
}
void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
for (OperationShape operation : TopDownIndex.of(model).getContainedOperations(service)) {
goDelegator.useShapeWriter(operation, writer -> {
// get input shape from operation
StructureShape input = model.expectShape(operation.getInput().get(), StructureShape.class);
// generate input copy function
writeInputCopy(writer, symbolProvider, input);
// generate outpost id accessor function
writeOutpostIDHelper(writer, model, symbolProvider, operation);
// generate arn helper function
writeARNHelper(writer, model, symbolProvider, operation);
// generate backfill account id helper function
writeBackfillAccountIDHelper(writer, model, symbolProvider, operation);
// generate update endpoint middleware helper function
writeMiddlewareHelper(writer, model, symbolProvider, operation);
});
}
// services must be processed later than operations to help generation of Nop helpers
goDelegator.useShapeWriter(service, writer -> {
// generate outpost id helper function
writeNopOutpostIDHelper(writer);
// generate Nop methods for ARNHelper
writeNopARNHelper(writer);
// generate Nop methods for BackfillAccountIDHelper
writeNopBackfillAccountIDHelper(writer);
});
}
private void writeNopARNHelper(
GoWriter writer
) {
// generate get arn member accessor getter function
writer.writeDocs("nopGetARNAccessor provides a nop get accessor function to be used "
+ "when a certain operation does not support ARNs");
writer.openBlock("func $L (input interface{}) (*string, bool) { ", "}",
NOP_GET_ARN_ACCESSOR, () -> {
writer.write("return nil, false");
});
writer.insertTrailingNewline();
// generate set arn member accessor setter function
writer.writeDocs("nopSetARNAccessor provides a nop set accessor function to be used "
+ "when a certain operation does not support ARNs");
writer.openBlock("func $L (input interface{}, v string) error {", "}",
NOP_SET_ARN_ACCESSOR, () -> {
writer.write("return nil");
});
writer.insertTrailingNewline();
}
private void writeNopBackfillAccountIDHelper(
GoWriter writer
) {
// generate arn member accessor getter function
writer.writeDocs("nopBackfillAccountIDAccessor provides a nop accessor function to be used "
+ "when a certain operation does not need to validate and backfill account id");
writer.openBlock("func $L (input interface{}, v string) error {", "}",
NOP_BACKFILL_ACCOUNT_ID_HELPER, () -> {
writer.write("return nil");
});
writer.insertTrailingNewline();
}
private void writeNopOutpostIDHelper(
GoWriter writer
) {
writer.writeDocs("nopGetOutpostIDFromInput provides a nop accessor function to be used "
+ "when endpoint customization behavior is not based on presence of outpost id member if any");
writer.openBlock("func $L (input interface{}) (*string, bool) {", "}",
NOP_GET_OUTPOST_ID_FROM_INPUT, () -> {
writer.write("return nil, false");
});
writer.insertTrailingNewline();
}
private void writeMiddlewareHelper(
GoWriter writer, Model model, SymbolProvider symbolProvider, OperationShape operationShape
) {
// imports
writer.addUseImports(SmithyGoDependency.SMITHY_MIDDLEWARE);
// input shape
StructureShape inputShape = model.expectShape(operationShape.getInput().get(), StructureShape.class);
String operationName = symbolProvider.toSymbol(operationShape).getName();
writer.openBlock("func $L(stack *middleware.Stack, options Options) error {", "}",
addMiddlewareFuncName(symbolProvider.toSymbol(operationShape).getName(),
UPDATE_ENDPOINT_INTERNAL_ADDER), () -> {
writer.write("return $T(stack, $T{ \n"
+ "Accessor : $T{GetARNInput: $L,\n BackfillAccountID: $L,\n"
+ "GetOutpostIDInput: $L, \n UpdateARNField: $L,\n CopyInput: $L,\n }, \n"
+ "EndpointResolver: options.EndpointResolver,\n "
+ "EndpointResolverOptions: options.EndpointOptions,\n"
+ "UseARNRegion: options.$L, \n })",
SymbolUtils.createValueSymbolBuilder(UPDATE_ENDPOINT_INTERNAL_ADDER,
AwsCustomGoDependency.S3CONTROL_CUSTOMIZATION).build(),
SymbolUtils.createValueSymbolBuilder(UPDATE_ENDPOINT_INTERNAL_OPTIONS,
AwsCustomGoDependency.S3CONTROL_CUSTOMIZATION).build(),
SymbolUtils.createValueSymbolBuilder(UPDATE_ENDPOINT_INTERNAL_PARAMETER_ACCESSOR,
AwsCustomGoDependency.S3CONTROL_CUSTOMIZATION).build(),
supportsARN.contains(operationName) ? getARNMemberFuncName(
operationName) : NOP_GET_ARN_ACCESSOR,
supportsARN.contains(operationName) ? backFillAccountIDFuncName(
operationName) : NOP_BACKFILL_ACCOUNT_ID_HELPER,
LIST_OUTPOST_ID_INPUT.contains(operationName) ? getOutpostIDMemberFuncName(
operationName) : NOP_GET_OUTPOST_ID_FROM_INPUT,
supportsARN.contains(operationName) ? setARNMemberFuncName(
operationName) : NOP_SET_ARN_ACCESSOR,
copyInputFuncName(symbolProvider.toSymbol(inputShape).getName()),
USE_ARNREGION_OPTION
);
});
writer.insertTrailingNewline();
}
/**
* Writes a accessor function that returns an address to copy of passed in input
*
* @param writer
* @param symbolProvider
* @param input
*/
private void writeInputCopy(
GoWriter writer,
SymbolProvider symbolProvider,
StructureShape input
) {
Symbol inputSymbol = symbolProvider.toSymbol(input);
writer.openBlock("func $L(params interface{}) (interface{}, error) {", "}",
copyInputFuncName(inputSymbol.getName()),
() -> {
writer.addUseImports(SmithyGoDependency.FMT);
writer.write("input, ok := params.($P)", inputSymbol);
writer.openBlock("if !ok {", "}", () -> {
writer.write("return nil, fmt.Errorf(\"expect $P type, got %T\", params)", inputSymbol);
});
writer.write("cpy := *input");
writer.write("return &cpy, nil");
});
}
/**
* writes BackfillAccountID Helper function for s3 api operation
* <p>
* Generates code:
* === api_operation.go===
* func backfillAccountID(input interface{}, v string) error {
* in := input.(*OpInputType)
* if in.AccountId!=nil {
* iv := *in.AccountId
* if !strings.EqualFold(iv, v) {
* return fmt.Errorf("error backfilling account id")
* }
* return nil
* }
* <p>
* in.AccountId = &v
* return nil
* }
*/
private void writeBackfillAccountIDHelper(
GoWriter writer, Model model, SymbolProvider symbolProvider, OperationShape operation
) {
StructureShape input = model.expectShape(operation.getInput().get(), StructureShape.class);
List<MemberShape> targetAccountIDShape = input.getAllMembers().values().stream()
.filter(m -> m.getMemberName().equals("AccountId"))
.collect(Collectors.toList());
// if model has multiple top level shapes targeting `AccountId`, we throw a codegen exception
if (targetAccountIDShape.size() > 1) {
throw new CodegenException("AccountId shape should be targeted by only one input member, found " +
targetAccountIDShape.size() + " for Input shape: " + input.getId());
}
if (targetAccountIDShape.isEmpty()) {
return;
}
Symbol inputSymbol = symbolProvider.toSymbol(input);
writer.write("func $L (input interface{}, v string) error { ",
backFillAccountIDFuncName(symbolProvider.toSymbol(operation).getName()));
String memberName = targetAccountIDShape.get(0).getMemberName();
writer.write("in := input.($P)", inputSymbol);
writer.write("if in.$L != nil {", memberName);
writer.addUseImports(SmithyGoDependency.STRINGS);
writer.write("if !strings.EqualFold(*in.$L, v) {", memberName);
writer.addUseImports(SmithyGoDependency.FMT);
writer.write("return fmt.Errorf(\"error backfilling account id\") }");
writer.write("return nil }");
writer.write("in.$L = &v", memberName);
writer.write("return nil }");
writer.insertTrailingNewline();
}
/**
* writes getARNMemberValue and updateARNMemberValue update function for all api input operations
*/
private void writeARNHelper(
GoWriter writer, Model model, SymbolProvider symbolProvider, OperationShape operation
) {
// list of outpost id input require special behavior
if (LIST_OUTPOST_ID_INPUT.contains(operation.getId().getName(service))) {
return;
}
// arn target shape
String arnType = LIST_ACCESSPOINT_ARN_INPUT.contains(
operation.getId().getName(service)
) ? "AccessPointName" : "BucketName";
StructureShape input = model.expectShape(operation.getInput().get(), StructureShape.class);
List<MemberShape> listOfARNMembers = input.getAllMembers().values().stream()
.filter(m -> m.getTarget().getName(service).equals(arnType))
.collect(Collectors.toList());
// if model has multiple top level shapes targeting arnable field, we throw a codegen exception
if (listOfARNMembers.size() > 1) {
throw new CodegenException(arnType + " shape should be targeted by only one input member, found " +
listOfARNMembers.size() + " for Input shape: " + input.getId());
}
if (listOfARNMembers.isEmpty()) {
return;
}
String operationName = symbolProvider.toSymbol(operation).getName();
// this operation supports taking arn as input
supportsARN.add(operationName);
Symbol inputSymbol = symbolProvider.toSymbol(input);
String memberName = listOfARNMembers.get(0).getMemberName();
// generate arn member accessor getter function
writer.write("func $L (input interface{}) (*string, bool) {",
getARNMemberFuncName(symbolProvider.toSymbol(operation).getName()));
writer.write("in := input.($P)", inputSymbol);
writer.write("if in.$L == nil {return nil, false }", memberName);
writer.write("return in.$L, true }", memberName);
writer.insertTrailingNewline();
// generate arn member accessor setter function
writer.write("func $L (input interface{}, v string) error {",
setARNMemberFuncName(symbolProvider.toSymbol(operation).getName()));
writer.write("in := input.($P)", inputSymbol);
writer.write("in.$L = &v", memberName);
writer.write("return nil }");
writer.insertTrailingNewline();
}
/**
* writes OutpostID Helper function for operations CreateBucket and ListRegionalBuckets
* <p>
* Generates code:
* func get<OpName>OutpostIDHelper</> (in interface{}) (*string, bool) {
* i, ok := input.(*OpName)
* if !ok {
* return nil, fmt.Errorf("Expected input of type *OpName, got %T", input)
* }
* return i.<MemberName>, nil
* }
*/
private void writeOutpostIDHelper(
GoWriter writer,
Model model,
SymbolProvider symbolProvider,
OperationShape operation
) {
String operationName = symbolProvider.toSymbol(operation).getName();
if (!LIST_OUTPOST_ID_INPUT.contains(operationName)) {
return;
}
String funcName = getOutpostIDMemberFuncName(operationName);
writer.writeDocs(
String.format("%s returns a pointer to string denoting a provided outpost-id member value"
+ " and a boolean indicating if the input has a modeled outpost-id,", funcName));
writer.openBlock("func $L (input interface{}) (*string, bool) {", "}",
funcName, () -> {
StructureShape input = model.expectShape(operation.getInput().get(),
StructureShape.class);
List<MemberShape> outpostIDMemberShapes = input.getAllMembers().values().stream()
.filter(m -> m.getMemberName().equalsIgnoreCase("OutpostId"))
.collect(Collectors.toList());
// if model has multiple top level shapes targeting `OutpostId`, we throw a codegen exception
if (outpostIDMemberShapes.size() > 1) {
throw new CodegenException(
"OutpostID shape should be targeted by only one input member, found " +
outpostIDMemberShapes.size() + " for Input shape: " + input.getId());
}
if (outpostIDMemberShapes.isEmpty()) {
LIST_OUTPOST_ID_INPUT.remove(operationName);
}
Symbol inputSymbol = symbolProvider.toSymbol(input);
String memberName = outpostIDMemberShapes.get(0).getMemberName();
writer.write("in := input.($P)", inputSymbol);
writer.openBlock("if in.$L == nil {", "}", memberName, () -> {
writer.write("return nil, false");
});
writer.write("return in.$L, true", memberName);
});
}
}
}
| 8,346 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/MachineLearningCustomizations.java | package software.amazon.smithy.aws.go.codegen.customization;
import java.util.List;
import software.amazon.smithy.aws.traits.ServiceTrait;
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.GoIntegration;
import software.amazon.smithy.go.codegen.integration.MiddlewareRegistrar;
import software.amazon.smithy.go.codegen.integration.ProtocolUtils;
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.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.utils.ListUtils;
public class MachineLearningCustomizations implements GoIntegration {
private static final String ADD_PREDICT_ENDPOINT = "AddPredictEndpointMiddleware";
private static final String ENDPOINT_ACCESSOR = "getPredictEndpoint";
@Override
public byte getOrder() {
// This needs to be run after the generic endpoint resolver gets added
return 50;
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return ListUtils.of(
RuntimeClientPlugin.builder()
.operationPredicate(MachineLearningCustomizations::isPredict)
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(ADD_PREDICT_ENDPOINT,
AwsCustomGoDependency.MACHINE_LEARNING_CUSTOMIZATION).build())
.functionArguments(ListUtils.of(
SymbolUtils.createValueSymbolBuilder(ENDPOINT_ACCESSOR).build()
))
.build())
.build()
);
}
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
ServiceShape service = settings.getService(model);
if (!isMachineLearning(model, service)) {
return;
}
TopDownIndex.of(model).getContainedOperations(service).stream()
.filter(shape -> shape.getId().getName(service).equalsIgnoreCase("Predict"))
.findAny()
.ifPresent(operation -> {
goDelegator.useShapeWriter(operation, writer -> writeEndpointAccessor(
writer, model, symbolProvider, operation));
});
}
private void writeEndpointAccessor(
GoWriter writer,
Model model,
SymbolProvider symbolProvider,
OperationShape operation
) {
StructureShape input = ProtocolUtils.expectInput(model, operation);
writer.openBlock("func $L(input interface{}) (*string, error) {", "}", ENDPOINT_ACCESSOR, () -> {
writer.write("in, ok := input.($P)", symbolProvider.toSymbol(input));
writer.openBlock("if !ok {", "}", () -> {
writer.addUseImports(SmithyGoDependency.SMITHY);
writer.addUseImports(SmithyGoDependency.FMT);
writer.write("return nil, &smithy.SerializationError{Err: fmt.Errorf("
+ "\"expected $P, but was %T\", input)}", symbolProvider.toSymbol(input));
});
writer.write("return in.PredictEndpoint, nil");
});
}
private static boolean isPredict(Model model, ServiceShape service, OperationShape operation) {
return isMachineLearning(model, service) && operation.getId().getName(service).equalsIgnoreCase("Predict");
}
private static boolean isMachineLearning(Model model, ServiceShape service) {
return service.expectTrait(ServiceTrait.class).getSdkId().equalsIgnoreCase("Machine Learning");
}
}
| 8,347 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/Route53Customizations.java | package software.amazon.smithy.aws.go.codegen.customization;
import java.util.List;
import java.util.stream.Collectors;
import software.amazon.smithy.aws.traits.ServiceTrait;
import software.amazon.smithy.codegen.core.CodegenException;
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.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.MemberShape;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.utils.ListUtils;
public class Route53Customizations implements GoIntegration {
private static final String ADD_ERROR_HANDLER_INTERNAL = "HandleCustomErrorDeserialization";
private static final String URL_SANITIZE_ADDER = "addSanitizeURLMiddleware";
private static final String URL_SANITIZE_INTERNAL_ADDER= "AddSanitizeURLMiddleware";
private static final String SANITIZE_URL_INPUT = "sanitizeURLInput";
@Override
public byte getOrder() {
// The associated customization ordering is relative to operation deserializers
// and thus the integration should be added at the end.
return 127;
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return ListUtils.of(
RuntimeClientPlugin.builder()
.operationPredicate(Route53Customizations::supportsCustomError)
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(ADD_ERROR_HANDLER_INTERNAL,
AwsCustomGoDependency.ROUTE53_CUSTOMIZATION).build())
.build())
.build(),
RuntimeClientPlugin.builder()
.operationPredicate(Route53Customizations::supportsSanitizeURLValue)
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(URL_SANITIZE_ADDER).build())
.build())
.build()
);
}
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
if (!isRoute53Service(model, settings.getService(model))) {
return;
}
ServiceShape service = settings.getService(model);
goDelegator.useShapeWriter(service, this::writeMiddlewareHelper);
goDelegator.useShapeWriter(service, writer -> {
writeURLInputSanitizer(writer, model, symbolProvider, service);
});
}
private void writeMiddlewareHelper(GoWriter writer) {
writer.openBlock("func $L(stack *middleware.Stack) error {", "}", URL_SANITIZE_ADDER, () -> {
writer.write("return $T(stack, $T{SanitizeURLInput: $L})",
SymbolUtils.createValueSymbolBuilder(URL_SANITIZE_INTERNAL_ADDER,
AwsCustomGoDependency.ROUTE53_CUSTOMIZATION).build(),
SymbolUtils.createValueSymbolBuilder(URL_SANITIZE_INTERNAL_ADDER + "Options",
AwsCustomGoDependency.ROUTE53_CUSTOMIZATION).build(),
SANITIZE_URL_INPUT
);
});
writer.insertTrailingNewline();
}
private void writeURLInputSanitizer(
GoWriter writer,
Model model,
SymbolProvider symbolProvider,
ServiceShape service
) {
writer.writeDocs("Check for and split apart Route53 resource IDs, setting only the last piece. " +
"This allows the output of one operation e.g. foo/1234 to be used as input in another operation " +
"(e.g. it expects just '1234')");
writer.openBlock("func sanitizeURLInput(input interface{}) error {", "}", () -> {
writer.openBlock("switch i:= input.(type) {", "}", () -> {
TopDownIndex.of(model).getContainedOperations(service).forEach((operation)-> {
StructureShape input = model.expectShape(operation.getInput().get(), StructureShape.class);
List<MemberShape> resourceMembers = getResourceMembers(service, input);
if (!resourceMembers.isEmpty()){
writer.openBlock("case $P :", "", symbolProvider.toSymbol(input), () -> {
writer.addUseImports(SmithyGoDependency.STRINGS);
for (MemberShape member : resourceMembers) {
String memberName = member.getMemberName();
writer.openBlock("if i.$L != nil {", "}", memberName, () -> {
writer.write("idx := strings.LastIndex(*i.$L, `/`)", memberName);
writer.write("v := (*i.$L)[idx+1:]", memberName);
writer.write("i.$L = &v", memberName);
});
}
});
}
});
writer.write("default: break");
});
writer.write("return nil");
});
}
private static List<MemberShape> getResourceMembers(ServiceShape service, StructureShape input) {
return input.getAllMembers().values().stream()
.filter(m -> m.getTarget().getName(service).equalsIgnoreCase("ResourceId")
|| m.getTarget().getName(service).equalsIgnoreCase("DelegationSetId")
|| m.getTarget().getName(service).equalsIgnoreCase("ChangeId"))
.collect(Collectors.toList());
}
// returns true if the operation supports custom route53 error response
private static boolean supportsCustomError(Model model, ServiceShape service, OperationShape operation) {
if (!isRoute53Service(model, service)) {
return false;
}
return operation.getId().getName(service).equalsIgnoreCase("ChangeResourceRecordSets");
}
// return true if the operation takes input that supports resource sanitization.
//
// For Route53, HostedZoneID, and changeID is supported by member shapes targeting `ResourceId` or `DelegationSetId`.
private static boolean supportsSanitizeURLValue(Model model, ServiceShape service, OperationShape operation) {
if (!isRoute53Service(model, service)) {
return false;
}
StructureShape input = model.expectShape(operation.getInput().get(), StructureShape.class);
List<MemberShape> targetMembers = getResourceMembers(service, input);
if (targetMembers.size() >1 ){
throw new CodegenException(String.format("Route53 service has ResourceId, DelegationSetId members " +
"modeled on %s shape", input.getId().getName(service)));
}
return targetMembers.size() != 0;
}
// returns true if service is route53
private static boolean isRoute53Service(Model model, ServiceShape service) {
String serviceId= service.expectTrait(ServiceTrait.class).getSdkId();
return serviceId.equalsIgnoreCase("Route 53");
}
}
| 8,348 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3GetBucketLocation.java | package software.amazon.smithy.aws.go.codegen.customization;
import java.util.List;
import software.amazon.smithy.aws.go.codegen.XmlProtocolUtils;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.codegen.core.Symbol;
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.GoStackStepMiddlewareGenerator;
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.GoIntegration;
import software.amazon.smithy.go.codegen.integration.MiddlewareRegistrar;
import software.amazon.smithy.go.codegen.integration.ProtocolGenerator;
import software.amazon.smithy.go.codegen.integration.ProtocolUtils;
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.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.utils.ListUtils;
/**
* This integration generates a custom deserializer for GetBucketLocation response.
* Amazon S3 service does not wrap the GetBucketLocation response with Operation
* name xml tags, and thus custom deserialization is required.
* <p>
* Related to aws/aws-sdk-go-v2#908
*/
public class S3GetBucketLocation implements GoIntegration {
private final String protocolName = "awsRestxml";
private final String swapDeserializerFuncName = "swapDeserializerHelper";
private final String getBucketLocationOpID = "GetBucketLocation";
/**
* Return true if service is Amazon S3.
*
* @param model is the generation model.
* @param service is the service shape being audited.
*/
private static boolean isS3Service(Model model, ServiceShape service) {
return S3ModelUtils.isServiceS3(model, service);
}
/**
* returns name of the deserializer middleware written wrt this customization.
*
* @param service the service closure for the operation.
* @param operation the operation for which custom deserializer is generated.
*/
private String getDeserializeMiddlewareName(ServiceShape service, OperationShape operation) {
return ProtocolGenerator.getDeserializeMiddlewareName(operation.getId(), service, protocolName) + "_custom";
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return ListUtils.of(
RuntimeClientPlugin.builder()
.operationPredicate((model, service, operation) -> {
return isS3Service(model, service) && operation.getId().getName()
.equals(getBucketLocationOpID);
})
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(
SymbolUtils.createValueSymbolBuilder(swapDeserializerFuncName).build())
.build())
.build()
);
}
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
ShapeId serviceId = settings.getService();
ServiceShape service = model.expectShape(serviceId, ServiceShape.class);
if (!isS3Service(model, service)) {
return;
}
for (OperationShape operation : TopDownIndex.of(model).getContainedOperations(service)) {
if (!(operation.getId().getName(service).equals(getBucketLocationOpID))) {
continue;
}
goDelegator.useShapeWriter(operation, writer -> {
writeCustomDeserializer(writer, model, symbolProvider, service, operation);
writeDeserializerSwapFunction(writer, service, operation);
});
}
}
/**
* writes helper function to swap deserialization middleware with the generated
* custom deserializer middleware.
*
* @param writer is the go writer used
* @param operation is the operation for which swap function is written.
*/
private void writeDeserializerSwapFunction(
GoWriter writer,
ServiceShape service,
OperationShape operation
) {
writer.writeDocs("Helper to swap in a custom deserializer");
writer.openBlock("func $L(stack *middleware.Stack) error{", "}",
swapDeserializerFuncName, () -> {
writer.write("_, err := stack.Deserialize.Swap($S, &$L{})",
ProtocolUtils.OPERATION_DESERIALIZER_MIDDLEWARE_ID.getString(),
getDeserializeMiddlewareName(service, operation)
);
writer.write("if err != nil { return err }");
writer.write("return nil");
});
}
/**
* writes a custom deserializer middleware for the provided operation.
*
* @param goWriter is the go writer used.
* @param model is the generation model.
* @param symbolProvider is the symbol provider.
* @param operation is the operation shape for which custom deserializer is written.
*/
private void writeCustomDeserializer(
GoWriter goWriter,
Model model,
SymbolProvider symbolProvider,
ServiceShape service,
OperationShape operation
) {
GoStackStepMiddlewareGenerator middleware = GoStackStepMiddlewareGenerator.createDeserializeStepMiddleware(
getDeserializeMiddlewareName(service, operation), ProtocolUtils.OPERATION_DESERIALIZER_MIDDLEWARE_ID);
String errorFunctionName = ProtocolGenerator.getOperationErrorDeserFunctionName(
operation, service, protocolName);
middleware.writeMiddleware(goWriter, (generator, writer) -> {
writer.addUseImports(SmithyGoDependency.FMT);
writer.write("out, metadata, err = next.$L(ctx, in)", generator.getHandleMethodName());
writer.write("if err != nil { return out, metadata, err }");
writer.write("");
writer.addUseImports(SmithyGoDependency.SMITHY_HTTP_TRANSPORT);
writer.write("response, ok := out.RawResponse.(*smithyhttp.Response)");
writer.openBlock("if !ok {", "}", () -> {
writer.addUseImports(SmithyGoDependency.SMITHY);
writer.write(String.format("return out, metadata, &smithy.DeserializationError{Err: %s}",
"fmt.Errorf(\"unknown transport type %T\", out.RawResponse)"));
});
writer.write("");
writer.openBlock("if response.StatusCode < 200 || response.StatusCode >= 300 {", "}", () -> {
writer.write("return out, metadata, $L(response, &metadata)", errorFunctionName);
});
Shape outputShape = model.expectShape(operation.getOutput()
.orElseThrow(() -> new CodegenException("expect output shape for operation: " + operation.getId()))
);
Symbol outputSymbol = symbolProvider.toSymbol(outputShape);
// initialize out.Result as output structure shape
writer.write("output := &$T{}", outputSymbol);
writer.write("out.Result = output");
writer.write("");
writer.addUseImports(SmithyGoDependency.XML);
writer.addUseImports(SmithyGoDependency.SMITHY_XML);
writer.addUseImports(SmithyGoDependency.IO);
writer.addUseImports(SmithyGoDependency.SMITHY_IO);
writer.write("var buff [1024]byte");
writer.write("ringBuffer := smithyio.NewRingBuffer(buff[:])");
writer.write("body := io.TeeReader(response.Body, ringBuffer)");
writer.write("rootDecoder := xml.NewDecoder(body)");
// define a decoder with empty start element since we s3 does not wrap Location Constraint
// xml tag with operation specific xml tag.
writer.write("decoder := smithyxml.WrapNodeDecoder(rootDecoder, xml.StartElement{})");
String deserFuncName = ProtocolGenerator.getDocumentDeserializerFunctionName(outputShape, service, protocolName);
writer.addUseImports(SmithyGoDependency.IO);
// delegate to already generated inner body deserializer function.
writer.write("err = $L(&output, decoder)", deserFuncName);
// EOF error is valid in this case, as we provide a NOP start element at start.
// Note that we correctly handle unexpected EOF.
writer.addUseImports(SmithyGoDependency.IO);
writer.write("if err == io.EOF { err = nil }");
XmlProtocolUtils.handleDecodeError(writer, "out, metadata,");
writer.write("");
writer.write("return out, metadata, err");
});
}
}
| 8,349 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3ContentSHA256Header.java | package software.amazon.smithy.aws.go.codegen.customization;
import java.util.List;
import java.util.Optional;
import software.amazon.smithy.aws.go.codegen.AwsGoDependency;
import software.amazon.smithy.aws.traits.auth.UnsignedPayloadTrait;
import software.amazon.smithy.go.codegen.SymbolUtils;
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.shapes.MemberShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.model.traits.StreamingTrait;
import software.amazon.smithy.utils.ListUtils;
public class S3ContentSHA256Header implements GoIntegration {
/**
* Gets the sort order of the customization from -128 to 127, with lowest
* executed first.
*
* @return Returns the sort order, defaults to -40.
*/
@Override
public byte getOrder() {
return 127;
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return ListUtils.of(
RuntimeClientPlugin.builder()
// Only add the middleware if UnsignedPayloadTrait is not specified, as this middleware
// will have already been added.
.operationPredicate((model, service, operation) -> {
if (!(S3ModelUtils.isServiceS3(model, service)
|| S3ModelUtils.isServiceS3Control(model, service))) {
return false;
}
return !operation.hasTrait(UnsignedPayloadTrait.class);
})
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(
"AddContentSHA256HeaderMiddleware",
AwsGoDependency.AWS_SIGNER_V4
).build())
.build())
.build(),
RuntimeClientPlugin.builder()
// If a S3 operation has a streaming payload but is not event stream payload,
// client swaps signing middleware to use dynamic payload signing middleware.
// This enables client to use unsigned payload when TLS is enabled, and switch
// to signed payload for security when TLS is disabled.
.operationPredicate(((model, service, operation) -> {
if (!(S3ModelUtils.isServiceS3(model, service))) {
return false;
}
Optional<ShapeId> input = operation.getInput();
if (!input.isPresent()) {
return false;
}
StructureShape inputShape = model.expectShape(input.get(), StructureShape.class);
for (MemberShape memberShape : inputShape.getAllMembers().values()) {
Shape targetShape = model.expectShape(memberShape.getTarget());
if (targetShape.hasTrait(StreamingTrait.class)
&& !StreamingTrait.isEventStream(model, memberShape)) {
return true;
}
}
return false;
}))
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(
"UseDynamicPayloadSigningMiddleware", AwsGoDependency.AWS_SIGNER_V4
).build())
.build())
.build()
);
}
}
| 8,350 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/EventBridgeMultiRegionEndpoint.java | package software.amazon.smithy.aws.go.codegen.customization;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import software.amazon.smithy.aws.go.codegen.AddAwsConfigFields;
import software.amazon.smithy.aws.go.codegen.AwsEndpointGenerator;
import software.amazon.smithy.aws.go.codegen.AwsSignatureVersion4;
import software.amazon.smithy.aws.go.codegen.AwsSignatureVersion4aUtils;
import software.amazon.smithy.aws.go.codegen.EndpointGenerator;
import software.amazon.smithy.aws.traits.ServiceTrait;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.codegen.core.Symbol;
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.ConfigFieldResolver;
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.OperationIndex;
import software.amazon.smithy.model.knowledge.TopDownIndex;
import software.amazon.smithy.model.shapes.MemberShape;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.shapes.ShapeType;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.utils.ListUtils;
import software.amazon.smithy.utils.MapUtils;
/**
* This integration configures the EventBridge client for Signature Version 4a
*/
public class EventBridgeMultiRegionEndpoint implements GoIntegration {
private static Map<ShapeId, String> SUPPORTED_OPERATIONS = MapUtils.of(
ShapeId.from("com.amazonaws.eventbridge#PutEvents"), "EndpointId"
);
/**
* Return true if service is .
*
* @param model is the generation model.
* @param service is the service shape being audited.
*/
private static boolean isEventBridgeService(Model model, ServiceShape service) {
var serviceId = service.expectTrait(ServiceTrait.class).getSdkId();
return serviceId.equalsIgnoreCase("EventBridge");
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
var resolver = SymbolUtils.createValueSymbolBuilder(
AwsSignatureVersion4aUtils.RESOLVE_CREDENTIAL_PROVIDER).build();
List<RuntimeClientPlugin> plugins = new ArrayList<>();
for (var operationId : SUPPORTED_OPERATIONS.keySet()) {
plugins.add(RuntimeClientPlugin.builder()
.operationPredicate((m, s, o) -> {
if (!isEventBridgeService(m, s)) {
return false;
}
return o.toShapeId().equals(operationId);
})
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(
getEndpointMiddlewareHelperName(operationId.getName()))
.build())
.useClientOptions()
.build())
.build());
}
plugins.addAll(ListUtils.of(RuntimeClientPlugin.builder()
.addConfigFieldResolver(ConfigFieldResolver.builder()
.location(ConfigFieldResolver.Location.CLIENT)
.target(ConfigFieldResolver.Target.FINALIZATION)
.resolver(resolver)
.build())
.addConfigFieldResolver(ConfigFieldResolver.builder()
.location(ConfigFieldResolver.Location.OPERATION)
.target(ConfigFieldResolver.Target.FINALIZATION)
.resolver(resolver)
.build())
.servicePredicate((model, serviceShape) -> {
if (!EventBridgeMultiRegionEndpoint.isEventBridgeService(model, serviceShape)) {
return false;
}
return AwsSignatureVersion4.isSupportedAuthentication(model, serviceShape);
})
.build(),
RuntimeClientPlugin.builder()
.servicePredicate(EventBridgeMultiRegionEndpoint::isEventBridgeService)
.addConfigField(ConfigField.builder()
.name(AwsSignatureVersion4aUtils.V4A_SIGNER_INTERFACE_NAME)
.type(SymbolUtils.createValueSymbolBuilder(
AwsSignatureVersion4aUtils.V4A_SIGNER_INTERFACE_NAME)
.build())
.documentation("Signature Version 4a (SigV4a) Signer")
.build())
.build(),
// Add HTTPSigner middleware to operation stack
RuntimeClientPlugin.builder()
.servicePredicate(EventBridgeMultiRegionEndpoint::isEventBridgeService)
.operationPredicate((model, service, operation) -> {
if (!isEventBridgeService(model, service)) {
return false;
}
return SUPPORTED_OPERATIONS.containsKey(operation.toShapeId());
})
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(
AwsSignatureVersion4aUtils.REGISTER_MIDDLEWARE_FUNCTION).build())
.useClientOptions()
.build())
.build(),
RuntimeClientPlugin.builder()
.servicePredicate(EventBridgeMultiRegionEndpoint::isEventBridgeService)
.addConfigFieldResolver(
ConfigFieldResolver.builder()
.location(ConfigFieldResolver.Location.CLIENT)
.target(ConfigFieldResolver.Target.INITIALIZATION)
.resolver(SymbolUtils.createValueSymbolBuilder(
AwsSignatureVersion4aUtils.SIGNER_RESOLVER).build())
.build())
.build()
));
return plugins;
}
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
if (!isEventBridgeService(model, model.expectShape(settings.getService(), ServiceShape.class))) {
return;
}
if (SUPPORTED_OPERATIONS.size() == 0) {
return;
}
var serviceShape = settings.getService(model);
goDelegator.useShapeWriter(serviceShape, writer -> {
writeCredentialProviderResolver(writer);
writeSigningMiddlewareRegister(model, writer, serviceShape);
writerSignerInterface(writer);
writerSignerConfigFieldResolver(writer, serviceShape);
writeNewV4ASignerFunc(writer, serviceShape);
});
for (var operationShape : TopDownIndex.of(model).getContainedOperations(serviceShape)) {
if (!SUPPORTED_OPERATIONS.containsKey(operationShape.toShapeId())) {
continue;
}
goDelegator.useShapeWriter(operationShape, writer -> {
writeEndpointIdAccessorHelper(writer, model, symbolProvider, operationShape);
writeEndpointMiddlewareHelper(writer, model, symbolProvider, operationShape);
});
}
}
private void writeCredentialProviderResolver(GoWriter writer) {
AwsSignatureVersion4aUtils.writeCredentialProviderResolver(writer);
}
private void writerSignerInterface(GoWriter writer) {
AwsSignatureVersion4aUtils.writerSignerInterface(writer);
}
private void writerSignerConfigFieldResolver(GoWriter writer, ServiceShape serviceShape) {
AwsSignatureVersion4aUtils.writerConfigFieldResolver(writer, serviceShape);
}
private void writeNewV4ASignerFunc(GoWriter writer, ServiceShape serviceShape) {
AwsSignatureVersion4aUtils.writeNewV4ASignerFunc(writer, serviceShape);
}
private void writeSigningMiddlewareRegister(Model model, GoWriter writer, ServiceShape serviceShape) {
AwsSignatureVersion4aUtils.writeMiddlewareRegister(model, writer, serviceShape,
AwsCustomGoDependency.EVENTBRIDGE_CUSTOMIZATION);
}
// retrieves function name for get bucket accessor function
private String getEndpointIdAccessorName(String operationName, String memberName) {
return String.format("get%s%s", operationName, memberName);
}
private String getEndpointMiddlewareHelperName(String operationName) {
return String.format("add%s%s", operationName, "UpdateEndpoint");
}
private void writeEndpointMiddlewareHelper(
GoWriter writer,
Model model,
SymbolProvider symbolProvider,
OperationShape operationShape
) {
var opShapeId = operationShape.toShapeId();
var input = OperationIndex.of(model).getInput(opShapeId).get();
var memberShape = input.getMember(SUPPORTED_OPERATIONS.get(opShapeId)).get();
writer.pushState();
writer.putContext("middlewareAdder", getEndpointMiddlewareHelperName(opShapeId.getName()));
writer.putContext("stackType", SymbolUtils.createPointableSymbolBuilder("Stack",
SmithyGoDependency.SMITHY_MIDDLEWARE).build());
writer.putContext("regHelper", SymbolUtils.createPointableSymbolBuilder("UpdateEndpoint",
AwsCustomGoDependency.EVENTBRIDGE_CUSTOMIZATION).build());
writer.putContext("helperOptions", SymbolUtils.createPointableSymbolBuilder("UpdateEndpointOptions",
AwsCustomGoDependency.EVENTBRIDGE_CUSTOMIZATION).build());
writer.putContext("memberHelper", getEndpointIdAccessorName(operationShape.getId().getName(),
memberShape.getMemberName()));
writer.putContext("resolver", AwsEndpointGenerator.ENDPOINT_RESOLVER_CONFIG_NAME);
writer.putContext("resolverOptions", AwsEndpointGenerator.ENDPOINT_OPTIONS_CONFIG_NAME);
writer.write("""
func $middlewareAdder:L(stack $stackType:P, o Options) error {
return $regHelper:T(stack, $helperOptions:T{
GetEndpointIDFromInput: $memberHelper:L,
EndpointResolver: o.$resolver:L,
EndpointResolverOptions: o.$resolverOptions:L,
})
}
""");
writer.popState();
}
private void writeEndpointIdAccessorHelper(
GoWriter writer,
Model model,
SymbolProvider symbolProvider,
OperationShape operationShape
) {
var opShapeId = operationShape.toShapeId();
var input = OperationIndex.of(model).getInput(opShapeId).get();
var memberShape = input.getMember(SUPPORTED_OPERATIONS.get(opShapeId)).get();
// limit to string for now
if (model.expectShape(memberShape.getTarget()).getType() != ShapeType.STRING) {
throw new CodegenException("expect EventBridge EndpointId shape type to be string");
}
var accessorName = getEndpointIdAccessorName(operationShape.getId().getName(),
memberShape.getMemberName());
writer.pushState();
writer.putContext("funcName", accessorName);
writer.putContext("inputShape", symbolProvider.toSymbol(input));
writer.putContext("memberName", memberShape.getMemberName());
writer.writeDocs(String.format("""
%s returns a pointer to string denoting a provided member value and a boolean indicating if the
value is not nil
""", accessorName));
writer.write("""
func $funcName:L(input interface{}) (*string, bool) {
in := input.($inputShape:P)
if in.$memberName:L == nil {
return nil, false
}
return in.$memberName:L, true
}
""");
writer.popState();
}
}
| 8,351 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3MetadataRetriever.java | package software.amazon.smithy.aws.go.codegen.customization;
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.SymbolUtils;
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.shapes.ServiceShape;
import software.amazon.smithy.utils.ListUtils;
/**
* Retrieves S3 specific metadata such as host id, request id from Deserialized response, and
* sets it on middleware's metadata.
*/
public class S3MetadataRetriever implements GoIntegration {
private static final String ADD_METADATA_RETRIEVER = "addMetadataRetrieverMiddleware";
private static final String ADD_METADATA_RETRIEVER_INTERNAL = "AddMetadataRetrieverMiddleware";
/**
* Gets the sort order of the customization from -128 to 127, with lowest
* executed first.
*
* @return Returns the sort order, defaults to -40.
*/
@Override
public byte getOrder() {
return 126;
}
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
ServiceShape service = settings.getService(model);
if (!requiresS3Customization(model, service)) {
return;
}
goDelegator.useShapeWriter(service, this::writeMiddlewareHelper);
}
private void writeMiddlewareHelper(GoWriter writer) {
writer.openBlock("func $L(stack *middleware.Stack) error {", "}", ADD_METADATA_RETRIEVER, () -> {
writer.write("return $T(stack)",
SymbolUtils.createValueSymbolBuilder(ADD_METADATA_RETRIEVER_INTERNAL,
AwsCustomGoDependency.S3_SHARED_CUSTOMIZATION).build()
);
});
writer.insertTrailingNewline();
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return ListUtils.of(
RuntimeClientPlugin.builder()
.servicePredicate(S3MetadataRetriever::requiresS3Customization)
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(ADD_METADATA_RETRIEVER).build())
.build())
.build()
);
}
// returns true if service is either s3 or s3 control and needs s3 customization
private static boolean requiresS3Customization(Model model, ServiceShape service) {
return S3ModelUtils.isServiceS3(model, service) || S3ModelUtils.isServiceS3Control(model, service);
}
}
| 8,352 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3100Continue.java | package software.amazon.smithy.aws.go.codegen.customization;
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.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.shapes.ServiceShape;
import software.amazon.smithy.model.traits.HttpTrait;
import software.amazon.smithy.utils.ListUtils;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* Add middleware, which adds {Expect: 100-continue} header for s3 client HTTP PUT request larger than 2MB
* or with unknown size streaming bodies, during operation builder step
*/
public class S3100Continue implements GoIntegration {
private static final String ADD_100Continue_Header = "add100Continue";
private static final String ADD_100Continue_Header_INTERNAL = "Add100Continue";
private static final String Continue_Client_Option = "ContinueHeaderThresholdBytes";
private static final Set<String> Put_Op_ShapeId_Set = new HashSet<>(Arrays.asList("com.amazonaws.s3#PutObject", "com.amazonaws.s3#UploadPart"));
/**
* Return true if service is Amazon S3.
*
* @param model is the generation model.
* @param service is the service shape being audited.
*/
private static boolean isS3Service(Model model, ServiceShape service) {
return S3ModelUtils.isServiceS3(model, service);
}
/**
* Gets the sort order of the customization from -128 to 127, with lowest
* executed first.
*
* @return Returns the sort order, defaults to -40.
*/
@Override
public byte getOrder() {
return 126;
}
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
ServiceShape service = settings.getService(model);
if (!isS3Service(model, service)) {
return;
}
goDelegator.useShapeWriter(service, this::writeMiddlewareHelper);
}
private void writeMiddlewareHelper(GoWriter writer) {
writer.openBlock("func $L(stack *middleware.Stack, options Options) error {", "}", ADD_100Continue_Header, () -> {
writer.write("return $T(stack, options.ContinueHeaderThresholdBytes)",
SymbolUtils.createValueSymbolBuilder(ADD_100Continue_Header_INTERNAL,
AwsCustomGoDependency.S3_SHARED_CUSTOMIZATION).build()
);
});
writer.insertTrailingNewline();
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return ListUtils.of(
RuntimeClientPlugin.builder()
.operationPredicate((model, service, operation) ->
isS3Service(model, service) && Put_Op_ShapeId_Set.contains(operation.getId().toString())
)
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(ADD_100Continue_Header).build())
.useClientOptions()
.build()
)
.build(),
RuntimeClientPlugin.builder()
.servicePredicate(S3100Continue::isS3Service)
.configFields(ListUtils.of(
ConfigField.builder()
.name(Continue_Client_Option)
.type(SymbolUtils.createValueSymbolBuilder("int64")
.putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true)
.build())
.documentation("The threshold ContentLength in bytes for HTTP PUT request to receive {Expect: 100-continue} header. " +
"Setting to -1 will disable adding the Expect header to requests; setting to 0 will set the threshold " +
"to default 2MB")
.build()
))
.build()
);
}
}
| 8,353 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/APIGatewayAcceptHeader.java | /*
* 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.aws.go.codegen.customization;
import java.util.List;
import software.amazon.smithy.aws.traits.ServiceTrait;
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.SymbolUtils;
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.shapes.ServiceShape;
import software.amazon.smithy.utils.ListUtils;
/**
* APIGatewayAcceptHeader integrations is used to add an accept header as customization for APIGateway service
*/
public class APIGatewayAcceptHeader implements GoIntegration {
private static final String ADD_ACCEPT_HEADER = "addAcceptHeader";
private static final String ACCEPT_HEADER_INTERNAL_ADDER = "AddAcceptHeader";
/**
* Gets the sort order of the customization from -128 to 127, with lowest
* executed first.
*
* @return Returns the sort order, defaults to -40.
*/
@Override
public byte getOrder() {
return 127;
}
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
ServiceShape service = settings.getService(model);
if (!isAPIGatewayService(model, service)) {
return;
}
goDelegator.useShapeWriter(service, this::writeMiddlewareHelper);
}
private void writeMiddlewareHelper(GoWriter writer) {
writer.openBlock("func $L(stack *middleware.Stack) error {", "}", ADD_ACCEPT_HEADER, () -> {
writer.write("return $T(stack)",
SymbolUtils.createValueSymbolBuilder(ACCEPT_HEADER_INTERNAL_ADDER,
AwsCustomGoDependency.APIGATEWAY_CUSTOMIZATION).build()
);
});
writer.insertTrailingNewline();
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return ListUtils.of(
RuntimeClientPlugin.builder()
.servicePredicate(APIGatewayAcceptHeader::isAPIGatewayService)
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(ADD_ACCEPT_HEADER).build())
.build())
.build()
);
}
private static boolean isAPIGatewayService(Model model, ServiceShape service) {
return service.expectTrait(ServiceTrait.class).getSdkId().equalsIgnoreCase("API Gateway");
}
}
| 8,354 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/KinesisCustomizations.java | package software.amazon.smithy.aws.go.codegen.customization;
import java.util.List;
import software.amazon.smithy.aws.go.codegen.AwsGoDependency;
import software.amazon.smithy.aws.traits.ServiceTrait;
import software.amazon.smithy.go.codegen.SymbolUtils;
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.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.utils.ListUtils;
public class KinesisCustomizations implements GoIntegration {
private static final String READ_TIMEOUT_ADDER = "AddResponseReadTimeoutMiddleware";
private static final String READ_TIMEOUT_DURATION = "ReadTimeoutDuration";
@Override
public byte getOrder() {
// We want this to go last so it can be registered at the very end of the list,
// meaning it will be the first to be called after the actual http request is
// made.
return 127;
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return ListUtils.of(
RuntimeClientPlugin.builder()
.operationPredicate(KinesisCustomizations::isGetRecords)
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(READ_TIMEOUT_ADDER,
AwsGoDependency.AWS_HTTP_TRANSPORT).build())
.functionArguments(ListUtils.of(
SymbolUtils.createValueSymbolBuilder(READ_TIMEOUT_DURATION,
AwsCustomGoDependency.KINESIS_CUSTOMIZATION).build()))
.build())
.build()
);
}
private static boolean isGetRecords(Model model, ServiceShape service, OperationShape operation) {
return isKinesis(model, service) && operation.getId().getName(service).equals("GetRecords");
}
private static boolean isKinesis(Model model, ServiceShape service) {
return service.expectTrait(ServiceTrait.class).getSdkId().equalsIgnoreCase("Kinesis");
}
}
| 8,355 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/SQSCustomizations.java | /*
* Copyright 2023 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.aws.go.codegen.customization;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.logging.Logger;
import software.amazon.smithy.go.codegen.CodegenUtils;
import software.amazon.smithy.go.codegen.GoSettings;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.node.Node;
import software.amazon.smithy.model.node.NumberNode;
import software.amazon.smithy.model.shapes.IntegerShape;
import software.amazon.smithy.model.shapes.MemberShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.traits.DefaultTrait;
import software.amazon.smithy.model.transform.ModelTransformer;
import software.amazon.smithy.utils.ListUtils;
import software.amazon.smithy.utils.SmithyUnstableApi;
/**
* AWS SDK for Go V2 Integrations for the Amazon SQS service
*/
@SmithyUnstableApi
public class SQSCustomizations implements GoIntegration {
private static final Logger LOGGER = Logger.getLogger(SQSCustomizations.class.getName());
private static final ShapeId SQS_SERVICE_ID = ShapeId.from("com.amazonaws.sqs#AmazonSQS");
private static final ShapeId NON_NULLABLE_INTEGER_ID = ShapeId.from("com.amazonaws.sqs#Integer");
private static final DefaultTrait DEFAULT_ZERO_TRAIT = new DefaultTrait(NumberNode.from(0L));
/**
* Default traits that need to be backfilled
*/
private static final List<ShapeId> DEFAULT_TRAIT_BACKFILL = ListUtils.of(
// Structure Shapes
ShapeId.from("com.amazonaws.sqs#ChangeMessageVisibilityBatchRequestEntry$VisibilityTimeout"),
ShapeId.from("com.amazonaws.sqs#SendMessageBatchRequestEntry$DelaySeconds"),
// Top-level Input Shape Members
ShapeId.from("com.amazonaws.sqs#SendMessageRequest$DelaySeconds"),
ShapeId.from("com.amazonaws.sqs#ChangeMessageVisibilityRequest$VisibilityTimeout"),
ShapeId.from("com.amazonaws.sqs#ReceiveMessageRequest$WaitTimeSeconds"),
ShapeId.from("com.amazonaws.sqs#ReceiveMessageRequest$VisibilityTimeout"),
ShapeId.from("com.amazonaws.sqs#ReceiveMessageRequest$MaxNumberOfMessages"),
// Synthetic-equivalent Top-level Input Shape Members
// Note that "Request" is translated to "Input" in synthetic members
ShapeId.from("smithy.go.synthetic#SendMessageInput$DelaySeconds"),
ShapeId.from("smithy.go.synthetic#ChangeMessageVisibilityInput$VisibilityTimeout"),
ShapeId.from("smithy.go.synthetic#ReceiveMessageInput$WaitTimeSeconds"),
ShapeId.from("smithy.go.synthetic#ReceiveMessageInput$VisibilityTimeout"),
ShapeId.from("smithy.go.synthetic#ReceiveMessageInput$MaxNumberOfMessages"));
@Override
public Model preprocessModel(Model model, GoSettings settings) {
ShapeId serviceId = settings.getService();
if (!serviceId.equals(SQS_SERVICE_ID)) {
return model;
}
// Add non-nullable integer shape
model = model.toBuilder()
.addShape(IntegerShape.builder()
.id(NON_NULLABLE_INTEGER_ID)
.addTrait(DEFAULT_ZERO_TRAIT)
.build())
.build();
// Process Default traits that need to be backfilled
List<Shape> updates = new ArrayList<>();
for (ShapeId memberShapeId : DEFAULT_TRAIT_BACKFILL) {
Optional<MemberShape> memberShapeOptional = model
.getShape(memberShapeId)
.flatMap(s -> s.asMemberShape());
String memberShapeNamespace = memberShapeId.getNamespace();
// Synthetic shapes could be missing if the upstream model changes are deduped
// and the synthetic shapes are no longer needed.
if (!memberShapeOptional.isPresent() && memberShapeNamespace.equals(CodegenUtils.getSyntheticTypeNamespace())) {
LOGGER.warning(String.format("SQS service synthetic member shape `" + memberShapeId
+ "` is not present in the model, so could not be backfilled with a default trait."));
continue;
}
MemberShape memberShape = memberShapeOptional.get();
// Overwrite default trait to maintain backward compatibility
if (memberShape.hasTrait(DefaultTrait.class)) {
DefaultTrait defaultTrait = memberShape.expectTrait(DefaultTrait.class);
LOGGER.warning("Overwriting default trait for SQS service member shape `" + memberShapeId
+ "` with value: `" + Node.prettyPrintJson(defaultTrait.toNode()) + "`");
}
// Patch member with default trait and change target to non-nullable integer shape
updates.add(memberShape.toBuilder()
.addTrait(DEFAULT_ZERO_TRAIT)
.target(NON_NULLABLE_INTEGER_ID)
.build());
}
return ModelTransformer.create().replaceShapes(model, updates);
}
}
| 8,356 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3UpdateOutpostArn.java | package software.amazon.smithy.aws.go.codegen.customization;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import software.amazon.smithy.codegen.core.CodegenException;
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.SymbolUtils;
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.MemberShape;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.utils.ListUtils;
import software.amazon.smithy.utils.SetUtils;
/**
* Implements the arnable interface on all relevant S3/S3Control outposts operations.
*/
public class S3UpdateOutpostArn implements GoIntegration {
private final Set<String> LIST_ACCESSPOINT_ARN_INPUT = SetUtils.of(
"GetAccessPoint", "DeleteAccessPoint", "PutAccessPointPolicy",
"GetAccessPointPolicy", "DeleteAccessPointPolicy"
);
private final MiddlewareRegistrar middlewareAdder =
MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder("AddUpdateOutpostARN", AwsCustomGoDependency.S3CONTROL_CUSTOMIZATION).build())
.build();
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return ListUtils.of(
RuntimeClientPlugin.builder()
.servicePredicate(S3ModelUtils::isServiceS3Control)
.registerMiddleware(middlewareAdder)
.build()
);
}
public void writeAdditionalFiles(GoSettings settings, Model model, SymbolProvider symbolProvider, GoDelegator goDelegator) {
ServiceShape service = settings.getService(model);
if (!S3ModelUtils.isServiceS3Control(model, service)) return;
for (OperationShape operation : TopDownIndex.of(model).getContainedOperations(service)) {
goDelegator.useShapeWriter(operation, writer -> {
writeARNHelper(settings, writer, model, symbolProvider, operation);
});
}
}
private void writeARNHelper(
GoSettings settings, GoWriter writer,
Model model, SymbolProvider symbolProvider, OperationShape operation
) {
ServiceShape service = settings.getService(model);
String arnType = LIST_ACCESSPOINT_ARN_INPUT.contains(
operation.getId().getName(service)
) ? "AccessPointName" : "BucketName";
StructureShape input = model.expectShape(operation.getInput().get(), StructureShape.class);
List<MemberShape> listOfARNMembers = input.getAllMembers().values().stream()
.filter(m -> m.getTarget().getName(service).equals(arnType))
.collect(Collectors.toList());
if (listOfARNMembers.size() > 1) {
throw new CodegenException(arnType + " shape should be targeted by only one input member, found " +
listOfARNMembers.size() + " for Input shape: " + input.getId());
}
if (listOfARNMembers.isEmpty()) {
return;
}
String inputName = symbolProvider.toSymbol(input).getName();
String memberName = listOfARNMembers.get(0).getMemberName();
writer.write(
"""
func (m *$1L) GetARNMember() (*string, bool) {
if m.$2L == nil {
return nil, false
}
return m.$2L, true
}
""",
inputName,
memberName
);
writer.write(
"""
func (m *$1L) SetARNMember(v string) error {
m.$2L = &v
return nil
}
""",
inputName,
memberName
);
}
}
| 8,357 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/BackfillS3ObjectSizeMemberShapeType.java | /*
* 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.aws.go.codegen.customization;
import java.util.Map;
import java.util.Set;
import java.util.logging.Logger;
import software.amazon.smithy.go.codegen.GoSettings;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.shapes.IntegerShape;
import software.amazon.smithy.model.shapes.LongShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.shapes.ShapeType;
import software.amazon.smithy.utils.MapUtils;
import software.amazon.smithy.utils.OptionalUtils;
import software.amazon.smithy.utils.SetUtils;
public class BackfillS3ObjectSizeMemberShapeType implements GoIntegration {
private static final Logger LOGGER = Logger.getLogger(BackfillS3ObjectSizeMemberShapeType.class.getName());
private static final Map<ShapeId, Set<ShapeId>> SERVICE_TO_SHAPE_MAP = MapUtils.of(
ShapeId.from("com.amazonaws.s3#AmazonS3"), SetUtils.of(
ShapeId.from("com.amazonaws.s3#Size")
)
);
@Override
public byte getOrder() {
// This integration should happen before other integrations that rely on the presence of this trait
return -60;
}
@Override
public Model preprocessModel(
Model model, GoSettings settings
) {
ShapeId serviceId = settings.getService();
if (!SERVICE_TO_SHAPE_MAP.containsKey(serviceId)) {
return model;
}
Set<ShapeId> shapeIds = SERVICE_TO_SHAPE_MAP.get(serviceId);
Model.Builder builder = model.toBuilder();
for (ShapeId shapeId : shapeIds) {
OptionalUtils.ifPresentOrElse(
model.getShape(shapeId),
(shape) -> {
if (shape.isLongShape()) {
LOGGER.warning("shape is already modeled as an LONG does not require backfill");
return;
}
builder.addShape(LongShape.builder()
.id(shape.getId())
.addTraits(shape.getAllTraits().values())
.build());
},
() -> LOGGER.warning("shape " + shapeId + " not found in " + serviceId + " model")
);
}
return builder.build();
}
}
| 8,358 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/LocationModelFixes.java | /*
* Copyright 2021 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.aws.go.codegen.customization;
import java.util.List;
import java.util.logging.Logger;
import software.amazon.smithy.go.codegen.GoSettings;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.traits.AuthTrait;
import software.amazon.smithy.utils.ListUtils;
public class LocationModelFixes implements GoIntegration {
private static final Logger LOGGER = Logger.getLogger(LocationModelFixes.class.getName());
private static final List<ShapeId> SHAPE_ID_EMPTY_AUTH_TRAIT_REMOVAL = ListUtils.of(
ShapeId.from("com.amazonaws.location#BatchEvaluateGeofences"),
ShapeId.from("com.amazonaws.location#DescribeGeofenceCollection"),
ShapeId.from("com.amazonaws.location#DescribeMap"),
ShapeId.from("com.amazonaws.location#DescribePlaceIndex"),
ShapeId.from("com.amazonaws.location#DescribeRouteCalculator"),
ShapeId.from("com.amazonaws.location#DescribeTracker")
);
@Override
public Model preprocessModel(
Model model,
GoSettings settings
) {
if (SHAPE_ID_EMPTY_AUTH_TRAIT_REMOVAL.size() == 0) {
return model;
}
var builder = model.toBuilder();
for (ShapeId shapeId : SHAPE_ID_EMPTY_AUTH_TRAIT_REMOVAL) {
var optionalShape = model.getShape(shapeId);
if (optionalShape.isEmpty()) {
continue;
}
var shape = optionalShape.get().asOperationShape().get();
var optionalAuthTrait = shape.getTrait(AuthTrait.class);
if (optionalAuthTrait.isEmpty()) {
LOGGER.warning(() -> String.format("%s no longer has an AuthTrait", shapeId));
continue;
}
var authTrait = optionalAuthTrait.get();
if (authTrait.getValueSet().size() != 0) {
LOGGER.warning(() -> String.format("%s has a non-empty AuthTrait list and will not be removed",
shapeId));
continue;
}
builder.addShape(shape.toBuilder()
.removeTrait(AuthTrait.ID)
.build());
}
return builder.build();
}
}
| 8,359 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3HttpLabelBucketFilterIntegration.java | package software.amazon.smithy.aws.go.codegen.customization;
import software.amazon.smithy.go.codegen.GoSettings;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.go.codegen.trait.NoSerializeTrait;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.traits.HttpLabelTrait;
import software.amazon.smithy.model.transform.ModelTransformer;
public class S3HttpLabelBucketFilterIntegration implements GoIntegration {
@Override
public Model preprocessModel(Model model, GoSettings settings) {
if (!S3ModelUtils.isServiceS3(model, settings.getService(model))) {
return model;
}
return ModelTransformer.create().mapShapes(model, (shape) -> {
if (!shape.hasTrait(HttpLabelTrait.class)) return shape;
boolean isBucket = shape.asMemberShape()
.map(s -> s.getMemberName().equals("Bucket"))
.orElse(false);
if (isBucket) {
shape = Shape.shapeToBuilder(shape).addTrait(new NoSerializeTrait()).build();
}
return shape;
});
}
}
| 8,360 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3ControlEndpointResolver.java | package software.amazon.smithy.aws.go.codegen.customization;
import java.util.function.Consumer;
import software.amazon.smithy.aws.go.codegen.EndpointGenerator;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.go.codegen.GoSettings;
import software.amazon.smithy.go.codegen.GoWriter;
import software.amazon.smithy.go.codegen.TriConsumer;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.model.Model;
/**
* S3ControlEndpointResolverCustomizations adds an internal endpoint resolver
* for s3 service endpoints
*/
public class S3ControlEndpointResolver implements GoIntegration {
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
TriConsumer<String, String, Consumer<GoWriter>> writerFactory
) {
if (!S3ModelUtils.isServiceS3Control(model, settings.getService(model))) {
return;
}
// Generate S3 internal endpoint resolver for S3 Control service
EndpointGenerator.builder()
.settings(settings)
.model(model)
.writerFactory(writerFactory)
.sdkID("S3")
.endpointPrefix("s3")
.arnNamespace("s3")
.internalOnly(true)
.build()
.run();
}
}
| 8,361 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3PaginationExtensions.java | /*
* Copyright 2021 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.aws.go.codegen.customization;
import java.util.Optional;
import software.amazon.smithy.aws.traits.ServiceTrait;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.go.codegen.GoSettings;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.go.codegen.trait.PagingExtensionTrait;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.knowledge.PaginatedIndex;
import software.amazon.smithy.model.knowledge.PaginationInfo;
import software.amazon.smithy.model.knowledge.TopDownIndex;
import software.amazon.smithy.model.shapes.MemberShape;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.shapes.StructureShape;
/**
* This customization adds support for checking the IsTruncated boolean member for paginated S3 operations to determine
* if the NextToken should be set for the paginator.
*/
public class S3PaginationExtensions implements GoIntegration {
@Override
public Model preprocessModel(
Model model, GoSettings settings
) {
ServiceShape service = settings.getService(model);
if (!S3ModelUtils.isServiceS3(model, service)) {
return model;
}
return addMoreResultsKey(model, service);
}
private Model addMoreResultsKey(Model model, ServiceShape service) {
PaginatedIndex paginatedIndex = PaginatedIndex.of(model);
Model.Builder builder = model.toBuilder();
for (OperationShape operation : TopDownIndex.of(model).getContainedOperations(service)) {
Optional<PaginationInfo> optionalPaginationInfo = paginatedIndex.getPaginationInfo(service, operation);
if (!optionalPaginationInfo.isPresent()) {
continue;
}
StructureShape outputShape = optionalPaginationInfo.get().getOutput();
Optional<MemberShape> memberShape = Optional.empty();
for (MemberShape member : outputShape.members()) {
if (member.getTarget().equals(ShapeId.from("com.amazonaws.s3#IsTruncated"))) {
if (memberShape.isPresent()) {
throw new CodegenException("IsTruncated member present in output more then once");
}
memberShape = Optional.of(member);
}
}
if (memberShape.isPresent()) {
OperationShape.Builder operationBuilder = optionalPaginationInfo.get().getOperation().toBuilder();
operationBuilder.addTrait(PagingExtensionTrait.builder()
.moreResults(memberShape.get())
.build());
builder.addShape(operationBuilder.build());
}
}
return builder.build();
}
}
| 8,362 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3AcceptEncodingGzip.java | package software.amazon.smithy.aws.go.codegen.customization;
import java.util.List;
import java.util.logging.Logger;
import software.amazon.smithy.aws.go.codegen.AddAwsConfigFields;
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.SymbolUtils;
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.utils.ListUtils;
/**
* S3AcceptEncodingGzip adds a customization for s3 client to disable
* auto decoding of GZip content by Golang HTTP Client.
*
* This customization provides an option on the S3 client options to enable
* AcceptEncoding for GZIP. The flag if set, will enable auto decompression of
* GZIP by the S3 Client.
*
* By default, the client's auto decompression of GZIP content is turned off.
*/
public class S3AcceptEncodingGzip implements GoIntegration {
private static final Logger LOGGER = Logger.getLogger(AddAwsConfigFields.class.getName());
private static final String GZIP_DISABLE = "disableAcceptEncodingGzip";
private static final String GZIP_INTERNAL_ADDER = "AddAcceptEncodingGzip";
/**
* Gets the sort order of the customization from -128 to 127, with lowest
* executed first.
*
* @return Returns the sort order, defaults to -50.
*/
@Override
public byte getOrder() {
return 127;
}
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
if (!S3ModelUtils.isServiceS3(model, settings.getService(model))) {
return;
}
goDelegator.useShapeWriter(settings.getService(model), this::writeMiddlewareHelper);
}
private void writeMiddlewareHelper(GoWriter writer) {
writer.openBlock("func $L(stack *middleware.Stack) error {", "}", GZIP_DISABLE, () -> {
writer.write("return $T(stack, $T{})",
SymbolUtils.createValueSymbolBuilder(GZIP_INTERNAL_ADDER,
AwsCustomGoDependency.ACCEPT_ENCODING_CUSTOMIZATION).build(),
SymbolUtils.createValueSymbolBuilder(GZIP_INTERNAL_ADDER + "Options",
AwsCustomGoDependency.ACCEPT_ENCODING_CUSTOMIZATION).build()
);
});
writer.insertTrailingNewline();
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return ListUtils.of(
// register disableAcceptEncodingGzip middleware
RuntimeClientPlugin.builder()
.servicePredicate(S3ModelUtils::isServiceS3)
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(GZIP_DISABLE)
.build())
.build()
)
.build()
);
}
}
| 8,363 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3ResponseErrorWrapper.java | package software.amazon.smithy.aws.go.codegen.customization;
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.SymbolUtils;
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.shapes.ServiceShape;
import software.amazon.smithy.utils.ListUtils;
/**
* wraps a smithy request error with an S3 Request error.
*/
public class S3ResponseErrorWrapper implements GoIntegration {
private static final String ADD_ERROR_MIDDLEWARE = "addResponseErrorMiddleware";
private static final String ADD_ERROR_MIDDLEWARE_INTERNAL = "AddResponseErrorMiddleware";
/**
* Gets the sort order of the customization from -128 to 127, with lowest
* executed first.
*
* @return Returns the sort order, defaults to -40.
*/
@Override
public byte getOrder() {
return 127;
}
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
ServiceShape service = settings.getService(model);
if (!requiresS3Customization(model, service)) {
return;
}
goDelegator.useShapeWriter(service, this::writeMiddlewareHelper);
}
private void writeMiddlewareHelper(GoWriter writer) {
writer.openBlock("func $L(stack *middleware.Stack) error {", "}", ADD_ERROR_MIDDLEWARE, () -> {
writer.write("return $T(stack)",
SymbolUtils.createValueSymbolBuilder(ADD_ERROR_MIDDLEWARE_INTERNAL,
AwsCustomGoDependency.S3_SHARED_CUSTOMIZATION).build()
);
});
writer.insertTrailingNewline();
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return ListUtils.of(
RuntimeClientPlugin.builder()
.servicePredicate(S3ResponseErrorWrapper::requiresS3Customization)
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(ADD_ERROR_MIDDLEWARE).build())
.build())
.build()
);
}
// returns true if service is either s3 or s3 control and needs s3 customization
private static boolean requiresS3Customization(Model model, ServiceShape service) {
return S3ModelUtils.isServiceS3(model, service) || S3ModelUtils.isServiceS3Control(model, service);
}
}
| 8,364 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/BackfillBoxTrait.java | /*
* 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.aws.go.codegen.customization;
import java.util.Map;
import java.util.Set;
import java.util.logging.Logger;
import software.amazon.smithy.go.codegen.GoSettings;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.shapes.IntegerShape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.traits.BoxTrait;
import software.amazon.smithy.utils.MapUtils;
import software.amazon.smithy.utils.SetUtils;
/**
* Integration that back fills the `boxed` traits to API shapes that were not decorated with the trait in the model.
*/
public class BackfillBoxTrait implements GoIntegration {
private static final Logger LOGGER = Logger.getLogger(BackfillBoxTrait.class.getName());
/**
* Map of service shape to Set of operation shapes that need to have this
* presigned url auto fill customization.
*/
public static final Map<ShapeId, Set<ShapeId>> SERVICE_TO_MEMBER_MAP = MapUtils.of(
ShapeId.from("com.amazonaws.s3control#AWSS3ControlServiceV20180820"), SetUtils.of(
ShapeId.from("com.amazonaws.s3control#S3ExpirationInDays")
));
/**
* /**
* Updates the API model to add additional members to the operation input shape that are needed for presign url
* customization.
*
* @param model API model
* @param settings Go codegen settings
* @return updated API model
*/
@Override
public Model preprocessModel(Model model, GoSettings settings) {
ShapeId serviceId = settings.getService();
if (!SERVICE_TO_MEMBER_MAP.containsKey(serviceId)) {
return model;
}
Model.Builder builder = model.toBuilder();
Set<ShapeId> shapeIds = SERVICE_TO_MEMBER_MAP.get(serviceId);
for (ShapeId shapeId : shapeIds) {
IntegerShape shape = model.expectShape(shapeId, IntegerShape.class);
if (shape.getTrait(BoxTrait.class).isPresent()) {
LOGGER.warning("BoxTrait is present in model and does not require backfill");
continue;
}
builder.addShape(shape.toBuilder()
.addTrait(new BoxTrait())
.build());
}
return builder.build();
}
}
| 8,365 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/BackfillOptionalAuthTrait.java | /*
* 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.aws.go.codegen.customization;
import java.util.Map;
import java.util.Set;
import java.util.logging.Logger;
import software.amazon.smithy.go.codegen.GoSettings;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.traits.OptionalAuthTrait;
import software.amazon.smithy.utils.MapUtils;
import software.amazon.smithy.utils.SetUtils;
/**
* Backfill missing Smithy OptionalAuth traits to AWS models.
*/
public class BackfillOptionalAuthTrait implements GoIntegration {
private static final Logger LOGGER = Logger.getLogger(BackfillOptionalAuthTrait.class.getName());
private static final Map<ShapeId, Set<ShapeId>> SERVICE_TO_OPERATION_MAP = MapUtils.of(
ShapeId.from("com.amazonaws.sts#AWSSecurityTokenServiceV20110615"), SetUtils.of(
ShapeId.from("com.amazonaws.sts#AssumeRoleWithSAML"),
ShapeId.from("com.amazonaws.sts#AssumeRoleWithWebIdentity")),
ShapeId.from("com.amazonaws.cognitoidentity#AWSCognitoIdentityService"), SetUtils.of(
ShapeId.from("com.amazonaws.cognitoidentity#GetId"),
ShapeId.from("com.amazonaws.cognitoidentity#GetOpenIdToken"),
ShapeId.from("com.amazonaws.cognitoidentity#UnlinkIdentity"),
ShapeId.from("com.amazonaws.cognitoidentity#GetCredentialsForIdentity")));
@Override
public byte getOrder() {
// This integration should happen before other integrations that rely on the presence of this trait
return -60;
}
@Override
public Model preprocessModel(
Model model, GoSettings settings
) {
ShapeId serviceId = settings.getService();
if (!SERVICE_TO_OPERATION_MAP.containsKey(serviceId)) {
return model;
}
Set<ShapeId> operationIds = SERVICE_TO_OPERATION_MAP.get(serviceId);
Model.Builder builder = model.toBuilder();
for (ShapeId operationId : operationIds) {
OperationShape operationShape = model.expectShape(operationId).asOperationShape().get();
if (operationShape.getTrait(OptionalAuthTrait.class).isPresent()) {
LOGGER.warning("optionalAuth trait is present in model and does not require backfill");
continue;
}
builder.addShape(operationShape.toBuilder()
.addTrait(new OptionalAuthTrait())
.build());
}
return builder.build();
}
}
| 8,366 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/ShapeBackwardsCompatabilityTransforms.java | /*
* Copyright 2021 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.aws.go.codegen.customization;
import java.util.Map;
import software.amazon.smithy.go.codegen.GoSettings;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.shapes.ShapeType;
import software.amazon.smithy.model.transform.ModelTransformer;
import software.amazon.smithy.utils.MapUtils;
public class ShapeBackwardsCompatabilityTransforms implements GoIntegration {
private static final Map<ShapeId, ShapeType> SHAPE_ID_SHAPE_TYPE_MAP = MapUtils.of(
ShapeId.from("com.amazonaws.nimble#StudioComponentConfiguration"), ShapeType.STRUCTURE
);
@Override
public byte getOrder() {
return -127;
}
@Override
public Model preprocessModel(Model model, GoSettings settings) {
return ModelTransformer.create()
.changeShapeType(model, SHAPE_ID_SHAPE_TYPE_MAP);
}
}
| 8,367 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3Bucketer.java | package software.amazon.smithy.aws.go.codegen.customization;
import software.amazon.smithy.codegen.core.CodegenException;
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.integration.GoIntegration;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.knowledge.TopDownIndex;
import software.amazon.smithy.model.shapes.MemberShape;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.utils.ListUtils;
import java.util.Comparator;
import java.util.List;
/**
* Implements a bucket() method on applicable S3 input structures, which returns the principal bucket name from the input.
*/
public class S3Bucketer implements GoIntegration {
// when deriving the principal input bucket for an operation, if more than one member is targeting the BucketName
// shape, we take one that has one of the following names
private final List<String> MATCHED_BUCKET_MEMBERS = ListUtils.of("Bucket", "BucketName");
public void writeAdditionalFiles(GoSettings settings, Model model, SymbolProvider symbolProvider, GoDelegator goDelegator) {
ServiceShape service = settings.getService(model);
if (!S3ModelUtils.isServiceS3(model, service)) return;
for (OperationShape operation : TopDownIndex.of(model).getContainedOperations(service)) {
goDelegator.useShapeWriter(operation, writer -> {
writeBucketer(writer, model, symbolProvider, operation);
});
}
}
private void writeBucketer(GoWriter writer, Model model, SymbolProvider symbolProvider, OperationShape operation) {
StructureShape input = model.expectShape(operation.getInput().get(), StructureShape.class);
MemberShape bucket = getBucketMember(input);
if (bucket == null) return;
String inputName = symbolProvider.toSymbol(input).getName();
String memberName = bucket.getMemberName();
writer.write("""
func (v *$1L) bucket() (string, bool) {
if v.$2L == nil {
return "", false
}
return *v.$2L, true
}""",
inputName,
memberName
);
}
private MemberShape getBucketMember(StructureShape input) {
List<MemberShape> members = input.members().stream()
.filter(it -> it.getTarget().getName().equals("BucketName"))
.toList();
if (members.isEmpty()) return null;
if (members.size() == 1) return members.get(0);
members = members.stream()
.filter(it -> MATCHED_BUCKET_MEMBERS.contains(it.getMemberName()))
.sorted(Comparator.comparing(MemberShape::getMemberName))
.toList();
if (members.size() > 0) return members.get(0);
throw new CodegenException("could not determine principal bucket input: " + input.getId());
}
}
| 8,368 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/BackfillEc2UnboxedToBoxedShapes.java | package software.amazon.smithy.aws.go.codegen.customization;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.logging.Logger;
import software.amazon.smithy.go.codegen.GoSettings;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.transform.ModelTransformer;
import software.amazon.smithy.model.shapes.MemberShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.model.traits.ClientOptionalTrait;
import software.amazon.smithy.utils.SetUtils;
public class BackfillEc2UnboxedToBoxedShapes implements GoIntegration {
private static final Logger LOGGER = Logger.getLogger(BackfillEc2UnboxedToBoxedShapes.class.getName());
/**
* Map of service shape to Set of operation shapes that need to have this
* presigned url auto fill customization.
*/
public static final Set<ShapeId> SERVICE_SET = SetUtils.of(
ShapeId.from("com.amazonaws.ec2#AmazonEC2")
);
/**
* /**
* Updates the API model to customize all structured members to be nullable.
*
* @param model API model
* @param settings Go codegen settings
* @return updated API model
*/
@Override
public Model preprocessModel(Model model, GoSettings settings) {
ShapeId serviceId = settings.getService();
if (!SERVICE_SET.contains(serviceId)) {
return model;
}
List<Shape> updates = new ArrayList<>();
for (StructureShape struct : model.getStructureShapes()) {
for (MemberShape member : struct.getAllMembers().values()) {
updates.add(member.toBuilder().addTrait(new ClientOptionalTrait()).build());
}
}
return ModelTransformer.create().replaceShapes(model, updates);
}
}
| 8,369 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3SerializeImmutableHostnameBucket.java | package software.amazon.smithy.aws.go.codegen.customization;
import software.amazon.smithy.go.codegen.SymbolUtils;
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.utils.ListUtils;
import java.util.List;
/**
* Adds the input bucket name back to the path when an immutable endpoint is returned through v1 EndpointResolution.
*/
public class S3SerializeImmutableHostnameBucket implements GoIntegration {
@Override
public byte getOrder() { return 127; } // depends on ResolveEndpointV2 middleware for stack insert
private final MiddlewareRegistrar serializeImmutableHostnameBucketMiddleware =
MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder("addSerializeImmutableHostnameBucketMiddleware").build())
.useClientOptions()
.build();
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return ListUtils.of(
RuntimeClientPlugin.builder()
.servicePredicate(S3ModelUtils::isServiceS3)
.registerMiddleware(serializeImmutableHostnameBucketMiddleware)
.build()
);
}
}
| 8,370 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/SQSValidateMessageChecksum.java | package software.amazon.smithy.aws.go.codegen.customization;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Logger;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.go.codegen.GoCodegenPlugin;
import software.amazon.smithy.go.codegen.GoSettings;
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.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.utils.MapUtils;
import software.amazon.smithy.utils.SetUtils;
public class SQSValidateMessageChecksum implements GoIntegration {
private static final Logger LOGGER = Logger.getLogger(SQSValidateMessageChecksum.class.getName());
/**
* Map of service shape to Set of operation shapes that need to have this
* customization.
*/
public static final Map<ShapeId, Set<ShapeId>> SERVICE_TO_OPERATION_MAP = MapUtils.of(
ShapeId.from("com.amazonaws.sqs#AmazonSQS"), SetUtils.of(
ShapeId.from("com.amazonaws.sqs#SendMessage"),
ShapeId.from("com.amazonaws.sqs#SendMessageBatch"),
ShapeId.from("com.amazonaws.sqs#ReceiveMessage")
)
);
static final String DISABLE_MESSAGE_CHECKSUM_VALIDATION_OPTION_NAME = "DisableMessageChecksumValidation";
private final List<RuntimeClientPlugin> runtimeClientPlugins = new ArrayList<>();
/**
* Builds the set of runtime plugs used by the customization.
*
* @param settings codegen settings
* @param model api model
*/
@Override
public void processFinalizedModel(GoSettings settings, Model model) {
ShapeId serviceId = settings.getService();
if (!SERVICE_TO_OPERATION_MAP.containsKey(serviceId)) {
return;
}
ServiceShape service = settings.getService(model);
// Add option to disable message checksum validation
runtimeClientPlugins.add(RuntimeClientPlugin.builder()
.servicePredicate((m, s) -> s.equals(service))
.addConfigField(ConfigField.builder()
.name(DISABLE_MESSAGE_CHECKSUM_VALIDATION_OPTION_NAME)
.type(SymbolUtils.createValueSymbolBuilder("bool")
.putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true).build())
.documentation("Allows you to disable the client's validation of "
+ "response message checksums. Enabled by default. "
+ "Used by SendMessage, SendMessageBatch, and ReceiveMessage.")
.build())
.build());
for (ShapeId operationId : SERVICE_TO_OPERATION_MAP.get(serviceId)) {
final OperationShape operation = model.expectShape(operationId, OperationShape.class);
// Create a symbol provider because one is not available in this call.
SymbolProvider symbolProvider = GoCodegenPlugin.createSymbolProvider(model, settings);
String helperFuncName = addMiddlewareFuncName(symbolProvider.toSymbol(operation).getName());
runtimeClientPlugins.add(RuntimeClientPlugin.builder()
.servicePredicate((m, s) -> s.equals(service))
.operationPredicate((m, s, o) -> o.equals(operation))
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(helperFuncName)
.build())
.useClientOptions()
.build())
.build());
}
}
String addMiddlewareFuncName(String operationName) {
return "addValidate" + operationName + "Checksum";
}
/**
* Returns the list of runtime client plugins added by this customization
*
* @return runtime client plugins
*/
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return runtimeClientPlugins;
}
}
| 8,371 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3AddPutObjectUnseekableBodyDoc.java | package software.amazon.smithy.aws.go.codegen.customization;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.logging.Logger;
import software.amazon.smithy.codegen.core.CodegenException;
import software.amazon.smithy.go.codegen.GoSettings;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.shapes.MemberShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.model.traits.DocumentationTrait;
import software.amazon.smithy.utils.MapUtils;
import software.amazon.smithy.utils.Pair;
import software.amazon.smithy.utils.SetUtils;
public class S3AddPutObjectUnseekableBodyDoc implements GoIntegration {
private static final Logger LOGGER = Logger.getLogger(S3AddPutObjectUnseekableBodyDoc.class.getName());
private static final Map<ShapeId, Set<Pair<ShapeId, String>>> SERVICE_TO_SHAPE_MAP = MapUtils.of(
ShapeId.from("com.amazonaws.s3#AmazonS3"), SetUtils.of(
new Pair(ShapeId.from("com.amazonaws.s3#PutObjectRequest"), "Body"),
new Pair(ShapeId.from("com.amazonaws.s3#UploadPartRequest"), "Body")
)
);
@Override
public byte getOrder() {
// This integration should happen before other integrations that rely on the presence of this trait
return -60;
}
@Override
public Model preprocessModel(
Model model, GoSettings settings
) {
ShapeId serviceId = settings.getService();
if (!SERVICE_TO_SHAPE_MAP.containsKey(serviceId)) {
return model;
}
Set<Pair<ShapeId, String>> shapeIds = SERVICE_TO_SHAPE_MAP.get(serviceId);
Model.Builder builder = model.toBuilder();
for (Pair<ShapeId, String> pair : shapeIds) {
ShapeId shapeId = pair.getLeft();
String memberName = pair.getRight();
StructureShape parent = model.expectShape(shapeId, StructureShape.class);
Optional<MemberShape> memberOpt = parent.getMember(memberName);
if (!memberOpt.isPresent()) {
// Throw in case member is not present, bad things must of happened.
throw new CodegenException("expect to find " + memberName + " member in shape " + parent.getId());
}
MemberShape member = memberOpt.get();
Shape target = model.expectShape(member.getTarget());
Optional<DocumentationTrait> docTrait = member.getTrait(DocumentationTrait.class);
String currentDocs = "";
if (docTrait.isPresent()) {
currentDocs = docTrait.get().getValue();
}
if (currentDocs.length() != 0) {
currentDocs += "<br/><br/>";
}
final String finalCurrentDocs = currentDocs;
StructureShape.Builder parentBuilder = parent.toBuilder();
parentBuilder.removeMember(memberName);
parentBuilder.addMember(memberName, target.getId(), (memberBuilder) -> {
memberBuilder
.addTraits(member.getAllTraits().values())
.addTrait(new DocumentationTrait(finalCurrentDocs +
"For using values that are not seekable (io.Seeker) see, " +
"https://aws.github.io/aws-sdk-go-v2/docs/sdk-utilities/s3/#unseekable-streaming-input"));
});
builder.addShape(parentBuilder.build());
}
return builder.build();
}
}
| 8,372 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/AwsCustomGoDependency.java | /*
* 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.aws.go.codegen.customization;
import software.amazon.smithy.aws.go.codegen.AwsGoDependency;
import software.amazon.smithy.go.codegen.GoDependency;
/**
* A class of constants for dependencies used by this package.
*/
public final class AwsCustomGoDependency extends AwsGoDependency {
public static final GoDependency DYNAMODB_CUSTOMIZATION = aws(
"service/dynamodb/internal/customizations", "ddbcust");
public static final GoDependency S3_CUSTOMIZATION = aws("service/s3/internal/customizations", "s3cust");
public static final GoDependency S3CONTROL_CUSTOMIZATION = aws("service/s3control/internal/customizations", "s3controlcust");
public static final GoDependency APIGATEWAY_CUSTOMIZATION = aws(
"service/apigateway/internal/customizations", "agcust");
public static final GoDependency GLACIER_CUSTOMIZATION = aws(
"service/glacier/internal/customizations", "glaciercust");
public static final GoDependency S3_SHARED_CUSTOMIZATION = awsModuleDep(
"service/internal/s3shared", null, Versions.INTERNAL_S3SHARED, "s3shared");
public static final GoDependency ACCEPT_ENCODING_CUSTOMIZATION = awsModuleDep(
"service/internal/accept-encoding", null, Versions.INTERNAL_ACCEPTENCODING, "acceptencodingcust");
public static final GoDependency KINESIS_CUSTOMIZATION = aws(
"service/kinesis/internal/customizations", "kinesiscust");
public static final GoDependency MACHINE_LEARNING_CUSTOMIZATION = aws(
"service/machinelearning/internal/customizations", "mlcust");
public static final GoDependency ROUTE53_CUSTOMIZATION = aws(
"service/route53/internal/customizations", "route53cust");
public static final GoDependency PRESIGNEDURL_CUSTOMIZATION = awsModuleDep(
"service/internal/presigned-url", null, Versions.INTERNAL_PRESIGNURL, "presignedurlcust");
public static final GoDependency EVENTBRIDGE_CUSTOMIZATION = aws("service/eventbridge/internal/customizations", "ebcust");
private AwsCustomGoDependency() {
super();
}
private static final class Versions {
private static final String INTERNAL_S3SHARED = "v1.2.3";
private static final String INTERNAL_ACCEPTENCODING = "v1.0.5";
private static final String INTERNAL_PRESIGNURL = "v1.0.7";
}
}
| 8,373 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/DisableEndpointHostPrefix.java | package software.amazon.smithy.aws.go.codegen.customization;
import java.util.Optional;
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.GoIntegration;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.pattern.SmithyPattern.Segment;
import software.amazon.smithy.model.traits.EndpointTrait;
import software.amazon.smithy.model.shapes.OperationShape;
public class DisableEndpointHostPrefix implements GoIntegration {
@Override
public void renderPostEndpointResolutionHook(
GoSettings settings, GoWriter writer, Model model, Optional<OperationShape> operation
) {
if (!S3ModelUtils.isServiceS3Control(model, settings.getService(model))) {
return;
}
if (operation.isPresent() && operation.get().getTrait(EndpointTrait.class).isPresent()) {
EndpointTrait endpointTrait = operation.get().getTrait(EndpointTrait.class).get();
boolean written = false;
for (Segment segment : endpointTrait.getHostPrefix().getLabels()) {
if (segment.isLabel() && segment.getContent().equals("AccountId") && !written) {
writer.write(
"""
ctx = $T(ctx, true)
""",
SymbolUtils.createPointableSymbolBuilder(
"DisableEndpointHostPrefix", SmithyGoDependency.SMITHY_HTTP_TRANSPORT).build()
);
// we only want the content above written ONCE per operation.
written = true;
}
}
}
}
}
| 8,374 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3ExportInternalFeatures.java | /*
* 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.aws.go.codegen.customization;
import software.amazon.smithy.codegen.core.Symbol;
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.GoIntegration;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.shapes.ServiceShape;
/**
* Exports internal functionality from the s3shared package.
*/
public class S3ExportInternalFeatures implements GoIntegration {
@Override
public byte getOrder() {
return 127;
}
@Override
public void writeAdditionalFiles(
GoSettings settings, Model model, SymbolProvider symbolProvider, GoDelegator goDelegator
) {
ServiceShape service = settings.getService(model);
if (!requiresCustomization(model, service)) {
return;
}
goDelegator.useShapeWriter(service, writer -> {
writeResponseErrorInterface(writer);
writeGetHostIDWrapper(writer);
});
}
private void writeGetHostIDWrapper(GoWriter writer) {
Symbol metadata = SymbolUtils.createPointableSymbolBuilder("Metadata",
SmithyGoDependency.SMITHY_MIDDLEWARE).build();
Symbol getHostID = SymbolUtils.createValueSymbolBuilder("GetHostIDMetadata",
AwsCustomGoDependency.S3_SHARED_CUSTOMIZATION).build();
writer.writeDocs("GetHostIDMetadata retrieves the host id from middleware metadata "
+ "returns host id as string along with a boolean indicating presence of "
+ "hostId on middleware metadata.");
writer.openBlock("func GetHostIDMetadata(metadata $T) (string, bool) {", "}", metadata, () -> {
writer.write("return $T(metadata)", getHostID);
});
}
private void writeResponseErrorInterface(GoWriter writer) {
writer.writeDocs("ResponseError provides the HTTP centric error type wrapping the underlying error "
+ "with the HTTP response value and the deserialized RequestID.");
writer.openBlock("type ResponseError interface {", "}", () -> {
writer.write("error").write("");
writer.write("ServiceHostID() string");
writer.write("ServiceRequestID() string");
}).write("");
writer.write("var _ ResponseError = ($P)(nil)", SymbolUtils.createPointableSymbolBuilder("ResponseError",
AwsCustomGoDependency.S3_SHARED_CUSTOMIZATION).build());
}
// returns true if service is either s3 or s3 control
private static boolean requiresCustomization(Model model, ServiceShape service) {
return S3ModelUtils.isServiceS3(model, service) || S3ModelUtils.isServiceS3Control(model, service);
}
}
| 8,375 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3HttpPathBucketFilterIntegration.java | /*
* Copyright 2023 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.aws.go.codegen.customization;
import java.util.logging.Logger;
import java.util.regex.Pattern;
import software.amazon.smithy.go.codegen.GoSettings;
import software.amazon.smithy.go.codegen.integration.GoIntegration;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.pattern.UriPattern;
import software.amazon.smithy.model.traits.HttpTrait;
import software.amazon.smithy.model.transform.ModelTransformer;
import software.amazon.smithy.utils.SmithyInternalApi;
@SmithyInternalApi
public class S3HttpPathBucketFilterIntegration implements GoIntegration {
private static final Logger LOGGER = Logger.getLogger(S3HttpPathBucketFilterIntegration.class.getName());
@Override
public Model preprocessModel(Model model, GoSettings settings) {
if (!S3ModelUtils.isServiceS3(model, settings.getService(model))) {
return model;
}
LOGGER.info("Filtering S3 HTTP Bucket Bindings in URI Paths in Http Traits");
return ModelTransformer.create().mapTraits(model, (shape, trait) -> {
if (trait instanceof HttpTrait) {
HttpTrait httpTrait = (HttpTrait) trait;
UriPattern uriPattern = UriPattern.parse(Pattern
.compile("\\{Bucket}/?")
.matcher(httpTrait.getUri().toString())
.replaceAll(""));
LOGGER.info("Replacing URI Path for " + httpTrait + ": "
+ httpTrait.getUri().toString() + " => " + uriPattern.toString());
return httpTrait.toBuilder()
.uri(uriPattern)
.build();
}
return trait;
});
}
}
| 8,376 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/LambdaRecursionDetection.java | package software.amazon.smithy.aws.go.codegen.customization;
import software.amazon.smithy.aws.go.codegen.AwsGoDependency;
import software.amazon.smithy.go.codegen.SymbolUtils;
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.utils.ListUtils;
import java.util.List;
/**
* Add middleware during operation builder step, which detects Lambda environment and sets its X-Ray trace ID to
* request header if absent to avoid recursion invocation in Lambda
*/
public class LambdaRecursionDetection implements GoIntegration {
/**
* Gets the sort order of the customization from -128 to 127, with lowest
* executed first.
*
* @return Returns the sort order, defaults to -40.
*/
@Override
public byte getOrder() {
return 126;
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return ListUtils.of(
RuntimeClientPlugin.builder()
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(
"AddRecursionDetection", AwsGoDependency.AWS_MIDDLEWARE)
.build())
.build()
)
.build()
);
}
}
| 8,377 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3ErrorWith200Status.java | package software.amazon.smithy.aws.go.codegen.customization;
import java.util.List;
import java.util.Set;
import software.amazon.smithy.go.codegen.SymbolUtils;
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.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.utils.ListUtils;
import software.amazon.smithy.utils.SetUtils;
/**
* Adds middleware to handle S3 response errors with 200 ok status code.
*/
public class S3ErrorWith200Status implements GoIntegration {
private static String ADD_ERROR_HANDLER_INTERNAL = "HandleResponseErrorWith200Status";
// list of operations for which this customization is valid.
private static Set<String> customizedOperations = SetUtils.of(
"CopyObject", "UploadPartCopy", "CompleteMultipartUpload");
@Override
public byte getOrder() {
// The associated customization ordering is relative to operation deserializers
// and thus the integration should be added at the end.
return 127;
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return ListUtils.of(
RuntimeClientPlugin.builder()
.operationPredicate(S3ErrorWith200Status::supports200Error)
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(ADD_ERROR_HANDLER_INTERNAL,
AwsCustomGoDependency.S3_CUSTOMIZATION).build())
.build())
.build()
);
}
// returns true if the operation supports error response with 200 ok status code
private static boolean supports200Error(Model model, ServiceShape service, OperationShape operation){
if (!isS3Service(model, service)) {
return false;
}
return customizedOperations.contains(operation.getId().getName(service));
}
// returns true if service is s3
private static boolean isS3Service(Model model, ServiceShape service) {
return S3ModelUtils.isServiceS3(model, service);
}
}
| 8,378 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/PresignURLAutoFill.java | /*
* 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.aws.go.codegen.customization;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.logging.Logger;
import software.amazon.smithy.aws.go.codegen.AwsGoDependency;
import software.amazon.smithy.codegen.core.Symbol;
import software.amazon.smithy.codegen.core.SymbolProvider;
import software.amazon.smithy.go.codegen.CodegenUtils;
import software.amazon.smithy.go.codegen.GoCodegenPlugin;
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.GoIntegration;
import software.amazon.smithy.go.codegen.integration.MiddlewareRegistrar;
import software.amazon.smithy.go.codegen.integration.ProtocolUtils;
import software.amazon.smithy.go.codegen.integration.RuntimeClientPlugin;
import software.amazon.smithy.go.codegen.trait.NoSerializeTrait;
import software.amazon.smithy.go.codegen.trait.UnexportedMemberTrait;
import software.amazon.smithy.model.Model;
import software.amazon.smithy.model.shapes.MemberShape;
import software.amazon.smithy.model.shapes.OperationShape;
import software.amazon.smithy.model.shapes.ServiceShape;
import software.amazon.smithy.model.shapes.Shape;
import software.amazon.smithy.model.shapes.ShapeId;
import software.amazon.smithy.model.shapes.StringShape;
import software.amazon.smithy.model.shapes.StructureShape;
import software.amazon.smithy.model.traits.DocumentationTrait;
import software.amazon.smithy.utils.IoUtils;
import software.amazon.smithy.utils.MapUtils;
import software.amazon.smithy.utils.SetUtils;
/**
* PresignURLAutoFill represents a runtime plugin integration class
* used generate customization to autofill a presign url as
* an unexported serialized input member
*/
public class PresignURLAutoFill implements GoIntegration {
/**
* Map of service shape to Set of operation shapes that need to have this
* presigned url auto fill customization.
*/
public static final Map<ShapeId, Set<ShapeId>> SERVICE_TO_OPERATION_MAP = MapUtils.of(
ShapeId.from("com.amazonaws.rds#AmazonRDSv19"), SetUtils.of(
ShapeId.from("com.amazonaws.rds#CopyDBSnapshot"),
ShapeId.from("com.amazonaws.rds#CreateDBInstanceReadReplica"),
ShapeId.from("com.amazonaws.rds#CopyDBClusterSnapshot"),
ShapeId.from("com.amazonaws.rds#CreateDBCluster")),
ShapeId.from("com.amazonaws.neptune#AmazonRDSv19"), SetUtils.of(
ShapeId.from("com.amazonaws.neptune#CopyDBClusterSnapshot"),
ShapeId.from("com.amazonaws.neptune#CreateDBCluster")),
ShapeId.from("com.amazonaws.docdb#AmazonRDSv19"), SetUtils.of(
ShapeId.from("com.amazonaws.docdb#CopyDBClusterSnapshot"),
ShapeId.from("com.amazonaws.docdb#CreateDBCluster")),
ShapeId.from("com.amazonaws.ec2#AmazonEC2"), SetUtils.of(
ShapeId.from("com.amazonaws.ec2#CopySnapshot"))
// TODO other services
);
private static final Logger LOGGER = Logger.getLogger(PresignURLAutoFill.class.getName());
private final List<RuntimeClientPlugin> runtimeClientPlugins = new ArrayList<>();
private static void writeMemberSetter(
GoWriter writer,
SymbolProvider symbolprovider,
OperationShape operation,
StructureShape input,
MemberShape member
) {
Symbol operationSymbol = symbolprovider.toSymbol(operation);
Symbol inputSymbol = symbolprovider.toSymbol(input);
String memberName = symbolprovider.toMemberName(member);
writer.openBlock("func $L(params interface{}, value string) error {", "}",
setterFuncName(operationSymbol.getName(), memberName),
() -> {
writer.addUseImports(SmithyGoDependency.FMT);
writer.write("input, ok := params.($P)", inputSymbol);
writer.openBlock("if !ok {", "}", () -> {
writer.write("return fmt.Errorf(\"expect $P type, got %T\", params)", inputSymbol);
});
writer.write("input.$L = &value", memberName);
writer.write("return nil");
});
}
private static void writeMemberGetter(
GoWriter writer,
SymbolProvider symbolprovider,
OperationShape operation,
StructureShape input,
MemberShape member
) {
Symbol operationSymbol = symbolprovider.toSymbol(operation);
Symbol inputSymbol = symbolprovider.toSymbol(input);
String memberName = symbolprovider.toMemberName(member);
writer.openBlock("func $L(params interface{}) (string, bool, error) {", "}",
getterFuncName(operationSymbol.getName(), memberName),
() -> {
writer.addUseImports(SmithyGoDependency.FMT);
writer.write("input, ok := params.($P)", inputSymbol);
writer.openBlock("if !ok {", "}", () -> {
writer.write("return ``, false, fmt.Errorf(\"expect $P type, got %T\", params)", inputSymbol);
});
writer.openBlock("if input.$L == nil || len(*input.$L) == 0 {", "}", memberName, memberName,
() -> writer.write("return ``, false, nil")
);
writer.write("return *input.$L, true, nil", memberName);
});
}
private static String addPresignMiddlewareFuncName(String operationName) {
return String.format("add%sPresignURLMiddleware", operationName);
}
private static String getterFuncName(String operationName, String memberName) {
return String.format("get%s%s", operationName, memberName);
}
private static String setterFuncName(String operationName, String memberName) {
return String.format("set%s%s", operationName, memberName);
}
private static String copyInputFuncName(String inputName) {
return String.format("copy%sForPresign", inputName);
}
private static String presignFuncName(String operationName) {
return String.format("Presign%s", operationName);
}
private static String autofillPresignClient(String operationName) {
return String.format("presignAutoFill%sClient", operationName);
}
/**
* Updates the API model to add additional members to the operation input shape that are needed for presign url
* customization.
*
* @param model API model
* @param settings Go codegen settings
* @return updated API model
*/
@Override
public Model preprocessModel(Model model, GoSettings settings) {
ShapeId serviceId = settings.getService();
if (!SERVICE_TO_OPERATION_MAP.containsKey(serviceId)) {
return model;
}
Model.Builder builder = model.toBuilder();
Shape customString = StringShape.builder().id("sdk.customizations.presignURL#String").build();
builder.addShape(customString);
Set<ShapeId> operationIds = SERVICE_TO_OPERATION_MAP.get(serviceId);
for (ShapeId operationId : operationIds) {
OperationShape operation = model.expectShape(operationId, OperationShape.class);
StructureShape input = ProtocolUtils.expectInput(model, operation);
StructureShape.Builder inputBuilder = input.toBuilder();
if (input.getAllMembers().containsKey("SourceRegion")) {
// In the case of EC2 the SourceRegion member is expected to be serialized.
LOGGER.warning("SourceRegion member is present in model and does not require backfill");
} else {
inputBuilder.addMember("SourceRegion", customString.getId(), (memberBuilder) -> {
memberBuilder
.addTrait(new DocumentationTrait(
"The AWS region the resource is in. The presigned URL will be created with this region, " +
"if the PresignURL member is empty set."))
.addTrait(new NoSerializeTrait());
});
}
// Even if the input already contains DestinationRegion replace it with a unexported member.
inputBuilder.addMember("DestinationRegion", customString.getId(), (memberBuilder) -> {
memberBuilder
.addTrait(new DocumentationTrait(
"Used by the SDK's PresignURL autofill customization to specify the region " +
"the of the client's request."))
.addTrait(new UnexportedMemberTrait());
});
// Add unmodeled parameters needed by presign customization
builder.addShape(inputBuilder.build());
}
return builder.build();
}
/**
* Generates additional types and logic for the presign customization middleware.
* * Generates member getter and setter functions
* * Generates API presign client
* * Generates the connection between middleware, members, and api presign client.
*
* @param settings codegen settings
* @param model api model
* @param symbolProvider codegen symbol provider
* @param goDelegator writer provider
*/
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
ShapeId serviceId = settings.getService();
if (!SERVICE_TO_OPERATION_MAP.containsKey(serviceId)) {
return;
}
ServiceShape service = model.expectShape(serviceId, ServiceShape.class);
Set<ShapeId> operationIds = SERVICE_TO_OPERATION_MAP.get(serviceId);
for (ShapeId operationId : operationIds) {
OperationShape operation = model.expectShape(operationId, OperationShape.class);
StructureShape input = ProtocolUtils.expectInput(model, operation);
goDelegator.useShapeWriter(operation, (writer) -> {
// Need to copy input parameters for presign url.
writeInputCopy(writer, symbolProvider, input);
// Members used by the customization need abstract getter and setters
writeMemberAccessor(writer, symbolProvider, operation, input);
// Generate the presign client
writePresignClientCustomization(writer, settings, model, symbolProvider, operation, input);
// Generate the autofill presign client and its PresignURL method
writeAutofillPresignClient(writer, symbolProvider, operation, input);
});
goDelegator.useShapeTestWriter(operation, (writer) -> {
writePresignClientCustomizationTest(writer, symbolProvider, operation, input);
});
}
}
/**
* Builds the set of runtime plugs used by the presign url customization.
*
* @param settings codegen settings
* @param model api model
*/
@Override
public void processFinalizedModel(GoSettings settings, Model model) {
ShapeId serviceId = settings.getService();
if (!SERVICE_TO_OPERATION_MAP.containsKey(serviceId)) {
return;
}
ServiceShape service = settings.getService(model);
for (ShapeId operationId : SERVICE_TO_OPERATION_MAP.get(serviceId)) {
final OperationShape operation = model.expectShape(operationId, OperationShape.class);
// Create a symbol provider because one is not available in this call.
SymbolProvider symbolProvider = GoCodegenPlugin.createSymbolProvider(model, settings);
String helperFuncName = addPresignMiddlewareFuncName(symbolProvider.toSymbol(operation).getName());
runtimeClientPlugins.add(RuntimeClientPlugin.builder()
.servicePredicate((m, s) -> s.equals(service))
.operationPredicate((m, s, o) -> o.equals(operation))
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(helperFuncName)
.build())
.useClientOptions()
.build())
.build());
}
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return runtimeClientPlugins;
}
private void writeInputCopy(
GoWriter writer,
SymbolProvider symbolProvider,
StructureShape input
) {
Symbol inputSymbol = symbolProvider.toSymbol(input);
writer.openBlock("func $L(params interface{}) (interface{}, error) {", "}",
copyInputFuncName(inputSymbol.getName()),
() -> {
writer.addUseImports(SmithyGoDependency.FMT);
writer.write("input, ok := params.($P)", inputSymbol);
writer.openBlock("if !ok {", "}", () -> {
writer.write("return nil, fmt.Errorf(\"expect $P type, got %T\", params)", inputSymbol);
});
writer.write("cpy := *input");
writer.write("return &cpy, nil");
});
}
private void writeMemberAccessor(
GoWriter writer,
SymbolProvider symbolProvider,
OperationShape operation,
StructureShape input
) {
// PresignedUrl member name has inconsistent casing across the services
MemberShape presignURLMember = CodegenUtils.expectMember(input, "PresignedUrl"::equalsIgnoreCase);
MemberShape dstRegionMember = CodegenUtils.expectMember(input, "DestinationRegion");
MemberShape srcRegionMember = CodegenUtils.expectMember(input, "SourceRegion");
MemberShape[] getMembers = {presignURLMember, srcRegionMember};
for (MemberShape member : getMembers) {
writeMemberGetter(writer, symbolProvider, operation, input, member);
}
MemberShape[] setMembers = {presignURLMember, dstRegionMember};
for (MemberShape member : setMembers) {
writeMemberSetter(writer, symbolProvider, operation, input, member);
}
}
private void writePresignClientCustomization(
GoWriter writer,
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
OperationShape operation,
StructureShape input
) {
Symbol smithyStack = SymbolUtils.createPointableSymbolBuilder("Stack",
SmithyGoDependency.SMITHY_MIDDLEWARE).build();
Symbol operationSymbol = symbolProvider.toSymbol(operation);
Symbol inputSymbol = symbolProvider.toSymbol(input);
String presignURLMember = symbolProvider.toMemberName(
CodegenUtils.expectMember(input, "PresignedUrl"::equalsIgnoreCase));
String dstRegionMember = symbolProvider.toMemberName(CodegenUtils.expectMember(input, "DestinationRegion"));
String srcRegionMember = symbolProvider.toMemberName(CodegenUtils.expectMember(input, "SourceRegion"));
Symbol parameterAccessor = SymbolUtils.createValueSymbolBuilder("ParameterAccessor",
AwsCustomGoDependency.PRESIGNEDURL_CUSTOMIZATION).build();
Symbol addMiddlewareOptions = SymbolUtils.createValueSymbolBuilder("Options",
AwsCustomGoDependency.PRESIGNEDURL_CUSTOMIZATION).build();
Symbol addMiddleware = SymbolUtils.createValueSymbolBuilder("AddMiddleware",
AwsCustomGoDependency.PRESIGNEDURL_CUSTOMIZATION).build();
// generate middleware mutator to wire up presign client with accessors and custom middleware.
writer.openBlock("func $L(stack $P, options Options) error {", "}",
addPresignMiddlewareFuncName(operationSymbol.getName()),
smithyStack,
() -> {
writer.openBlock("return $T(stack, $T{", "})", addMiddleware, addMiddlewareOptions, () -> {
writer.openBlock("Accessor: $T{", "},", parameterAccessor, () -> {
writer.write("GetPresignedURL: $L, \n",
getterFuncName(operationSymbol.getName(), presignURLMember));
writer.write("GetSourceRegion: $L, \n",
getterFuncName(operationSymbol.getName(), srcRegionMember));
writer.write("CopyInput: $L, \n", copyInputFuncName(inputSymbol.getName()));
writer.write("SetDestinationRegion: $L,\n",
setterFuncName(operationSymbol.getName(), dstRegionMember));
writer.write("SetPresignedURL: $L, \n",
setterFuncName(operationSymbol.getName(), presignURLMember));
});
writer.write("Presigner: &$L{ client: NewPresignClient(New(options))}, \n",
autofillPresignClient(operationSymbol.getName()));
});
});
}
private void writeAutofillPresignClient(
GoWriter writer,
SymbolProvider symbolprovider,
OperationShape operation,
StructureShape input
) {
Symbol operationSymbol = symbolprovider.toSymbol(operation);
Symbol inputSymbol = symbolprovider.toSymbol(input);
Symbol removeMiddleware = SymbolUtils.createValueSymbolBuilder("RemoveMiddleware",
AwsCustomGoDependency.PRESIGNEDURL_CUSTOMIZATION).build();
// generate autofill presign client
writer.openBlock("type $L struct {", "}",
autofillPresignClient(operationSymbol.getName()), () -> {
writer.write("client *PresignClient");
});
writer.write("");
// generate PresignURL method that satisfies URLPresigner interface of middleware
writer.writeDocs("PresignURL is a middleware accessor that satisfies URLPresigner interface.");
writer.openBlock("func (c *$L) PresignURL(ctx context.Context, srcRegion string, params interface{}) "
+ "(*v4.PresignedHTTPRequest, error) {", "}",
autofillPresignClient(operationSymbol.getName()), () -> {
writer.addUseImports(SmithyGoDependency.FMT);
// check input
writer.write("input, ok := params.($P)", inputSymbol);
writer.openBlock("if !ok {", "}", () -> {
writer.write("return nil, fmt.Errorf(\"expect $P type, got %T\", params)", inputSymbol);
});
// generate client options
writer.openBlock("optFn := func(o *Options) {", "}", () -> {
writer.write("o.Region = srcRegion");
writer.write("o.APIOptions = append(o.APIOptions, $T)", removeMiddleware);
});
// getPresignAPIOptions
writer.write("presignOptFn := WithPresignClientFromClientOptions(optFn)");
// call the exported function
writer.write("return c.client.$L(ctx, input, presignOptFn)",
presignFuncName(operationSymbol.getName()));
});
writer.write("");
}
private void writePresignClientCustomizationTest(
GoWriter writer,
SymbolProvider symbolProvider,
OperationShape operation,
StructureShape input
) {
String presignURLMember = symbolProvider.toMemberName(
CodegenUtils.expectMember(input, "PresignedUrl"::equalsIgnoreCase));
String dstRegionMember = symbolProvider.toMemberName(CodegenUtils.expectMember(input, "DestinationRegion"));
String srcRegionMember = symbolProvider.toMemberName(CodegenUtils.expectMember(input, "SourceRegion"));
Map<String, String> replaces = new TreeMap<>();
replaces.put("operation", symbolProvider.toSymbol(operation).getName());
replaces.put("input", symbolProvider.toSymbol(input).getName());
replaces.put("presignURL_member", presignURLMember);
replaces.put("srcRegion_member", srcRegionMember);
replaces.put("dstRegion_member", dstRegionMember);
String template = IoUtils.readUtf8Resource(getClass(), "presign_url.go.template");
for (Map.Entry<String, String> entry : replaces.entrySet()) {
template = template.replaceAll("\\$\\{" + entry.getKey() + "}", entry.getValue());
}
writer.addUseImports(SmithyGoDependency.NET_HTTP);
writer.addUseImports(SmithyGoDependency.CONTEXT);
writer.addUseImports(SmithyGoDependency.STRINGS);
writer.addUseImports(SmithyGoDependency.TESTING);
writer.addUseImports(SmithyGoDependency.SMITHY_HTTP_TRANSPORT);
writer.addUseImports(SmithyGoDependency.SMITHY_MIDDLEWARE);
writer.addUseImports(AwsGoDependency.AWS_CORE);
writer.addUseImports(AwsGoDependency.AWSTESTING_UNIT);
writer.addUseImports(AwsCustomGoDependency.PRESIGNEDURL_CUSTOMIZATION);
writer.write(template);
}
}
| 8,379 |
0 | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen | Create_ds/aws-sdk-go-v2/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/DynamoDBValidateResponseChecksum.java | /*
* 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.aws.go.codegen.customization;
import java.util.List;
import software.amazon.smithy.aws.traits.ServiceTrait;
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.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.shapes.ServiceShape;
import software.amazon.smithy.utils.ListUtils;
public class DynamoDBValidateResponseChecksum implements GoIntegration {
private static final String CHECKSUM_CLIENT_OPTION = "DisableValidateResponseChecksum";
private static final String CHECKSUM_ADDER = "addValidateResponseChecksum";
private static final String CHECKSUM_INTERNAL_ADDER = "AddValidateResponseChecksum";
private static final String GZIP_CLIENT_OPTION = "EnableAcceptEncodingGzip";
private static final String GZIP_ADDER = "addAcceptEncodingGzip";
private static final String GZIP_INTERNAL_ADDER = "AddAcceptEncodingGzip";
/**
* Gets the sort order of the customization from -128 to 127, with lowest
* executed first.
*
* @return Returns the sort order, defaults to -40.
*/
@Override
public byte getOrder() {
return 127;
}
@Override
public void writeAdditionalFiles(
GoSettings settings,
Model model,
SymbolProvider symbolProvider,
GoDelegator goDelegator
) {
if (!isDynamoDBService(model, settings.getService(model))) {
return;
}
goDelegator.useShapeWriter(settings.getService(model), this::writeMiddlewareHelper);
}
private void writeMiddlewareHelper(GoWriter writer) {
writer.openBlock("func $L(stack *middleware.Stack, options Options) error {", "}", CHECKSUM_ADDER, () -> {
writer.write("return $T(stack, $T{Disable: options.$L})",
SymbolUtils.createValueSymbolBuilder(CHECKSUM_INTERNAL_ADDER,
AwsCustomGoDependency.DYNAMODB_CUSTOMIZATION).build(),
SymbolUtils.createValueSymbolBuilder(CHECKSUM_INTERNAL_ADDER + "Options",
AwsCustomGoDependency.DYNAMODB_CUSTOMIZATION).build(),
CHECKSUM_CLIENT_OPTION
);
});
writer.write("");
writer.openBlock("func $L(stack *middleware.Stack, options Options) error {", "}", GZIP_ADDER, () -> {
writer.write("return $T(stack, $T{Enable: options.$L})",
SymbolUtils.createValueSymbolBuilder(GZIP_INTERNAL_ADDER,
AwsCustomGoDependency.ACCEPT_ENCODING_CUSTOMIZATION).build(),
SymbolUtils.createValueSymbolBuilder(GZIP_INTERNAL_ADDER + "Options",
AwsCustomGoDependency.ACCEPT_ENCODING_CUSTOMIZATION).build(),
GZIP_CLIENT_OPTION
);
});
writer.write("");
}
@Override
public List<RuntimeClientPlugin> getClientPlugins() {
return ListUtils.of(
// Add DynamoDB Checksum customization middleware to deserialize.
RuntimeClientPlugin.builder()
.servicePredicate(DynamoDBValidateResponseChecksum::isDynamoDBService)
.configFields(ListUtils.of(
ConfigField.builder()
.name(CHECKSUM_CLIENT_OPTION)
.type(SymbolUtils.createValueSymbolBuilder("bool")
.putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true)
.build())
.documentation("Allows you to disable the client's validation of "
+ "response integrity using CRC32 checksum. Enabled by default.")
.build()
))
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(CHECKSUM_ADDER)
.build())
.useClientOptions()
.build()
)
.build(),
// Add DynamoDB explicit control over accept-encoding: gzip.
RuntimeClientPlugin.builder()
.servicePredicate(DynamoDBValidateResponseChecksum::isDynamoDBService)
.configFields(ListUtils.of(
ConfigField.builder()
.name(GZIP_CLIENT_OPTION)
.type(SymbolUtils.createValueSymbolBuilder("bool")
.putProperty(SymbolUtils.GO_UNIVERSE_TYPE, true)
.build())
.documentation("Allows you to enable the client's support for "
+ "compressed gzip responses. Disabled by default.")
.build()
))
.registerMiddleware(MiddlewareRegistrar.builder()
.resolvedFunction(SymbolUtils.createValueSymbolBuilder(GZIP_ADDER)
.build())
.useClientOptions()
.build()
)
.build()
);
}
private static boolean isDynamoDBService(Model model, ServiceShape service) {
return service.expectTrait(ServiceTrait.class).getSdkId().equalsIgnoreCase("DynamoDB");
}
}
| 8,380 |
0 | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest/jmh/DirectConcurrentTest.java | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License 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 org.apache.camel.itest.jmh;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import org.apache.camel.CamelContext;
import org.apache.camel.Endpoint;
import org.apache.camel.ProducerTemplate;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.impl.DefaultCamelContext;
import org.junit.jupiter.api.Test;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.Level;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.TearDown;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
/**
* Tests a simple Camel route
*/
public class DirectConcurrentTest {
@Test
public void launchBenchmark() throws Exception {
Options opt = new OptionsBuilder()
// Specify which benchmarks to run.
// You can be more specific if you'd like to run only one benchmark per test.
.include(this.getClass().getName() + ".*")
// Set the following options as needed
.mode(Mode.AverageTime)
.timeUnit(TimeUnit.MICROSECONDS)
.warmupIterations(1)
.measurementIterations(15)
.threads(4)
.forks(1)
.shouldFailOnError(true)
.shouldDoGC(true)
.resultFormat(ResultFormatType.JSON)
.result(this.getClass().getSimpleName() + ".jmh.json")
.build();
new Runner(opt).run();
}
// The JMH samples are the best documentation for how to use it
// http://hg.openjdk.java.net/code-tools/jmh/file/tip/jmh-samples/src/main/java/org/openjdk/jmh/samples/
@State(Scope.Thread)
public static class BenchmarkState {
CamelContext camel;
ProducerTemplate producer;
Endpoint endpoint;
String someString = "test1";
File sampleFile = new File("some-file");
Integer someInt = Integer.valueOf(1);
Long someLong = Long.valueOf(2);
@Setup(Level.Trial)
public void initialize() {
camel = new DefaultCamelContext();
endpoint = camel.getEndpoint("direct:start");
try {
camel.addRoutes(new RouteBuilder() {
@Override
public void configure() throws Exception {
from("direct:start")
.to("direct:a")
.to("direct:b")
.to("direct:c")
.to("mock:result?retainFirst=0");
from("direct:a")
.to("log:a?level=OFF");
from("direct:b")
.to("log:b?level=OFF");
from("direct:c")
.to("log:c?level=OFF");
}
});
camel.start();
producer = camel.createProducerTemplate();
} catch (Exception e) {
// ignore
}
}
@TearDown(Level.Trial)
public void close() {
try {
producer.stop();
camel.stop();
} catch (Exception e) {
// ignore
}
}
}
@Benchmark
public void directConcurrentTest(BenchmarkState state, Blackhole bh) {
state.producer.sendBody(state.endpoint, state.someString);
}
@Benchmark
public void directConcurrentTestWithMultipleTypes(BenchmarkState state, Blackhole bh) {
state.producer.sendBody(state.endpoint, state.someString);
state.producer.sendBody(state.endpoint, state.someInt);
state.producer.sendBody(state.endpoint, state.someLong);
state.producer.sendBody(state.endpoint, state.sampleFile);
}
}
| 8,381 |
0 | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest/jmh/SedaRoundTripTest.java | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License 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 org.apache.camel.itest.jmh;
import java.io.File;
import java.util.concurrent.TimeUnit;
import org.apache.camel.CamelContext;
import org.apache.camel.ConsumerTemplate;
import org.apache.camel.Endpoint;
import org.apache.camel.ProducerTemplate;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.impl.DefaultCamelContext;
import org.junit.jupiter.api.Test;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Level;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
public class SedaRoundTripTest {
@Test
public void launchBenchmark() throws Exception {
Options opt = new OptionsBuilder()
// Specify which benchmarks to run.
// You can be more specific if you'd like to run only one benchmark per test.
.include(this.getClass().getName() + ".*")
// Set the following options as needed
.measurementIterations(10)
.warmupIterations(5)
.forks(1)
.resultFormat(ResultFormatType.JSON)
.result(this.getClass().getSimpleName() + ".jmh.json")
.build();
new Runner(opt).run();
}
// The JMH samples are the best documentation for how to use it
// http://hg.openjdk.java.net/code-tools/jmh/file/tip/jmh-samples/src/main/java/org/openjdk/jmh/samples/
@State(Scope.Benchmark)
public static class BenchmarkState {
CamelContext context;
ProducerTemplate producerTemplate;
ConsumerTemplate consumerTemplate;
Endpoint producerEndpoint;
Endpoint consumerEndpoint;
String someString = "test1";
File sampleFile = new File("some-file");
Integer someInt = Integer.valueOf(1);
Long someLong = Long.valueOf(2);
@Setup(Level.Trial)
public void initialize() throws Exception {
context = new DefaultCamelContext();
producerTemplate = context.createProducerTemplate();
consumerTemplate = context.createConsumerTemplate();
producerEndpoint = context.getEndpoint("seda:test?blockWhenFull=true&offerTimeout=1000");
consumerEndpoint = context.getEndpoint("seda:test");
context.start();
}
}
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@BenchmarkMode({Mode.Throughput, Mode.AverageTime, Mode.SingleShotTime})
@Benchmark
public void sendBlocking(SedaRoundTripTest.BenchmarkState state, Blackhole bh) {
state.producerTemplate.sendBody(state.producerEndpoint, state.someString);
bh.consume(state.consumerTemplate.receive(state.consumerEndpoint));
}
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@BenchmarkMode({Mode.Throughput, Mode.AverageTime, Mode.SingleShotTime})
@Benchmark
public void sendBlockingWithMultipleTypes(SedaRoundTripTest.BenchmarkState state, Blackhole bh) {
state.producerTemplate.sendBody(state.producerEndpoint, state.someString);
bh.consume(state.consumerTemplate.receive(state.consumerEndpoint));
state.producerTemplate.sendBody(state.producerEndpoint, state.someLong);
bh.consume(state.consumerTemplate.receive(state.consumerEndpoint));
state.producerTemplate.sendBody(state.producerEndpoint, state.someInt);
bh.consume(state.consumerTemplate.receive(state.consumerEndpoint));
state.producerTemplate.sendBody(state.producerEndpoint, state.sampleFile);
bh.consume(state.consumerTemplate.receive(state.consumerEndpoint));
}
}
| 8,382 |
0 | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest/jmh/CSimpleScript3.java | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License 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 org.apache.camel.itest.jmh;
import org.apache.camel.CamelContext;
import org.apache.camel.Exchange;
import org.apache.camel.Message;
import org.apache.camel.language.csimple.CSimpleSupport;
import static org.apache.camel.language.csimple.CSimpleHelper.headerAs;
public class CSimpleScript3 extends CSimpleSupport {
public CSimpleScript3() {
}
@Override
public String getText() {
return "${header.gold} < 123";
}
@Override
public Object evaluate(CamelContext context, Exchange exchange, Message message, Object body)
throws Exception {
return headerAs(message, "gold", int.class) < 123;
}
@Override
public boolean isPredicate() {
return true;
}
}
| 8,383 |
0 | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest/jmh/EndpointHelperTest.java | package org.apache.camel.itest.jmh;
import java.util.concurrent.TimeUnit;
import org.apache.camel.Endpoint;
import org.apache.camel.ProducerTemplate;
import org.apache.camel.ServiceStatus;
import org.apache.camel.impl.DefaultCamelContext;
import org.apache.camel.spi.EndpointRegistry;
import org.apache.camel.support.EndpointHelper;
import org.apache.camel.support.NormalizedUri;
import org.junit.jupiter.api.Test;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Level;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
/**
* These tests specific operations of the EndpointHelper in single-thread scenarios.
*/
public class EndpointHelperTest {
@Test
public void launchBenchmark() throws Exception {
Options opt = new OptionsBuilder()
// Specify which benchmarks to run.
// You can be more specific if you'd like to run only one benchmark per test.
.include(this.getClass().getName() + ".*")
// Set the following options as needed
.measurementIterations(10)
.warmupIterations(5)
.forks(1)
.resultFormat(ResultFormatType.JSON)
.result(this.getClass().getSimpleName() + ".jmh.json")
.build();
new Runner(opt).run();
}
@State(Scope.Benchmark)
public static class BenchmarkState {
DefaultCamelContext context;
ProducerTemplate producerTemplate;
EndpointRegistry<NormalizedUri> endpointRegistry;
String[] stringRoutes = new String[500];
NormalizedUri[] routes = new NormalizedUri[500];
NormalizedUri[] nonExistentRoutes = new NormalizedUri[500];
Endpoint[] endpoints = new Endpoint[500];
@Setup(Level.Trial)
public void initialize() throws Exception {
context = new DefaultCamelContext();
context.start();
producerTemplate = context.createProducerTemplate();
endpointRegistry = context.getEndpointRegistry();
for (int i = 0; i < routes.length; i++) {
final String route = "controlbus:route?routeId=route" + i + "&action=status&loggingLevel=off";
stringRoutes[i] = route;
routes[i] = NormalizedUri.newNormalizedUri(route, false);
endpoints[i] = context.getEndpoint(route);
producerTemplate.requestBody(endpoints[i], null, ServiceStatus.class);
nonExistentRoutes[i] = NormalizedUri.newNormalizedUri("controlbus:route?routeId=nonExistentRoutes" + i + "&action=status&loggingLevel=off",
false);
}
}
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Benchmark
public void testMatchEndpointSame(BenchmarkState state, Blackhole bh) {
for (String route : state.stringRoutes) {
bh.consume(EndpointHelper.matchEndpoint(state.context, route, route));
}
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Benchmark
public void testMatchEndpointNotSame(BenchmarkState state, Blackhole bh) {
for (int i = 0; i < state.routes.length; i++) {
bh.consume(EndpointHelper.matchEndpoint(state.context, state.routes[i].toString(), state.stringRoutes[i]));
}
}
}
| 8,384 |
0 | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest/jmh/SimpleOperatorTest.java | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License 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 org.apache.camel.itest.jmh;
import java.util.concurrent.TimeUnit;
import org.apache.camel.CamelContext;
import org.apache.camel.Exchange;
import org.apache.camel.impl.DefaultCamelContext;
import org.apache.camel.spi.Language;
import org.apache.camel.support.DefaultExchange;
import org.junit.jupiter.api.Test;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.Level;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.TearDown;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import org.openjdk.jmh.runner.options.TimeValue;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Tests a Simple operator expression
*/
public class SimpleOperatorTest {
private static final Logger LOG = LoggerFactory.getLogger(SimpleOperatorTest.class);
@Test
public void launchBenchmark() throws Exception {
Options opt = new OptionsBuilder()
// Specify which benchmarks to run.
// You can be more specific if you'd like to run only one benchmark per test.
.include(this.getClass().getName() + ".*")
// Set the following options as needed
.mode(Mode.All)
.timeUnit(TimeUnit.MICROSECONDS)
.warmupTime(TimeValue.seconds(1))
.warmupIterations(2)
.measurementTime(TimeValue.seconds(10))
.measurementIterations(2)
.threads(2)
.forks(1)
.shouldFailOnError(true)
.shouldDoGC(true)
.resultFormat(ResultFormatType.JSON)
.result(this.getClass().getSimpleName() + ".jmh.json")
.build();
new Runner(opt).run();
}
// The JMH samples are the best documentation for how to use it
// http://hg.openjdk.java.net/code-tools/jmh/file/tip/jmh-samples/src/main/java/org/openjdk/jmh/samples/
@State(Scope.Thread)
public static class BenchmarkState {
CamelContext camel;
String expression = "${header.gold} == 123";
String expression2 = "${header.gold} > 123";
String expression3 = "${header.gold} < 123";
Exchange exchange;
Language simple;
@Setup(Level.Trial)
public void initialize() {
camel = new DefaultCamelContext();
try {
camel.start();
exchange = new DefaultExchange(camel);
exchange.getIn().setBody("World");
exchange.getIn().setHeader("gold", "123");
simple = camel.resolveLanguage("simple");
} catch (Exception e) {
// ignore
}
}
@TearDown(Level.Trial)
public void close() {
try {
LOG.info("" + camel.getTypeConverterRegistry().getStatistics());
camel.stop();
} catch (Exception e) {
// ignore
}
}
}
@Benchmark
@Measurement(batchSize = 1000)
public void simplePredicate(BenchmarkState state, Blackhole bh) {
boolean out = state.simple.createPredicate(state.expression).matches(state.exchange);
if (!out) {
throw new IllegalArgumentException("Evaluation failed");
}
bh.consume(out);
boolean out2 = state.simple.createPredicate(state.expression2).matches(state.exchange);
if (out2) {
throw new IllegalArgumentException("Evaluation failed");
}
bh.consume(out2);
boolean out3 = state.simple.createPredicate(state.expression3).matches(state.exchange);
if (out3) {
throw new IllegalArgumentException("Evaluation failed");
}
bh.consume(out3);
}
}
| 8,385 |
0 | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest/jmh/ContextStartStopTest.java | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License 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 org.apache.camel.itest.jmh;
import java.util.concurrent.TimeUnit;
import org.apache.camel.CamelContext;
import org.apache.camel.ExtendedCamelContext;
import org.apache.camel.impl.DefaultCamelContext;
import org.apache.camel.impl.engine.PrototypeExchangeFactory;
import org.apache.camel.model.ModelCamelContext;
import org.junit.jupiter.api.Test;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.Level;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
public class ContextStartStopTest {
@Test
public void launchBenchmark() throws Exception {
Options opt = new OptionsBuilder()
// Specify which benchmarks to run.
// You can be more specific if you'd like to run only one benchmark per test.
.include(this.getClass().getName() + ".*")
// Set the following options as needed
.mode(Mode.Throughput)
.timeUnit(TimeUnit.MICROSECONDS)
.measurementIterations(10)
.warmupIterations(5)
.forks(1)
.resultFormat(ResultFormatType.JSON)
.result(this.getClass().getSimpleName() + ".jmh.json")
.build();
new Runner(opt).run();
}
// The JMH samples are the best documentation for how to use it
// http://hg.openjdk.java.net/code-tools/jmh/file/tip/jmh-samples/src/main/java/org/openjdk/jmh/samples/
@State(Scope.Benchmark)
public static class BenchmarkState {
CamelContext context;
PrototypeExchangeFactory factory;
ExtendedCamelContext extendedCamelContext;
ModelCamelContext modelCamelContext;
@Setup(Level.Trial)
public void initialize() {
context = new DefaultCamelContext();
}
}
@Benchmark
public void contextCycle(ContextStartStopTest.BenchmarkState state, Blackhole bh) {
state.context.start();
state.context.stop();
bh.consume(state.context);
}
}
| 8,386 |
0 | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest/jmh/CSimpleScript2.java | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License 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 org.apache.camel.itest.jmh;
import org.apache.camel.CamelContext;
import org.apache.camel.Exchange;
import org.apache.camel.Message;
import org.apache.camel.language.csimple.CSimpleSupport;
import static org.apache.camel.language.csimple.CSimpleHelper.headerAs;
public class CSimpleScript2 extends CSimpleSupport {
public CSimpleScript2() {
}
@Override
public String getText() {
return "${header.gold} > 123";
}
@Override
public Object evaluate(CamelContext context, Exchange exchange, Message message, Object body)
throws Exception {
return headerAs(message, "gold", int.class) > 123;
}
@Override
public boolean isPredicate() {
return true;
}
}
| 8,387 |
0 | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest/jmh/SimpleExpressionTest.java | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License 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 org.apache.camel.itest.jmh;
import java.util.concurrent.TimeUnit;
import org.apache.camel.CamelContext;
import org.apache.camel.Exchange;
import org.apache.camel.impl.DefaultCamelContext;
import org.apache.camel.spi.Language;
import org.apache.camel.support.DefaultExchange;
import org.junit.jupiter.api.Test;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.Level;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.TearDown;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import org.openjdk.jmh.runner.options.TimeValue;
/**
* Tests a Simple expression
*/
public class SimpleExpressionTest {
@Test
public void launchBenchmark() throws Exception {
Options opt = new OptionsBuilder()
// Specify which benchmarks to run.
// You can be more specific if you'd like to run only one benchmark per test.
.include(this.getClass().getName() + ".*")
// Set the following options as needed
.mode(Mode.All)
.timeUnit(TimeUnit.MICROSECONDS)
.warmupTime(TimeValue.seconds(1))
.warmupIterations(2)
.measurementTime(TimeValue.seconds(10))
.measurementIterations(2)
.threads(2)
.forks(1)
.shouldFailOnError(true)
.shouldDoGC(true)
.resultFormat(ResultFormatType.JSON)
.result(this.getClass().getSimpleName() + ".jmh.json")
.build();
new Runner(opt).run();
}
// The JMH samples are the best documentation for how to use it
// http://hg.openjdk.java.net/code-tools/jmh/file/tip/jmh-samples/src/main/java/org/openjdk/jmh/samples/
@State(Scope.Thread)
public static class BenchmarkState {
CamelContext camel;
String expression = "Hello ${body}";
Exchange exchange;
Language simple;
@Setup(Level.Trial)
public void initialize() {
camel = new DefaultCamelContext();
try {
camel.start();
exchange = new DefaultExchange(camel);
exchange.getIn().setBody("World");
simple = camel.resolveLanguage("simple");
} catch (Exception e) {
// ignore
}
}
@TearDown(Level.Trial)
public void close() {
try {
camel.stop();
} catch (Exception e) {
// ignore
}
}
}
@Benchmark
@Measurement(batchSize = 1000)
public void simpleExpression(BenchmarkState state, Blackhole bh) {
String out = state.simple.createExpression(state.expression).evaluate(state.exchange, String.class);
if (!out.equals("Hello World")) {
throw new IllegalArgumentException("Evaluation failed");
}
bh.consume(out);
}
}
| 8,388 |
0 | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest/jmh/DisruptorScalabilityProducerTest.java | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License 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 org.apache.camel.itest.jmh;
import java.util.concurrent.TimeUnit;
import org.apache.camel.CamelContext;
import org.apache.camel.Endpoint;
import org.apache.camel.ProducerTemplate;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.impl.DefaultCamelContext;
import org.junit.jupiter.api.Test;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Level;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Param;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.Threads;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
/**
* This tests the scalability of the disruptor component when running with many threads. You need a large machine for running
* this reliably: desktops and machines with a small number of cores may introduce excessive scheduler latency affecting the
* results.
*/
public class DisruptorScalabilityProducerTest {
@Test
public void launchBenchmark() throws Exception {
Options opt = new OptionsBuilder()
// Specify which benchmarks to run.
// You can be more specific if you'd like to run only one benchmark per test.
.include(this.getClass().getName() + ".*")
// Set the following options as needed
.measurementIterations(10)
.warmupIterations(5)
.forks(1)
.resultFormat(ResultFormatType.JSON)
.result(this.getClass().getSimpleName() + ".jmh.json")
.build();
new Runner(opt).run();
}
// The JMH samples are the best documentation for how to use it
// http://hg.openjdk.java.net/code-tools/jmh/file/tip/jmh-samples/src/main/java/org/openjdk/jmh/samples/
@State(Scope.Benchmark)
public static class BenchmarkState {
@Param({"1", "8", "16", "32"})
int consumers;
CamelContext context;
ProducerTemplate producerTemplate;
Endpoint endpoint;
@Setup(Level.Trial)
public void initialize() throws Exception {
context = new DefaultCamelContext();
producerTemplate = context.createProducerTemplate();
endpoint = context.getEndpoint("disruptor:test");
context.addRoutes(new RouteBuilder() {
@Override
public void configure() {
fromF("disruptor:test?concurrentConsumers=%s", consumers).to("log:?level=OFF");
}
});
context.start();
}
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Benchmark
@Threads(8)
public void send_8(BenchmarkState state, Blackhole bh) {
state.producerTemplate.sendBody(state.endpoint, "test");
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Benchmark
@Threads(16)
public void send_16(BenchmarkState state, Blackhole bh) {
state.producerTemplate.sendBody(state.endpoint, "test");
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Benchmark
@Threads(32)
public void send_32(BenchmarkState state, Blackhole bh) {
state.producerTemplate.sendBody(state.endpoint, "test");
}
}
| 8,389 |
0 | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest/jmh/TypeConverterTest.java | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License 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 org.apache.camel.itest.jmh;
import java.io.ByteArrayInputStream;
import java.io.CharArrayReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeUnit;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.w3c.dom.Document;
import org.apache.camel.CamelContext;
import org.apache.camel.LoggingLevel;
import org.apache.camel.impl.DefaultCamelContext;
import org.apache.camel.util.IOHelper;
import org.junit.jupiter.api.Test;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.Level;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.TearDown;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import org.openjdk.jmh.runner.options.TimeValue;
/**
* Tests {@link org.apache.camel.TypeConverter}
*/
public class TypeConverterTest {
@Test
public void launchBenchmark() throws Exception {
Options opt = new OptionsBuilder()
// Specify which benchmarks to run.
// You can be more specific if you'd like to run only one benchmark per test.
.include(this.getClass().getName() + ".*")
// Set the following options as needed
.mode(Mode.Throughput)
.timeUnit(TimeUnit.MILLISECONDS)
.warmupTime(TimeValue.seconds(1))
.warmupIterations(2)
.measurementTime(TimeValue.seconds(5))
.measurementIterations(3)
.threads(1)
.forks(1)
.shouldFailOnError(true)
.shouldDoGC(true)
.measurementBatchSize(1000)
.resultFormat(ResultFormatType.JSON)
.result(this.getClass().getSimpleName() + ".jmh.json")
.build();
new Runner(opt).run();
}
// The JMH samples are the best documentation for how to use it
// http://hg.openjdk.java.net/code-tools/jmh/file/tip/jmh-samples/src/main/java/org/openjdk/jmh/samples/
@State(Scope.Thread)
public static class BenchmarkCamelContextState {
Integer someInteger = 12345;
String someIntegerString = String.valueOf(someInteger);
ByteArrayInputStream bos;
String xmlAsString;
byte[] xmlAsBytes;
char[] xmlAsCharArray;
CamelContext camel;
@Setup(Level.Trial)
public void initialize() throws IOException {
camel = new DefaultCamelContext();
try {
camel.start();
} catch (Exception e) {
// ignore
}
xmlAsString = IOHelper.loadText(getClass().getClassLoader().getResourceAsStream("sample_soap.xml"));
xmlAsBytes = xmlAsString.getBytes(StandardCharsets.UTF_8);
xmlAsCharArray = xmlAsString.toCharArray();
bos = new ByteArrayInputStream(xmlAsBytes);
}
@TearDown(Level.Trial)
public void close() {
try {
camel.stop();
} catch (Exception e) {
// ignore
}
}
}
@Benchmark
public void typeConvertIntegerToString(BenchmarkCamelContextState state, Blackhole bh) {
String string = state.camel.getTypeConverter().convertTo(String.class, state.someInteger);
bh.consume(string);
}
@Benchmark
public void typeConvertStringToInteger(BenchmarkCamelContextState state, Blackhole bh) {
Integer integer = state.camel.getTypeConverter().convertTo(Integer.class, state.someIntegerString);
bh.consume(integer);
}
@Benchmark
public void typeConvertTheSameTypes(BenchmarkCamelContextState state, Blackhole bh) {
String string = state.camel.getTypeConverter().convertTo(String.class, state.someIntegerString);
bh.consume(string);
}
@Benchmark
public void typeConvertInputStreamToString(BenchmarkCamelContextState state, Blackhole bh) {
state.bos.reset();
String string = state.camel.getTypeConverter().convertTo(String.class, state.bos);
bh.consume(string);
}
@Benchmark
public void typeConvertStringToInputStream(BenchmarkCamelContextState state, Blackhole bh) {
InputStream inputStream = state.camel.getTypeConverter().convertTo(InputStream.class, state.xmlAsString);
bh.consume(inputStream);
}
@Benchmark
public void typeConvertStringToDocument(BenchmarkCamelContextState state, Blackhole bh) {
Document document = state.camel.getTypeConverter().convertTo(Document.class, state.xmlAsString);
bh.consume(document);
}
@Benchmark
public void typeConvertStringToByteArray(BenchmarkCamelContextState state, Blackhole bh) {
byte[] bytes = state.camel.getTypeConverter().convertTo(byte[].class, state.xmlAsString);
bh.consume(bytes);
}
@Benchmark
public void typeConvertByteArrayToString(BenchmarkCamelContextState state, Blackhole bh) {
String string = state.camel.getTypeConverter().convertTo(String.class, state.xmlAsBytes);
bh.consume(string);
}
@Benchmark
public void typeConvertStringToEnum(BenchmarkCamelContextState state, Blackhole bh) {
LoggingLevel level = state.camel.getTypeConverter().convertTo(LoggingLevel.class, "WARN");
bh.consume(level);
}
@Benchmark
public void typeConvertReaderToByteArray(BenchmarkCamelContextState state, Blackhole bh) {
Reader reader = new CharArrayReader(state.xmlAsCharArray);
byte[] arr = state.camel.getTypeConverter().convertTo(byte[].class, reader);
bh.consume(arr);
bh.consume(reader);
}
}
| 8,390 |
0 | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest/jmh/DefaultUuidGeneratorTest.java | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License 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 org.apache.camel.itest.jmh;
import org.apache.camel.support.DefaultUuidGenerator;
import org.junit.jupiter.api.Test;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.Level;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.Threads;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import java.util.concurrent.TimeUnit;
/**
* Tests the {@link DefaultUuidGenerator}.
* <p/>
* Thanks to this SO answer: https://stackoverflow.com/questions/30485856/how-to-run-jmh-from-inside-junit-tests
*/
public class DefaultUuidGeneratorTest {
@Test
public void launchBenchmark() throws Exception {
Options opt = new OptionsBuilder()
// Specify which benchmarks to run.
// You can be more specific if you'd like to run only one benchmark per test.
.include(this.getClass().getName() + ".*")
// Set the following options as needed
.mode(Mode.SingleShotTime)
.timeUnit(TimeUnit.MILLISECONDS)
.warmupIterations(5)
.warmupBatchSize(5000)
.measurementIterations(2)
.threads(2)
.forks(1)
.shouldFailOnError(true)
.shouldDoGC(true)
.resultFormat(ResultFormatType.JSON)
.result(this.getClass().getSimpleName() + ".jmh.json")
.build();
new Runner(opt).run();
}
// The JMH samples are the best documentation for how to use it
// http://hg.openjdk.java.net/code-tools/jmh/file/tip/jmh-samples/src/main/java/org/openjdk/jmh/samples/
@State(Scope.Thread)
public static class BenchmarkState {
DefaultUuidGenerator uuid;
@Setup(Level.Trial)
public void initialize() {
uuid = new DefaultUuidGenerator();
}
}
@Benchmark
@Measurement(batchSize = 1000000)
public void benchmark(BenchmarkState state, Blackhole bh) {
String id = state.uuid.generateUuid();
bh.consume(id);
}
@Benchmark
@Measurement(batchSize = 1000000)
@Threads(2)
public void benchmark_2(BenchmarkState state, Blackhole bh) {
String id = state.uuid.generateUuid();
bh.consume(id);
}
@Benchmark
@Measurement(batchSize = 1000000)
@Threads(4)
public void benchmark_4(BenchmarkState state, Blackhole bh) {
String id = state.uuid.generateUuid();
bh.consume(id);
}
@Benchmark
@Measurement(batchSize = 1000000)
@Threads(8)
public void benchmark_8(BenchmarkState state, Blackhole bh) {
String id = state.uuid.generateUuid();
bh.consume(id);
}
@Benchmark
@Measurement(batchSize = 1000000)
@Threads(16)
public void benchmark_16(BenchmarkState state, Blackhole bh) {
String id = state.uuid.generateUuid();
bh.consume(id);
}
@Benchmark
@Measurement(batchSize = 1000000)
@Threads(32)
public void benchmark_32(BenchmarkState state, Blackhole bh) {
String id = state.uuid.generateUuid();
bh.consume(id);
}
}
| 8,391 |
0 | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest/jmh/EndpointRegistryScalabilityTest.java | package org.apache.camel.itest.jmh;
import java.util.concurrent.TimeUnit;
import org.apache.camel.Endpoint;
import org.apache.camel.ProducerTemplate;
import org.apache.camel.ServiceStatus;
import org.apache.camel.impl.DefaultCamelContext;
import org.apache.camel.spi.EndpointRegistry;
import org.apache.camel.support.NormalizedUri;
import org.junit.jupiter.api.Test;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Level;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.Threads;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
/**
* These tests specific operations of the Endpoint registry in multi-thread scenarios.
*/
public class EndpointRegistryScalabilityTest {
@Test
public void launchBenchmark() throws Exception {
Options opt = new OptionsBuilder()
// Specify which benchmarks to run.
// You can be more specific if you'd like to run only one benchmark per test.
.include(this.getClass().getName() + ".*")
// Set the following options as needed
.measurementIterations(10)
.warmupIterations(5)
.forks(1)
.resultFormat(ResultFormatType.JSON)
.result(this.getClass().getSimpleName() + ".jmh.json")
.build();
new Runner(opt).run();
}
@State(Scope.Benchmark)
public static class BenchmarkState {
DefaultCamelContext context;
ProducerTemplate producerTemplate;
EndpointRegistry<NormalizedUri> endpointRegistry;
NormalizedUri[] routes = new NormalizedUri[500];
NormalizedUri[] nonExistentRoutes = new NormalizedUri[500];
Endpoint[] endpoints = new Endpoint[500];
@Setup(Level.Trial)
public void initialize() throws Exception {
context = new DefaultCamelContext();
context.start();
producerTemplate = context.createProducerTemplate();
endpointRegistry = context.getEndpointRegistry();
for (int i = 0; i < routes.length; i++) {
String route = "controlbus:route?routeId=route" + i + "&action=status&loggingLevel=off";
routes[i] = NormalizedUri.newNormalizedUri(route, false);
endpoints[i] = context.getEndpoint(route);
producerTemplate.requestBody(endpoints[i], null, ServiceStatus.class);
nonExistentRoutes[i] = NormalizedUri.newNormalizedUri("controlbus:route?routeId=nonExistentRoutes" + i + "&action=status&loggingLevel=off",
false);
}
}
}
private static void doContainsCheck(BenchmarkState state, Blackhole bh) {
for (NormalizedUri route : state.routes) {
bh.consume(state.endpointRegistry.containsKey(route));
}
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Threads(2)
@Benchmark
public void testContainsNonExistentKey_2(BenchmarkState state, Blackhole bh) {
doContainsCheck(state, bh);
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Threads(4)
@Benchmark
public void testContainsNonExistentKey_4(BenchmarkState state, Blackhole bh) {
doContainsCheck(state, bh);
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Threads(8)
@Benchmark
public void testContainsNonExistentKey_8(BenchmarkState state, Blackhole bh) {
doContainsCheck(state, bh);
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Threads(2)
@Benchmark
public void testContainsNonExistentValue_2(BenchmarkState state, Blackhole bh) {
doContainsValueCheck(state, bh);
}
private static void doContainsValueCheck(BenchmarkState state, Blackhole bh) {
for (Endpoint ep : state.endpoints) {
bh.consume(state.endpointRegistry.containsValue(ep));
}
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Threads(4)
@Benchmark
public void testContainsNonExistentValue_4(BenchmarkState state, Blackhole bh) {
doContainsValueCheck(state, bh);
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Threads(8)
@Benchmark
public void testContainsNonExistentValue_8(BenchmarkState state, Blackhole bh) {
doContainsValueCheck(state, bh);
}
private static void doIsDynamicCheck(BenchmarkState state, Blackhole bh) {
for (NormalizedUri route : state.routes) {
bh.consume(state.endpointRegistry.isDynamic(route.get()));
}
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Threads(2)
@Benchmark
public void testIsDynamic_2(BenchmarkState state, Blackhole bh) {
doIsDynamicCheck(state, bh);
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Threads(4)
@Benchmark
public void testIsDynamic_4(BenchmarkState state, Blackhole bh) {
doIsDynamicCheck(state, bh);
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Threads(8)
@Benchmark
public void testIsDynamic_8(BenchmarkState state, Blackhole bh) {
doIsDynamicCheck(state, bh);
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Threads(2)
@Benchmark
public void testDynamicSize_2(BenchmarkState state, Blackhole bh) {
bh.consume(state.endpointRegistry.dynamicSize());
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Threads(4)
@Benchmark
public void testDynamicSize_4(BenchmarkState state, Blackhole bh) {
bh.consume(state.endpointRegistry.dynamicSize());
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Threads(8)
@Benchmark
public void testDynamicSize_8(BenchmarkState state, Blackhole bh) {
bh.consume(state.endpointRegistry.dynamicSize());
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Threads(2)
@Benchmark
public void testReadOnlyMap_2(BenchmarkState state, Blackhole bh) {
bh.consume(state.endpointRegistry.getReadOnlyMap());
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Threads(4)
@Benchmark
public void testReadOnlyMap_4(BenchmarkState state, Blackhole bh) {
bh.consume(state.endpointRegistry.getReadOnlyMap());
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Threads(8)
@Benchmark
public void testReadOnlyMap_8(BenchmarkState state, Blackhole bh) {
bh.consume(state.endpointRegistry.getReadOnlyMap());
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Threads(2)
@Benchmark
public void testReadOnlyValues_2(BenchmarkState state, Blackhole bh) {
bh.consume(state.endpointRegistry.getReadOnlyValues());
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Threads(4)
@Benchmark
public void testReadOnlyValues_4(BenchmarkState state, Blackhole bh) {
bh.consume(state.endpointRegistry.getReadOnlyValues());
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Threads(8)
@Benchmark
public void testReadOnlyValues_8(BenchmarkState state, Blackhole bh) {
bh.consume(state.endpointRegistry.getReadOnlyValues());
}
}
| 8,392 |
0 | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest/jmh/CoreObjectsCreationTest.java | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License 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 org.apache.camel.itest.jmh;
import java.util.concurrent.TimeUnit;
import org.apache.camel.CamelContext;
import org.apache.camel.impl.DefaultCamelContext;
import org.apache.camel.support.DefaultExchange;
import org.apache.camel.support.DefaultMessage;
import org.junit.jupiter.api.Test;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Level;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
/**
* This tests the cost of creating exchanges.
*/
public class CoreObjectsCreationTest {
@Test
public void launchBenchmark() throws Exception {
Options opt = new OptionsBuilder()
// Specify which benchmarks to run.
// You can be more specific if you'd like to run only one benchmark per test.
.include(this.getClass().getName() + ".*")
// Set the following options as needed
.measurementIterations(10)
.warmupIterations(5)
.forks(1)
.resultFormat(ResultFormatType.JSON)
.result(this.getClass().getSimpleName() + ".jmh.json")
.build();
new Runner(opt).run();
}
// The JMH samples are the best documentation for how to use it
// http://hg.openjdk.java.net/code-tools/jmh/file/tip/jmh-samples/src/main/java/org/openjdk/jmh/samples/
@State(Scope.Benchmark)
public static class BenchmarkState {
CamelContext context;
@Setup(Level.Trial)
public void initialize() throws Exception {
context = new DefaultCamelContext();
context.start();
}
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Benchmark
public void createDefaultExchange(BenchmarkState state, Blackhole bh) {
DefaultExchange de = new DefaultExchange(state.context);
bh.consume(de);
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Benchmark
public void createDefaultMessage(BenchmarkState state, Blackhole bh) {
DefaultMessage dm = new DefaultMessage(state.context);
bh.consume(dm);
}
}
| 8,393 |
0 | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest/jmh/SlowTypeConverterTest.java | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License 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 org.apache.camel.itest.jmh;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import org.apache.camel.CamelContext;
import org.apache.camel.impl.DefaultCamelContext;
import org.junit.jupiter.api.Test;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.Level;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.TearDown;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import org.openjdk.jmh.runner.options.TimeValue;
/**
* Tests the default slow {@link org.apache.camel.TypeConverter} which uses method call reflection
*/
public class SlowTypeConverterTest {
@Test
public void launchBenchmark() throws Exception {
Options opt = new OptionsBuilder()
// Specify which benchmarks to run.
// You can be more specific if you'd like to run only one benchmark per test.
.include(this.getClass().getName() + ".*")
// Set the following options as needed
.mode(Mode.SampleTime)
.timeUnit(TimeUnit.MILLISECONDS)
.warmupTime(TimeValue.seconds(1))
.warmupIterations(2)
.measurementTime(TimeValue.seconds(5))
.measurementIterations(3)
.threads(1)
.forks(1)
.shouldFailOnError(true)
.shouldDoGC(true)
.measurementBatchSize(100000)
.resultFormat(ResultFormatType.JSON)
.result(this.getClass().getSimpleName() + ".jmh.json")
.build();
new Runner(opt).run();
}
// The JMH samples are the best documentation for how to use it
// http://hg.openjdk.java.net/code-tools/jmh/file/tip/jmh-samples/src/main/java/org/openjdk/jmh/samples/
@State(Scope.Thread)
public static class BenchmarkCamelContextState {
ByteBuf buffer;
byte[] bytes = "Hello World this is some text".getBytes();
CamelContext camel;
@Setup(Level.Trial)
public void initialize() throws IOException {
camel = new DefaultCamelContext();
try {
camel.start();
} catch (Exception e) {
// ignore
}
buffer = ByteBufAllocator.DEFAULT.buffer(bytes.length);
buffer.writeBytes(bytes);
}
@TearDown(Level.Trial)
public void close() {
try {
camel.stop();
} catch (Exception e) {
// ignore
}
}
}
@Benchmark
public void typeConvertByteBufToArray(BenchmarkCamelContextState state, Blackhole bh) {
byte[] arr = state.camel.getTypeConverter().convertTo(byte[].class, state.buffer);
bh.consume(arr);
}
}
| 8,394 |
0 | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest/jmh/FileComponentPollingDirectoryTest.java | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License 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 org.apache.camel.itest.jmh;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import org.apache.camel.CamelContext;
import org.apache.camel.Processor;
import org.apache.camel.component.file.FileConsumer;
import org.apache.camel.component.file.FileEndpoint;
import org.apache.camel.component.file.GenericFile;
import org.apache.camel.component.file.GenericFileOperations;
import org.apache.camel.component.file.GenericFileProcessStrategy;
import org.apache.camel.impl.DefaultCamelContext;
import org.junit.jupiter.api.Test;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.Param;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
/**
* Tests the {@link org.apache.camel.component.file.FileConsumer#pollDirectory} method
*/
@State(Scope.Thread)
public class FileComponentPollingDirectoryTest {
private MyFileEndpoint endpoint;
private CustomFileConsumer consumer;
@Param(".")
private String inputDir;
private int depth = 1;
private int subDirs = 5;
private int numFiles = 20000;
private List<GenericFile<File>> fileList = new ArrayList<>();
private class CustomFileConsumer extends FileConsumer {
public CustomFileConsumer(FileEndpoint endpoint, Processor processor, GenericFileOperations<File> operations, GenericFileProcessStrategy<File> processStrategy) {
super(endpoint, processor, operations, processStrategy);
}
@Override
public boolean pollDirectory(String fileName, List<GenericFile<File>> fileList, int depth) {
return super.pollDirectory(fileName, fileList, depth);
}
}
private class MyFileEndpoint extends FileEndpoint {
@Override
protected FileConsumer newFileConsumer(Processor processor, GenericFileOperations<File> operations) {
return new CustomFileConsumer(this, processor, operations, createGenericFileStrategy());
}
}
public String createFakeFiles() throws Exception {
Path baseDir = Paths.get(this.getClass().getResource(".").getFile(), "file-component-test-data");
baseDir = Files.createDirectories(baseDir);
for (int d = 0; d < depth; d++) {
Path testDir = Files.createTempDirectory(baseDir, "file-component");
for (int i = 0; i < subDirs; i++) {
Path subDir = Files.createTempDirectory(testDir, "file-component");
for (int f = 0; f < numFiles; f++) {
Files.createTempFile(subDir, "tmp", "test");
}
}
}
return baseDir.toString();
}
@Setup
public void prepare() throws Exception {
CamelContext context = new DefaultCamelContext();
endpoint = new MyFileEndpoint();
endpoint.setNoop(true);
endpoint.setRecursive(true);
System.out.println("Running with Camel version: " + context.getVersion());
context.addEndpoint("perf-file", endpoint);
consumer = (CustomFileConsumer) endpoint.newFileConsumer(exchange -> {}, null);
}
@Benchmark
public void testFilePolling() {
System.out.println("Polling from " + inputDir);
consumer.pollDirectory(inputDir, fileList, 0);
System.out.println("Polled files: " + fileList.size());
}
@Test
public void launchBenchmark() throws Exception {
String inputDir = createFakeFiles();
Options opt = new OptionsBuilder()
.include(this.getClass().getName() + ".*")
.mode(Mode.SingleShotTime)
.timeUnit(TimeUnit.MILLISECONDS)
.forks(15)
.shouldFailOnError(true)
.shouldDoGC(true)
.param("inputDir", inputDir)
.build();
new Runner(opt).run();
}
}
| 8,395 |
0 | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest/jmh/JoorTest.java | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License 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 org.apache.camel.itest.jmh;
import java.util.concurrent.TimeUnit;
import org.apache.camel.CamelContext;
import org.apache.camel.Exchange;
import org.apache.camel.Predicate;
import org.apache.camel.impl.DefaultCamelContext;
import org.apache.camel.spi.Language;
import org.apache.camel.support.DefaultExchange;
import org.junit.jupiter.api.Test;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.Level;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.TearDown;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import org.openjdk.jmh.runner.options.TimeValue;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class JoorTest {
private static final Logger LOG = LoggerFactory.getLogger(JoorTest.class);
@Test
public void launchBenchmark() throws Exception {
Options opt = new OptionsBuilder()
// Specify which benchmarks to run.
// You can be more specific if you'd like to run only one benchmark per test.
.include(this.getClass().getName() + ".*")
// Set the following options as needed
.mode(Mode.All)
.timeUnit(TimeUnit.MICROSECONDS)
.warmupTime(TimeValue.seconds(1))
.warmupIterations(2)
.measurementTime(TimeValue.seconds(10))
.measurementIterations(2)
.threads(2)
.forks(1)
.shouldFailOnError(true)
.shouldDoGC(true)
.resultFormat(ResultFormatType.JSON)
.result(this.getClass().getSimpleName() + ".jmh.json")
.build();
new Runner(opt).run();
}
public static class MyUser {
private int age = 44;
private String name = "tony";
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
// The JMH samples are the best documentation for how to use it
// http://hg.openjdk.java.net/code-tools/jmh/file/tip/jmh-samples/src/main/java/org/openjdk/jmh/samples/
@State(Scope.Thread)
public static class BenchmarkState {
CamelContext camel;
Exchange exchange;
String joorCode
= "var user = message.getBody(org.apache.camel.itest.jmh.JoorTest.MyUser.class); return user.getName() != null && user.getAge() > 20;";
String simpleCode = "${body.name} != null && ${body.age} > 20";
Predicate joorPredicate;
Predicate simplePredicate;
Language joor;
Language simple;
@Setup(Level.Trial)
public void initialize() {
camel = new DefaultCamelContext();
try {
camel.start();
exchange = new DefaultExchange(camel);
exchange.getIn().setBody(new MyUser());
exchange.getIn().setHeader("gold", "123");
joor = camel.resolveLanguage("joor");
joorPredicate = joor.createPredicate(joorCode);
simple = camel.resolveLanguage("simple");
simplePredicate = simple.createPredicate(simpleCode);
} catch (Exception e) {
// ignore
}
}
@TearDown(Level.Trial)
public void close() {
try {
camel.stop();
} catch (Exception e) {
// ignore
}
}
}
@Benchmark
@Measurement(batchSize = 1000)
public void joorPredicate(BenchmarkState state, Blackhole bh) {
boolean out = state.joorPredicate.matches(state.exchange);
if (!out) {
throw new IllegalArgumentException("Evaluation failed");
}
bh.consume(out);
}
@Benchmark
@Measurement(batchSize = 1000)
public void simplePredicate(BenchmarkState state, Blackhole bh) {
boolean out = state.simplePredicate.matches(state.exchange);
if (!out) {
throw new IllegalArgumentException("Evaluation failed");
}
bh.consume(out);
}
}
| 8,396 |
0 | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest/jmh/EndpointRegistryTest.java | package org.apache.camel.itest.jmh;
import java.util.concurrent.TimeUnit;
import org.apache.camel.Endpoint;
import org.apache.camel.ProducerTemplate;
import org.apache.camel.ServiceStatus;
import org.apache.camel.impl.DefaultCamelContext;
import org.apache.camel.spi.EndpointRegistry;
import org.apache.camel.support.NormalizedUri;
import org.junit.jupiter.api.Test;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Level;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
/**
* These tests specific operations of the Endpoint registry in single-thread scenarios.
*/
public class EndpointRegistryTest {
@Test
public void launchBenchmark() throws Exception {
Options opt = new OptionsBuilder()
// Specify which benchmarks to run.
// You can be more specific if you'd like to run only one benchmark per test.
.include(this.getClass().getName() + ".*")
// Set the following options as needed
.measurementIterations(10)
.warmupIterations(5)
.forks(1)
.resultFormat(ResultFormatType.JSON)
.result(this.getClass().getSimpleName() + ".jmh.json")
.build();
new Runner(opt).run();
}
@State(Scope.Benchmark)
public static class BenchmarkState {
DefaultCamelContext context;
ProducerTemplate producerTemplate;
EndpointRegistry<NormalizedUri> endpointRegistry;
NormalizedUri[] routes = new NormalizedUri[500];
NormalizedUri[] nonExistentRoutes = new NormalizedUri[500];
Endpoint[] endpoints = new Endpoint[500];
@Setup(Level.Trial)
public void initialize() throws Exception {
context = new DefaultCamelContext();
context.start();
producerTemplate = context.createProducerTemplate();
endpointRegistry = context.getEndpointRegistry();
for (int i = 0; i < routes.length; i++) {
String route = "controlbus:route?routeId=route" + i + "&action=status&loggingLevel=off";
routes[i] = NormalizedUri.newNormalizedUri(route, false);
endpoints[i] = context.getEndpoint(route);
producerTemplate.requestBody(endpoints[i], null, ServiceStatus.class);
nonExistentRoutes[i] = NormalizedUri.newNormalizedUri("controlbus:route?routeId=nonExistentRoutes" + i + "&action=status&loggingLevel=off",
false);
}
}
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Benchmark
public void testContainsExistentKey(BenchmarkState state, Blackhole bh) {
for (NormalizedUri route : state.routes) {
bh.consume(state.endpointRegistry.containsKey(route));
}
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Benchmark
public void testContainsNonExistentKey(BenchmarkState state, Blackhole bh) {
for (NormalizedUri route : state.nonExistentRoutes) {
bh.consume(state.endpointRegistry.containsKey(route));
}
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Benchmark
public void testContainsNonExistentValue(BenchmarkState state, Blackhole bh) {
for (Endpoint ep : state.endpoints) {
bh.consume(state.endpointRegistry.containsValue(ep));
}
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Benchmark
public void testIsDynamic(BenchmarkState state, Blackhole bh) {
for (NormalizedUri route : state.routes) {
bh.consume(state.endpointRegistry.isDynamic(route.get()));
}
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Benchmark
public void testDynamicSize(BenchmarkState state, Blackhole bh) {
bh.consume(state.endpointRegistry.dynamicSize());
}
// The following methods require camel 4.0.0-M2 or newer. Comment these if running w/ 4.0.0-M1 or 3.x
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Benchmark
public void testReadOnlyMap(BenchmarkState state, Blackhole bh) {
bh.consume(state.endpointRegistry.getReadOnlyMap());
}
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Benchmark
public void testReadOnlyValues(BenchmarkState state, Blackhole bh) {
bh.consume(state.endpointRegistry.getReadOnlyValues());
}
}
| 8,397 |
0 | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest/jmh/SimpleMockPlaceholderTest.java | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License 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 org.apache.camel.itest.jmh;
import java.util.Properties;
import java.util.concurrent.TimeUnit;
import org.apache.camel.CamelContext;
import org.apache.camel.ProducerTemplate;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.impl.DefaultCamelContext;
import org.junit.jupiter.api.Test;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.Level;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.TearDown;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import org.openjdk.jmh.runner.options.TimeValue;
/**
* Tests a simple Camel route
*/
public class SimpleMockPlaceholderTest {
@Test
public void launchBenchmark() throws Exception {
Options opt = new OptionsBuilder()
// Specify which benchmarks to run.
// You can be more specific if you'd like to run only one benchmark per test.
.include(this.getClass().getName() + ".*")
// Set the following options as needed
.mode(Mode.All)
.timeUnit(TimeUnit.MICROSECONDS)
.warmupTime(TimeValue.seconds(1))
.warmupIterations(2)
.measurementTime(TimeValue.seconds(1))
.measurementIterations(2)
.threads(2)
.forks(1)
.shouldFailOnError(true)
.shouldDoGC(true)
.build();
new Runner(opt).run();
}
// The JMH samples are the best documentation for how to use it
// http://hg.openjdk.java.net/code-tools/jmh/file/tip/jmh-samples/src/main/java/org/openjdk/jmh/samples/
@State(Scope.Thread)
public static class BenchmarkState {
CamelContext camel;
ProducerTemplate producer;
@Setup(Level.Trial)
public void initialize() {
camel = new DefaultCamelContext();
Properties prop = new Properties();
prop.put("foolish", "log:foo?groupSize=10");
prop.put("mymock", "mock:result?retainFirst=0");
camel.getPropertiesComponent().setInitialProperties(prop);
try {
camel.addRoutes(new RouteBuilder() {
@Override
public void configure() throws Exception {
from("direct:start").to("{{foolish}}").to("log:bar").to("{{mymock}}");
}
});
camel.start();
producer = camel.createProducerTemplate();
} catch (Exception e) {
// ignore
}
}
@TearDown(Level.Trial)
public void close() {
try {
producer.stop();
camel.stop();
} catch (Exception e) {
// ignore
}
}
}
@Benchmark
@Measurement(batchSize = 1000)
public void simpleMockPlaceholderTest(BenchmarkState state, Blackhole bh) {
ProducerTemplate template = state.producer;
template.sendBody("direct:start", "Hello World");
}
}
| 8,398 |
0 | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest | Create_ds/camel-performance-tests/tests/camel-jmh/src/test/java/org/apache/camel/itest/jmh/ObjectHelperTest.java | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License 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 org.apache.camel.itest.jmh;
import java.util.concurrent.TimeUnit;
import org.apache.camel.support.ObjectHelper;
import org.junit.jupiter.api.Test;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
@State(Scope.Thread)
public class ObjectHelperTest {
private String numericString = "123456789";
private String numericFloatSmall = "123456789.0";
private String numericFloatLarge = "123456789.0000123456789";
private String negativeNumericString = "-123456789";
private String negativeNumericFloatSmall = "-123456789.0";
private String negativeNumericFloatLarge = "-123456789.0000123456789";
private String nonNumericString = "ABCD";
@Test
public void launchBenchmark() throws Exception {
Options opt = new OptionsBuilder()
// Specify which benchmarks to run.
// You can be more specific if you'd like to run only one benchmark per test.
.include(this.getClass().getName() + ".*")
// Set the following options as needed
.measurementIterations(10)
.warmupIterations(5)
.forks(1)
.resultFormat(ResultFormatType.JSON)
.result(this.getClass().getSimpleName() + ".jmh.json")
.build();
new Runner(opt).run();
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public void testIsNumberInteger(Blackhole bh) {
bh.consume(ObjectHelper.isNumber(numericString));
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public void testIsNumberNegativeInteger(Blackhole bh) {
bh.consume(ObjectHelper.isNumber(negativeNumericString));
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public void testIsNumberFloatSmall(Blackhole bh) {
bh.consume(ObjectHelper.isNumber(numericFloatSmall));
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public void testIsNumberNonNumeric(Blackhole bh) {
bh.consume(ObjectHelper.isNumber(nonNumericString));
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public void testIsFloatingNumberNonNumeric(Blackhole bh) {
bh.consume(ObjectHelper.isFloatingNumber(nonNumericString));
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public void testIsFloatingNumberInteger(Blackhole bh) {
bh.consume(ObjectHelper.isFloatingNumber(numericString));
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public void testIsFloatingNumberNumericFloatSmall(Blackhole bh) {
bh.consume(ObjectHelper.isFloatingNumber(numericFloatSmall));
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public void testIsFloatingNumberNumericFloatLarge(Blackhole bh) {
bh.consume(ObjectHelper.isFloatingNumber(numericFloatLarge));
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public void testIsFloatingNumberNegativeNumericFloatSmall(Blackhole bh) {
bh.consume(ObjectHelper.isFloatingNumber(negativeNumericFloatSmall));
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public void testIsFloatingNumberNegativeNumericFloatLarge(Blackhole bh) {
bh.consume(ObjectHelper.isFloatingNumber(negativeNumericFloatLarge));
}
}
| 8,399 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.