From 4a1c633ffd85633e4f179bdd027e4b1580b76625 Mon Sep 17 00:00:00 2001 From: Sean McGrail Date: Fri, 3 Dec 2021 01:02:06 +0000 Subject: [PATCH] Endpoint Prefix & Idempotency Token Auto-fill, and Authentication Bugfixes (#1518) * Ensure TopDownIndex is used when iterating service operations * Temporary Model Fix Transforms for Location Service * Fixed Idempotency Token Autofill * Fixed Endpoint Prefix Bug * Add Changelog Annotations --- .../b51f6004654f4c5eb4799d04a5045020.json | 17 ++++ .../b55ca4d66d1d4102baf0cb7c49f3bde3.json | 9 +++ .../ce7b78be34014ab39c6d0f40cd08bd56.json | 8 ++ .../AwsHttpPresignURLClientGenerator.java | 62 +++++++------- .../codegen/EndpointDiscoveryGenerator.java | 7 +- .../customization/GlacierCustomizations.java | 6 +- .../customization/LocationModelFixes.java | 81 +++++++++++++++++++ .../MachineLearningCustomizations.java | 7 +- .../customization/Route53Customizations.java | 4 +- .../customization/S3GetBucketLocation.java | 6 +- .../S3HeadObjectCustomizations.java | 11 ++- .../customization/S3PaginationExtensions.java | 3 +- .../customization/S3UpdateEndpoint.java | 11 +-- ...mithy.go.codegen.integration.GoIntegration | 1 + .../accessanalyzer/api_op_CreateAnalyzer.go | 37 +++++++++ .../api_op_CreateArchiveRule.go | 37 +++++++++ .../accessanalyzer/api_op_DeleteAnalyzer.go | 37 +++++++++ .../api_op_DeleteArchiveRule.go | 37 +++++++++ .../api_op_UpdateArchiveRule.go | 37 +++++++++ service/amp/api_client.go | 20 +++++ .../api_op_CreateAlertManagerDefinition.go | 37 +++++++++ .../amp/api_op_CreateRuleGroupsNamespace.go | 37 +++++++++ service/amp/api_op_CreateWorkspace.go | 37 +++++++++ .../api_op_DeleteAlertManagerDefinition.go | 37 +++++++++ .../amp/api_op_DeleteRuleGroupsNamespace.go | 37 +++++++++ service/amp/api_op_DeleteWorkspace.go | 37 +++++++++ .../amp/api_op_PutAlertManagerDefinition.go | 37 +++++++++ service/amp/api_op_PutRuleGroupsNamespace.go | 37 +++++++++ service/amp/api_op_UpdateWorkspaceAlias.go | 37 +++++++++ service/appmesh/api_client.go | 20 +++++ service/appmesh/api_op_CreateGatewayRoute.go | 37 +++++++++ service/appmesh/api_op_CreateMesh.go | 37 +++++++++ service/appmesh/api_op_CreateRoute.go | 37 +++++++++ .../appmesh/api_op_CreateVirtualGateway.go | 37 +++++++++ service/appmesh/api_op_CreateVirtualNode.go | 37 +++++++++ service/appmesh/api_op_CreateVirtualRouter.go | 37 +++++++++ .../appmesh/api_op_CreateVirtualService.go | 37 +++++++++ service/appmesh/api_op_UpdateGatewayRoute.go | 37 +++++++++ service/appmesh/api_op_UpdateMesh.go | 37 +++++++++ service/appmesh/api_op_UpdateRoute.go | 37 +++++++++ .../appmesh/api_op_UpdateVirtualGateway.go | 37 +++++++++ service/appmesh/api_op_UpdateVirtualNode.go | 37 +++++++++ service/appmesh/api_op_UpdateVirtualRouter.go | 37 +++++++++ .../appmesh/api_op_UpdateVirtualService.go | 37 +++++++++ service/braket/api_client.go | 20 +++++ service/braket/api_op_CancelQuantumTask.go | 37 +++++++++ service/braket/api_op_CreateJob.go | 37 +++++++++ service/braket/api_op_CreateQuantumTask.go | 37 +++++++++ service/codeguruprofiler/api_client.go | 20 +++++ .../api_op_CreateProfilingGroup.go | 37 +++++++++ .../api_op_PostAgentProfile.go | 37 +++++++++ .../evidently/api_op_BatchEvaluateFeature.go | 31 +++++++ service/evidently/api_op_EvaluateFeature.go | 31 +++++++ service/evidently/api_op_PutProjectEvents.go | 31 +++++++ service/grafana/api_client.go | 20 +++++ service/grafana/api_op_CreateWorkspace.go | 37 +++++++++ .../api_op_AssociateTrackerConsumer.go | 31 +++++++ ...api_op_BatchDeleteDevicePositionHistory.go | 31 +++++++ .../location/api_op_BatchDeleteGeofence.go | 31 +++++++ .../location/api_op_BatchEvaluateGeofences.go | 39 +++++++++ .../location/api_op_BatchGetDevicePosition.go | 31 +++++++ service/location/api_op_BatchPutGeofence.go | 31 +++++++ .../api_op_BatchUpdateDevicePosition.go | 31 +++++++ service/location/api_op_CalculateRoute.go | 31 +++++++ .../api_op_CreateGeofenceCollection.go | 31 +++++++ service/location/api_op_CreateMap.go | 31 +++++++ service/location/api_op_CreatePlaceIndex.go | 31 +++++++ .../location/api_op_CreateRouteCalculator.go | 31 +++++++ service/location/api_op_CreateTracker.go | 31 +++++++ .../api_op_DeleteGeofenceCollection.go | 31 +++++++ service/location/api_op_DeleteMap.go | 31 +++++++ service/location/api_op_DeletePlaceIndex.go | 31 +++++++ .../location/api_op_DeleteRouteCalculator.go | 31 +++++++ service/location/api_op_DeleteTracker.go | 31 +++++++ .../api_op_DescribeGeofenceCollection.go | 39 +++++++++ service/location/api_op_DescribeMap.go | 39 +++++++++ service/location/api_op_DescribePlaceIndex.go | 39 +++++++++ .../api_op_DescribeRouteCalculator.go | 39 +++++++++ service/location/api_op_DescribeTracker.go | 39 +++++++++ .../api_op_DisassociateTrackerConsumer.go | 31 +++++++ service/location/api_op_GetDevicePosition.go | 31 +++++++ .../api_op_GetDevicePositionHistory.go | 30 +++++++ service/location/api_op_GetGeofence.go | 31 +++++++ service/location/api_op_GetMapGlyphs.go | 31 +++++++ service/location/api_op_GetMapSprites.go | 31 +++++++ .../location/api_op_GetMapStyleDescriptor.go | 31 +++++++ service/location/api_op_GetMapTile.go | 31 +++++++ .../location/api_op_ListDevicePositions.go | 30 +++++++ .../api_op_ListGeofenceCollections.go | 30 +++++++ service/location/api_op_ListGeofences.go | 30 +++++++ service/location/api_op_ListMaps.go | 30 +++++++ service/location/api_op_ListPlaceIndexes.go | 30 +++++++ .../location/api_op_ListRouteCalculators.go | 30 +++++++ .../location/api_op_ListTagsForResource.go | 31 +++++++ .../location/api_op_ListTrackerConsumers.go | 30 +++++++ service/location/api_op_ListTrackers.go | 30 +++++++ service/location/api_op_PutGeofence.go | 31 +++++++ .../api_op_SearchPlaceIndexForPosition.go | 31 +++++++ .../api_op_SearchPlaceIndexForText.go | 31 +++++++ service/location/api_op_TagResource.go | 31 +++++++ service/location/api_op_UntagResource.go | 31 +++++++ .../api_op_UpdateGeofenceCollection.go | 31 +++++++ service/location/api_op_UpdateMap.go | 31 +++++++ service/location/api_op_UpdatePlaceIndex.go | 31 +++++++ .../location/api_op_UpdateRouteCalculator.go | 31 +++++++ service/location/api_op_UpdateTracker.go | 31 +++++++ service/nimble/api_client.go | 20 +++++ service/nimble/api_op_AcceptEulas.go | 37 +++++++++ service/nimble/api_op_CreateLaunchProfile.go | 37 +++++++++ service/nimble/api_op_CreateStreamingImage.go | 37 +++++++++ .../nimble/api_op_CreateStreamingSession.go | 37 +++++++++ .../api_op_CreateStreamingSessionStream.go | 37 +++++++++ service/nimble/api_op_CreateStudio.go | 37 +++++++++ .../nimble/api_op_CreateStudioComponent.go | 37 +++++++++ service/nimble/api_op_DeleteLaunchProfile.go | 37 +++++++++ .../api_op_DeleteLaunchProfileMember.go | 37 +++++++++ service/nimble/api_op_DeleteStreamingImage.go | 37 +++++++++ .../nimble/api_op_DeleteStreamingSession.go | 37 +++++++++ service/nimble/api_op_DeleteStudio.go | 37 +++++++++ .../nimble/api_op_DeleteStudioComponent.go | 37 +++++++++ service/nimble/api_op_DeleteStudioMember.go | 37 +++++++++ .../nimble/api_op_PutLaunchProfileMembers.go | 37 +++++++++ service/nimble/api_op_PutStudioMembers.go | 37 +++++++++ .../nimble/api_op_StartStreamingSession.go | 37 +++++++++ ...pi_op_StartStudioSSOConfigurationRepair.go | 37 +++++++++ service/nimble/api_op_StopStreamingSession.go | 37 +++++++++ service/nimble/api_op_UpdateLaunchProfile.go | 37 +++++++++ .../api_op_UpdateLaunchProfileMember.go | 37 +++++++++ service/nimble/api_op_UpdateStreamingImage.go | 37 +++++++++ service/nimble/api_op_UpdateStudio.go | 37 +++++++++ .../nimble/api_op_UpdateStudioComponent.go | 37 +++++++++ service/proton/api_client.go | 20 +++++ ...i_op_CreateEnvironmentAccountConnection.go | 37 +++++++++ ...api_op_CreateEnvironmentTemplateVersion.go | 37 +++++++++ .../api_op_CreateServiceTemplateVersion.go | 37 +++++++++ service/snowdevicemanagement/api_client.go | 20 +++++ .../snowdevicemanagement/api_op_CreateTask.go | 37 +++++++++ service/wisdom/api_client.go | 20 +++++ service/wisdom/api_op_CreateAssistant.go | 37 +++++++++ .../api_op_CreateAssistantAssociation.go | 37 +++++++++ service/wisdom/api_op_CreateContent.go | 37 +++++++++ service/wisdom/api_op_CreateKnowledgeBase.go | 37 +++++++++ service/wisdom/api_op_CreateSession.go | 37 +++++++++ 143 files changed, 4513 insertions(+), 61 deletions(-) create mode 100644 .changelog/b51f6004654f4c5eb4799d04a5045020.json create mode 100644 .changelog/b55ca4d66d1d4102baf0cb7c49f3bde3.json create mode 100644 .changelog/ce7b78be34014ab39c6d0f40cd08bd56.json create mode 100644 codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/LocationModelFixes.java diff --git a/.changelog/b51f6004654f4c5eb4799d04a5045020.json b/.changelog/b51f6004654f4c5eb4799d04a5045020.json new file mode 100644 index 00000000000..5192c873731 --- /dev/null +++ b/.changelog/b51f6004654f4c5eb4799d04a5045020.json @@ -0,0 +1,17 @@ +{ + "id": "b51f6004-654f-4c5e-b479-9d04a5045020", + "type": "bugfix", + "description": "Fixed an issue that prevent auto-filling of an API's idempotency parameters when not explictly provided by the caller.", + "modules": [ + "service/accessanalyzer", + "service/amp", + "service/appmesh", + "service/braket", + "service/codeguruprofiler", + "service/grafana", + "service/nimble", + "service/proton", + "service/snowdevicemanagement", + "service/wisdom" + ] +} \ No newline at end of file diff --git a/.changelog/b55ca4d66d1d4102baf0cb7c49f3bde3.json b/.changelog/b55ca4d66d1d4102baf0cb7c49f3bde3.json new file mode 100644 index 00000000000..435c92cad99 --- /dev/null +++ b/.changelog/b55ca4d66d1d4102baf0cb7c49f3bde3.json @@ -0,0 +1,9 @@ +{ + "id": "b55ca4d6-6d1d-4102-baf0-cb7c49f3bde3", + "type": "bugfix", + "description": "Fixed a bug that prevented the resolution of the correct endpoint for some API operations.", + "modules": [ + "service/evidently", + "service/location" + ] +} \ No newline at end of file diff --git a/.changelog/ce7b78be34014ab39c6d0f40cd08bd56.json b/.changelog/ce7b78be34014ab39c6d0f40cd08bd56.json new file mode 100644 index 00000000000..ba1b1560355 --- /dev/null +++ b/.changelog/ce7b78be34014ab39c6d0f40cd08bd56.json @@ -0,0 +1,8 @@ +{ + "id": "ce7b78be-3401-4ab3-9c6d-0f40cd08bd56", + "type": "bugfix", + "description": "Fixed an issue that caused some operations to not be signed using sigv4, resulting in authentication failures.", + "modules": [ + "service/location" + ] +} \ No newline at end of file diff --git a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsHttpPresignURLClientGenerator.java b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsHttpPresignURLClientGenerator.java index 2c526fe27a5..b45ff800a21 100644 --- a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsHttpPresignURLClientGenerator.java +++ b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/AwsHttpPresignURLClientGenerator.java @@ -36,6 +36,7 @@ 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; @@ -198,8 +199,7 @@ public void writeAdditionalFiles( writeConvertToPresignMiddleware(writer, model, symbolProvider, serviceShape); }); - for (ShapeId operationId : serviceShape.getAllOperations()) { - OperationShape operationShape = model.expectShape(operationId, OperationShape.class); + for (OperationShape operationShape : TopDownIndex.of(model).getContainedOperations(serviceShape)) { if (!validOperations.contains(operationShape.getId())) { continue; } @@ -229,11 +229,11 @@ private void writePresignOperationFunction( 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()) + + "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, + + "($P, error) {", "}", presignClientSymbol, operationSymbol, operationInputSymbol, presignOptionsSymbol, v4PresignedHTTPRequestSymbol, () -> { writer.write("if params == nil { params = &$T{} }", operationInputSymbol).insertTrailingNewline(); @@ -338,17 +338,17 @@ private void writeConvertToPresignMiddleware( smithyStack, () -> { Symbol smithyAfter = SymbolUtils.createValueSymbolBuilder("After", - SmithyGoDependency.SMITHY_MIDDLEWARE) + SmithyGoDependency.SMITHY_MIDDLEWARE) .build(); // Middleware to remove Symbol requestInvocationID = SymbolUtils.createPointableSymbolBuilder( - "ClientRequestID", - AwsGoDependency.AWS_MIDDLEWARE) + "ClientRequestID", + AwsGoDependency.AWS_MIDDLEWARE) .build(); Symbol presignMiddleware = SymbolUtils.createValueSymbolBuilder("NewPresignHTTPRequestMiddleware", - AwsGoDependency.AWS_SIGNER_V4) + AwsGoDependency.AWS_SIGNER_V4) .build(); // Middleware to add @@ -385,25 +385,25 @@ private void writeConvertToPresignMiddleware( writer.write("// add multi-region access point presigner"); // ==== multi-region access point support - Symbol PresignConstructor = SymbolUtils.createValueSymbolBuilder( - "NewPresignHTTPRequestMiddleware", AwsCustomGoDependency.S3_CUSTOMIZATION - ).build(); + Symbol PresignConstructor = SymbolUtils.createValueSymbolBuilder( + "NewPresignHTTPRequestMiddleware", AwsCustomGoDependency.S3_CUSTOMIZATION + ).build(); - Symbol PresignOptions = SymbolUtils.createValueSymbolBuilder( - "PresignHTTPRequestMiddlewareOptions", AwsCustomGoDependency.S3_CUSTOMIZATION - ).build(); + Symbol PresignOptions = SymbolUtils.createValueSymbolBuilder( + "PresignHTTPRequestMiddlewareOptions", AwsCustomGoDependency.S3_CUSTOMIZATION + ).build(); - Symbol RegisterPresigningMiddleware = SymbolUtils.createValueSymbolBuilder( - "RegisterPreSigningMiddleware", 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(),"); - }); + 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 }"); @@ -420,7 +420,7 @@ private void writeConvertToPresignMiddleware( "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"); + + " 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 }"); @@ -506,7 +506,7 @@ private void writePresignClientHelpers( // 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) + SmithyGoDependency.SMITHY_HTTP_TRANSPORT) .build(); writer.write("o.HTTPClient = $T{}", nopClientSymbol); @@ -604,8 +604,8 @@ public void writePresignOptionType( 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." + + "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"); @@ -632,7 +632,7 @@ public void writePresignOptionType( 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(); @@ -640,7 +640,7 @@ public void writePresignOptionType( writer.openBlock("func (w $L) options (o $P) {", "}", presignOptionsFromClientOptionsInternal.getName(), presignOptionsSymbol, () -> { writer.write("o.ClientOptions = append(o.ClientOptions, w...)"); - }).insertTrailingNewline(); + }).insertTrailingNewline(); // s3 specific helpers @@ -653,7 +653,7 @@ public void writePresignOptionType( writer.openBlock("func $L(dur time.Duration) func($P) {", "}", PRESIGN_OPTIONS_FROM_EXPIRES, presignOptionsSymbol, () -> { writer.write("return $L(dur).options", presignOptionsFromExpiresInternal.getName()); - }); + }); writer.insertTrailingNewline(); @@ -661,7 +661,7 @@ public void writePresignOptionType( writer.openBlock("func (w $L) options (o $P) {", "}", presignOptionsFromExpiresInternal.getName(), presignOptionsSymbol, () -> { writer.write("o.Expires = time.Duration(w)"); - }).insertTrailingNewline(); + }).insertTrailingNewline(); } } diff --git a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/EndpointDiscoveryGenerator.java b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/EndpointDiscoveryGenerator.java index 7c523d88708..628ed13736b 100644 --- a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/EndpointDiscoveryGenerator.java +++ b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/EndpointDiscoveryGenerator.java @@ -24,6 +24,7 @@ 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; @@ -494,8 +495,7 @@ public void processFinalizedModel(GoSettings settings, Model model) { .build()); - for (ShapeId operationId : service.getAllOperations()) { - OperationShape operation = model.expectShape(operationId, OperationShape.class); + for (OperationShape operation : TopDownIndex.of(model).getContainedOperations(service)) { String helperFuncName = generateAddDiscoverEndpointMiddlewareName(service, operation); Collection middlewareArgs = ListUtils.of( @@ -556,8 +556,7 @@ public void writeAdditionalFiles( }); // generate code specific to the operation - for (ShapeId id : service.getOperations()) { - OperationShape operation = model.expectShape(id, OperationShape.class); + for (OperationShape operation : TopDownIndex.of(model).getContainedOperations(service)) { goDelegator.useShapeWriter(operation, writer -> { generateAddDiscoverEndpointMiddleware(model, symbolProvider, writer, service, operation); generateFetchDiscoveredEndpointFunction(model, symbolProvider, writer, service, operation); diff --git a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/GlacierCustomizations.java b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/GlacierCustomizations.java index e202660e4c3..1a9b5990af1 100644 --- a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/GlacierCustomizations.java +++ b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/GlacierCustomizations.java @@ -13,6 +13,7 @@ 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; @@ -87,13 +88,12 @@ private void writeAccountIdSetter( 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 (ShapeId operationId : service.getAllOperations()) { - OperationShape operation = model.expectShape(operationId, OperationShape.class); + for (OperationShape operation : TopDownIndex.of(model).getContainedOperations(service)) { StructureShape input = ProtocolUtils.expectInput(model, operation); List accountId = input.getAllMembers().values().stream() .filter(m -> m.getMemberName().toLowerCase().equals("accountid")) - .collect(Collectors.toList()); + .toList(); if (accountId.isEmpty()) { continue; diff --git a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/LocationModelFixes.java b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/LocationModelFixes.java new file mode 100644 index 00000000000..b5af435956d --- /dev/null +++ b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/LocationModelFixes.java @@ -0,0 +1,81 @@ +/* + * 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 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(); + } +} diff --git a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/MachineLearningCustomizations.java b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/MachineLearningCustomizations.java index 4bf174fc3eb..774d26c139a 100644 --- a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/MachineLearningCustomizations.java +++ b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/MachineLearningCustomizations.java @@ -13,6 +13,7 @@ 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; @@ -57,11 +58,9 @@ public void writeAdditionalFiles( return; } - service.getAllOperations().stream() - .filter(shapeId -> shapeId.getName(service).equalsIgnoreCase("Predict")) + TopDownIndex.of(model).getContainedOperations(service).stream() + .filter(shape -> shape.getId().getName(service).equalsIgnoreCase("Predict")) .findAny() - .map(model::expectShape) - .flatMap(Shape::asOperationShape) .ifPresent(operation -> { goDelegator.useShapeWriter(operation, writer -> writeEndpointAccessor( writer, model, symbolProvider, operation)); diff --git a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/Route53Customizations.java b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/Route53Customizations.java index aa90940645b..0f739cdf484 100644 --- a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/Route53Customizations.java +++ b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/Route53Customizations.java @@ -14,6 +14,7 @@ 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; @@ -97,8 +98,7 @@ private void writeHostedZoneIDInputSanitizer( writer.openBlock("func sanitizeHostedZoneIDInput(input interface{}) error {", "}", () -> { writer.openBlock("switch i:= input.(type) {", "}", () -> { - service.getAllOperations().forEach((operationId)-> { - OperationShape operation = model.expectShape(operationId, OperationShape.class); + TopDownIndex.of(model).getContainedOperations(service).forEach((operation)-> { StructureShape input = model.expectShape(operation.getInput().get(), StructureShape.class); List hostedZoneIDMembers = input.getAllMembers().values().stream() .filter(m -> m.getTarget().getName(service).equalsIgnoreCase("ResourceId") diff --git a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3GetBucketLocation.java b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3GetBucketLocation.java index 28cdb394ecd..8035cbfc797 100644 --- a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3GetBucketLocation.java +++ b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3GetBucketLocation.java @@ -17,6 +17,7 @@ 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; @@ -85,12 +86,11 @@ public void writeAdditionalFiles( return; } - for (ShapeId operationId : service.getAllOperations()) { - if (!(operationId.getName(service).equals(getBucketLocationOpID))) { + for (OperationShape operation : TopDownIndex.of(model).getContainedOperations(service)) { + if (!(operation.getId().getName(service).equals(getBucketLocationOpID))) { continue; } - OperationShape operation = model.expectShape(operationId, OperationShape.class); goDelegator.useShapeWriter(operation, writer -> { writeCustomDeserializer(writer, model, symbolProvider, service, operation); writeDeserializerSwapFunction(writer, service, operation); diff --git a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3HeadObjectCustomizations.java b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3HeadObjectCustomizations.java index 1abdb26c115..15959b10ba9 100644 --- a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3HeadObjectCustomizations.java +++ b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3HeadObjectCustomizations.java @@ -3,6 +3,7 @@ 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.knowledge.TopDownIndex; import software.amazon.smithy.model.shapes.OperationShape; import software.amazon.smithy.model.shapes.ServiceShape; import software.amazon.smithy.model.shapes.ShapeId; @@ -10,7 +11,6 @@ /** * This integration removes incorrectly modeled S3 `NoSuchKey` error for HeadObject operation. * Related to aws/aws-sdk-go#1208 - * */ public class S3HeadObjectCustomizations implements GoIntegration { @Override @@ -27,16 +27,15 @@ public Model preprocessModel( return model; } - for (ShapeId operationId :service.getAllOperations()) { - if (operationId.getName(service).equalsIgnoreCase("HeadObject")) { + for (OperationShape operationShape: TopDownIndex.of(model).getContainedOperations(service)) { + if (operationShape.getId().getName(service).equalsIgnoreCase("HeadObject")) { Model.Builder modelBuilder = model.toBuilder(); - OperationShape operationShape = model.expectShape(operationId, OperationShape.class); - OperationShape.Builder builder = operationShape.toBuilder(); + OperationShape.Builder builder = operationShape.toBuilder(); // clear all errors associated with 'HeadObject' operation aws/aws-sdk-go#1208 builder.clearErrors(); // remove old operation shape and add the updated shape to model - return modelBuilder.removeShape(operationId).addShape(builder.build()).build(); + return modelBuilder.removeShape(operationShape.getId()).addShape(builder.build()).build(); } } return model; diff --git a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3PaginationExtensions.java b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3PaginationExtensions.java index 0b6109f6f15..c8be77cfef5 100644 --- a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3PaginationExtensions.java +++ b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3PaginationExtensions.java @@ -24,6 +24,7 @@ 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; @@ -51,7 +52,7 @@ private Model addMoreResultsKey(Model model, ServiceShape service) { PaginatedIndex paginatedIndex = PaginatedIndex.of(model); Model.Builder builder = model.toBuilder(); - for (ShapeId operation : service.getOperations()) { + for (OperationShape operation : TopDownIndex.of(model).getContainedOperations(service)) { Optional optionalPaginationInfo = paginatedIndex.getPaginationInfo(service, operation); if (!optionalPaginationInfo.isPresent()) { continue; diff --git a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3UpdateEndpoint.java b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3UpdateEndpoint.java index 720a375b9cf..53bfd69369b 100644 --- a/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3UpdateEndpoint.java +++ b/codegen/smithy-aws-go-codegen/src/main/java/software/amazon/smithy/aws/go/codegen/customization/S3UpdateEndpoint.java @@ -36,6 +36,7 @@ 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; @@ -126,9 +127,7 @@ public void writeAdditionalFiles( @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); - + 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( @@ -275,8 +274,7 @@ private void writeAdditionalFiles( GoDelegator goDelegator ) { - for (ShapeId operationID : service.getAllOperations()) { - OperationShape operation = model.expectShape(operationID, OperationShape.class); + for (OperationShape operation : TopDownIndex.of(model).getContainedOperations(service)) { goDelegator.useShapeWriter(operation, writer -> { // generate get bucket member helper function writeGetBucketMemberHelper(writer, model, symbolProvider, operation); @@ -452,8 +450,7 @@ void writeAdditionalFiles( SymbolProvider symbolProvider, GoDelegator goDelegator ) { - for (ShapeId operationID : service.getAllOperations()) { - OperationShape operation = model.expectShape(operationID, OperationShape.class); + 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); diff --git a/codegen/smithy-aws-go-codegen/src/main/resources/META-INF/services/software.amazon.smithy.go.codegen.integration.GoIntegration b/codegen/smithy-aws-go-codegen/src/main/resources/META-INF/services/software.amazon.smithy.go.codegen.integration.GoIntegration index 273f76694a0..fe9286408a6 100644 --- a/codegen/smithy-aws-go-codegen/src/main/resources/META-INF/services/software.amazon.smithy.go.codegen.integration.GoIntegration +++ b/codegen/smithy-aws-go-codegen/src/main/resources/META-INF/services/software.amazon.smithy.go.codegen.integration.GoIntegration @@ -14,6 +14,7 @@ software.amazon.smithy.aws.go.codegen.AWSResponseErrorWrapper software.amazon.smithy.aws.go.codegen.FilterShapes software.amazon.smithy.aws.go.codegen.customization.ShapeBackwardsCompatabilityTransforms software.amazon.smithy.aws.go.codegen.customization.BackfillBoxTrait +software.amazon.smithy.aws.go.codegen.customization.LocationModelFixes software.amazon.smithy.aws.go.codegen.customization.DynamoDBValidateResponseChecksum software.amazon.smithy.aws.go.codegen.customization.S3UpdateEndpoint software.amazon.smithy.aws.go.codegen.customization.APIGatewayAcceptHeader diff --git a/service/accessanalyzer/api_op_CreateAnalyzer.go b/service/accessanalyzer/api_op_CreateAnalyzer.go index d8a9ac5b6e0..229c2282e6a 100644 --- a/service/accessanalyzer/api_op_CreateAnalyzer.go +++ b/service/accessanalyzer/api_op_CreateAnalyzer.go @@ -4,6 +4,7 @@ package accessanalyzer import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/accessanalyzer/types" @@ -112,6 +113,9 @@ func (c *Client) addOperationCreateAnalyzerMiddlewares(stack *middleware.Stack, if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateAnalyzerMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateAnalyzerValidationMiddleware(stack); err != nil { return err } @@ -130,6 +134,39 @@ func (c *Client) addOperationCreateAnalyzerMiddlewares(stack *middleware.Stack, return nil } +type idempotencyToken_initializeOpCreateAnalyzer struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateAnalyzer) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateAnalyzer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateAnalyzerInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateAnalyzerInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateAnalyzerMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateAnalyzer{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateAnalyzer(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/accessanalyzer/api_op_CreateArchiveRule.go b/service/accessanalyzer/api_op_CreateArchiveRule.go index 311ed46cc13..74c1948df02 100644 --- a/service/accessanalyzer/api_op_CreateArchiveRule.go +++ b/service/accessanalyzer/api_op_CreateArchiveRule.go @@ -4,6 +4,7 @@ package accessanalyzer import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/accessanalyzer/types" @@ -108,6 +109,9 @@ func (c *Client) addOperationCreateArchiveRuleMiddlewares(stack *middleware.Stac if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateArchiveRuleMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateArchiveRuleValidationMiddleware(stack); err != nil { return err } @@ -126,6 +130,39 @@ func (c *Client) addOperationCreateArchiveRuleMiddlewares(stack *middleware.Stac return nil } +type idempotencyToken_initializeOpCreateArchiveRule struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateArchiveRule) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateArchiveRule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateArchiveRuleInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateArchiveRuleInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateArchiveRuleMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateArchiveRule{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateArchiveRule(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/accessanalyzer/api_op_DeleteAnalyzer.go b/service/accessanalyzer/api_op_DeleteAnalyzer.go index 8268e20aba6..825b65598f6 100644 --- a/service/accessanalyzer/api_op_DeleteAnalyzer.go +++ b/service/accessanalyzer/api_op_DeleteAnalyzer.go @@ -4,6 +4,7 @@ package accessanalyzer import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -95,6 +96,9 @@ func (c *Client) addOperationDeleteAnalyzerMiddlewares(stack *middleware.Stack, if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opDeleteAnalyzerMiddleware(stack, options); err != nil { + return err + } if err = addOpDeleteAnalyzerValidationMiddleware(stack); err != nil { return err } @@ -113,6 +117,39 @@ func (c *Client) addOperationDeleteAnalyzerMiddlewares(stack *middleware.Stack, return nil } +type idempotencyToken_initializeOpDeleteAnalyzer struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpDeleteAnalyzer) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpDeleteAnalyzer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*DeleteAnalyzerInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *DeleteAnalyzerInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opDeleteAnalyzerMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpDeleteAnalyzer{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opDeleteAnalyzer(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/accessanalyzer/api_op_DeleteArchiveRule.go b/service/accessanalyzer/api_op_DeleteArchiveRule.go index ba9e0673ecd..14c8882003e 100644 --- a/service/accessanalyzer/api_op_DeleteArchiveRule.go +++ b/service/accessanalyzer/api_op_DeleteArchiveRule.go @@ -4,6 +4,7 @@ package accessanalyzer import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -97,6 +98,9 @@ func (c *Client) addOperationDeleteArchiveRuleMiddlewares(stack *middleware.Stac if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opDeleteArchiveRuleMiddleware(stack, options); err != nil { + return err + } if err = addOpDeleteArchiveRuleValidationMiddleware(stack); err != nil { return err } @@ -115,6 +119,39 @@ func (c *Client) addOperationDeleteArchiveRuleMiddlewares(stack *middleware.Stac return nil } +type idempotencyToken_initializeOpDeleteArchiveRule struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpDeleteArchiveRule) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpDeleteArchiveRule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*DeleteArchiveRuleInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *DeleteArchiveRuleInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opDeleteArchiveRuleMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpDeleteArchiveRule{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opDeleteArchiveRule(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/accessanalyzer/api_op_UpdateArchiveRule.go b/service/accessanalyzer/api_op_UpdateArchiveRule.go index d9bcf31e936..095a6d671ca 100644 --- a/service/accessanalyzer/api_op_UpdateArchiveRule.go +++ b/service/accessanalyzer/api_op_UpdateArchiveRule.go @@ -4,6 +4,7 @@ package accessanalyzer import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/accessanalyzer/types" @@ -104,6 +105,9 @@ func (c *Client) addOperationUpdateArchiveRuleMiddlewares(stack *middleware.Stac if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opUpdateArchiveRuleMiddleware(stack, options); err != nil { + return err + } if err = addOpUpdateArchiveRuleValidationMiddleware(stack); err != nil { return err } @@ -122,6 +126,39 @@ func (c *Client) addOperationUpdateArchiveRuleMiddlewares(stack *middleware.Stac return nil } +type idempotencyToken_initializeOpUpdateArchiveRule struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpUpdateArchiveRule) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpUpdateArchiveRule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*UpdateArchiveRuleInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *UpdateArchiveRuleInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opUpdateArchiveRuleMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpUpdateArchiveRule{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opUpdateArchiveRule(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/amp/api_client.go b/service/amp/api_client.go index ba3c1580727..570186959c0 100644 --- a/service/amp/api_client.go +++ b/service/amp/api_client.go @@ -4,6 +4,7 @@ package amp import ( "context" + cryptorand "crypto/rand" "github.com/aws/aws-sdk-go-v2/aws" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" @@ -14,6 +15,7 @@ import ( smithydocument "github.com/aws/smithy-go/document" "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" + smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" "net/http" "time" @@ -44,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveDefaultEndpointConfiguration(&options) + resolveIdempotencyTokenProvider(&options) + for _, fn := range optFns { fn(&options) } @@ -76,6 +80,10 @@ type Options struct { // Signature Version 4 (SigV4) Signer HTTPSignerV4 HTTPSignerV4 + // Provides idempotency tokens values that will be automatically populated into + // idempotent API operations. + IdempotencyTokenProvider IdempotencyTokenProvider + // The logger writer interface to write logging messages to. Logger logging.Logger @@ -241,6 +249,13 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func resolveIdempotencyTokenProvider(o *Options) { + if o.IdempotencyTokenProvider != nil { + return + } + o.IdempotencyTokenProvider = smithyrand.NewUUIDIdempotencyToken(cryptorand.Reader) +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, @@ -279,6 +294,11 @@ func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error { return nil } +// IdempotencyTokenProvider interface for providing idempotency token +type IdempotencyTokenProvider interface { + GetIdempotencyToken() (string, error) +} + func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error { return awsmiddleware.AddRequestIDRetrieverMiddleware(stack) } diff --git a/service/amp/api_op_CreateAlertManagerDefinition.go b/service/amp/api_op_CreateAlertManagerDefinition.go index 3c80041fa99..5663d413a8c 100644 --- a/service/amp/api_op_CreateAlertManagerDefinition.go +++ b/service/amp/api_op_CreateAlertManagerDefinition.go @@ -4,6 +4,7 @@ package amp import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/amp/types" @@ -106,6 +107,9 @@ func (c *Client) addOperationCreateAlertManagerDefinitionMiddlewares(stack *midd if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateAlertManagerDefinitionMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateAlertManagerDefinitionValidationMiddleware(stack); err != nil { return err } @@ -124,6 +128,39 @@ func (c *Client) addOperationCreateAlertManagerDefinitionMiddlewares(stack *midd return nil } +type idempotencyToken_initializeOpCreateAlertManagerDefinition struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateAlertManagerDefinition) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateAlertManagerDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateAlertManagerDefinitionInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateAlertManagerDefinitionInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateAlertManagerDefinitionMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateAlertManagerDefinition{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateAlertManagerDefinition(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/amp/api_op_CreateRuleGroupsNamespace.go b/service/amp/api_op_CreateRuleGroupsNamespace.go index d03ebb21771..516812c6f5e 100644 --- a/service/amp/api_op_CreateRuleGroupsNamespace.go +++ b/service/amp/api_op_CreateRuleGroupsNamespace.go @@ -4,6 +4,7 @@ package amp import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/amp/types" @@ -127,6 +128,9 @@ func (c *Client) addOperationCreateRuleGroupsNamespaceMiddlewares(stack *middlew if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateRuleGroupsNamespaceMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateRuleGroupsNamespaceValidationMiddleware(stack); err != nil { return err } @@ -145,6 +149,39 @@ func (c *Client) addOperationCreateRuleGroupsNamespaceMiddlewares(stack *middlew return nil } +type idempotencyToken_initializeOpCreateRuleGroupsNamespace struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateRuleGroupsNamespace) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateRuleGroupsNamespace) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateRuleGroupsNamespaceInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateRuleGroupsNamespaceInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateRuleGroupsNamespaceMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateRuleGroupsNamespace{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateRuleGroupsNamespace(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/amp/api_op_CreateWorkspace.go b/service/amp/api_op_CreateWorkspace.go index 222e676d5b0..533ef66ecb4 100644 --- a/service/amp/api_op_CreateWorkspace.go +++ b/service/amp/api_op_CreateWorkspace.go @@ -4,6 +4,7 @@ package amp import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/amp/types" @@ -116,6 +117,9 @@ func (c *Client) addOperationCreateWorkspaceMiddlewares(stack *middleware.Stack, if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateWorkspaceMiddleware(stack, options); err != nil { + return err + } if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateWorkspace(options.Region), middleware.Before); err != nil { return err } @@ -131,6 +135,39 @@ func (c *Client) addOperationCreateWorkspaceMiddlewares(stack *middleware.Stack, return nil } +type idempotencyToken_initializeOpCreateWorkspace struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateWorkspace) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateWorkspace) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateWorkspaceInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateWorkspaceInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateWorkspaceMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateWorkspace{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateWorkspace(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/amp/api_op_DeleteAlertManagerDefinition.go b/service/amp/api_op_DeleteAlertManagerDefinition.go index 4581506be11..937b7eb8905 100644 --- a/service/amp/api_op_DeleteAlertManagerDefinition.go +++ b/service/amp/api_op_DeleteAlertManagerDefinition.go @@ -4,6 +4,7 @@ package amp import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -93,6 +94,9 @@ func (c *Client) addOperationDeleteAlertManagerDefinitionMiddlewares(stack *midd if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opDeleteAlertManagerDefinitionMiddleware(stack, options); err != nil { + return err + } if err = addOpDeleteAlertManagerDefinitionValidationMiddleware(stack); err != nil { return err } @@ -111,6 +115,39 @@ func (c *Client) addOperationDeleteAlertManagerDefinitionMiddlewares(stack *midd return nil } +type idempotencyToken_initializeOpDeleteAlertManagerDefinition struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpDeleteAlertManagerDefinition) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpDeleteAlertManagerDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*DeleteAlertManagerDefinitionInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *DeleteAlertManagerDefinitionInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opDeleteAlertManagerDefinitionMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpDeleteAlertManagerDefinition{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opDeleteAlertManagerDefinition(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/amp/api_op_DeleteRuleGroupsNamespace.go b/service/amp/api_op_DeleteRuleGroupsNamespace.go index 14510f7df4b..ebe8476ab9c 100644 --- a/service/amp/api_op_DeleteRuleGroupsNamespace.go +++ b/service/amp/api_op_DeleteRuleGroupsNamespace.go @@ -4,6 +4,7 @@ package amp import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -98,6 +99,9 @@ func (c *Client) addOperationDeleteRuleGroupsNamespaceMiddlewares(stack *middlew if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opDeleteRuleGroupsNamespaceMiddleware(stack, options); err != nil { + return err + } if err = addOpDeleteRuleGroupsNamespaceValidationMiddleware(stack); err != nil { return err } @@ -116,6 +120,39 @@ func (c *Client) addOperationDeleteRuleGroupsNamespaceMiddlewares(stack *middlew return nil } +type idempotencyToken_initializeOpDeleteRuleGroupsNamespace struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpDeleteRuleGroupsNamespace) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpDeleteRuleGroupsNamespace) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*DeleteRuleGroupsNamespaceInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *DeleteRuleGroupsNamespaceInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opDeleteRuleGroupsNamespaceMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpDeleteRuleGroupsNamespace{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opDeleteRuleGroupsNamespace(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/amp/api_op_DeleteWorkspace.go b/service/amp/api_op_DeleteWorkspace.go index 6df1fe105ca..5dc47c79e22 100644 --- a/service/amp/api_op_DeleteWorkspace.go +++ b/service/amp/api_op_DeleteWorkspace.go @@ -4,6 +4,7 @@ package amp import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -93,6 +94,9 @@ func (c *Client) addOperationDeleteWorkspaceMiddlewares(stack *middleware.Stack, if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opDeleteWorkspaceMiddleware(stack, options); err != nil { + return err + } if err = addOpDeleteWorkspaceValidationMiddleware(stack); err != nil { return err } @@ -111,6 +115,39 @@ func (c *Client) addOperationDeleteWorkspaceMiddlewares(stack *middleware.Stack, return nil } +type idempotencyToken_initializeOpDeleteWorkspace struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpDeleteWorkspace) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpDeleteWorkspace) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*DeleteWorkspaceInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *DeleteWorkspaceInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opDeleteWorkspaceMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpDeleteWorkspace{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opDeleteWorkspace(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/amp/api_op_PutAlertManagerDefinition.go b/service/amp/api_op_PutAlertManagerDefinition.go index fdc849c68e1..056db42cf9a 100644 --- a/service/amp/api_op_PutAlertManagerDefinition.go +++ b/service/amp/api_op_PutAlertManagerDefinition.go @@ -4,6 +4,7 @@ package amp import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/amp/types" @@ -106,6 +107,9 @@ func (c *Client) addOperationPutAlertManagerDefinitionMiddlewares(stack *middlew if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opPutAlertManagerDefinitionMiddleware(stack, options); err != nil { + return err + } if err = addOpPutAlertManagerDefinitionValidationMiddleware(stack); err != nil { return err } @@ -124,6 +128,39 @@ func (c *Client) addOperationPutAlertManagerDefinitionMiddlewares(stack *middlew return nil } +type idempotencyToken_initializeOpPutAlertManagerDefinition struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpPutAlertManagerDefinition) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpPutAlertManagerDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*PutAlertManagerDefinitionInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *PutAlertManagerDefinitionInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opPutAlertManagerDefinitionMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpPutAlertManagerDefinition{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opPutAlertManagerDefinition(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/amp/api_op_PutRuleGroupsNamespace.go b/service/amp/api_op_PutRuleGroupsNamespace.go index 9af4f8f57fa..534c8edd0e0 100644 --- a/service/amp/api_op_PutRuleGroupsNamespace.go +++ b/service/amp/api_op_PutRuleGroupsNamespace.go @@ -4,6 +4,7 @@ package amp import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/amp/types" @@ -124,6 +125,9 @@ func (c *Client) addOperationPutRuleGroupsNamespaceMiddlewares(stack *middleware if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opPutRuleGroupsNamespaceMiddleware(stack, options); err != nil { + return err + } if err = addOpPutRuleGroupsNamespaceValidationMiddleware(stack); err != nil { return err } @@ -142,6 +146,39 @@ func (c *Client) addOperationPutRuleGroupsNamespaceMiddlewares(stack *middleware return nil } +type idempotencyToken_initializeOpPutRuleGroupsNamespace struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpPutRuleGroupsNamespace) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpPutRuleGroupsNamespace) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*PutRuleGroupsNamespaceInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *PutRuleGroupsNamespaceInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opPutRuleGroupsNamespaceMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpPutRuleGroupsNamespace{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opPutRuleGroupsNamespace(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/amp/api_op_UpdateWorkspaceAlias.go b/service/amp/api_op_UpdateWorkspaceAlias.go index 73cc9826e9c..3342b44bc59 100644 --- a/service/amp/api_op_UpdateWorkspaceAlias.go +++ b/service/amp/api_op_UpdateWorkspaceAlias.go @@ -4,6 +4,7 @@ package amp import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -96,6 +97,9 @@ func (c *Client) addOperationUpdateWorkspaceAliasMiddlewares(stack *middleware.S if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opUpdateWorkspaceAliasMiddleware(stack, options); err != nil { + return err + } if err = addOpUpdateWorkspaceAliasValidationMiddleware(stack); err != nil { return err } @@ -114,6 +118,39 @@ func (c *Client) addOperationUpdateWorkspaceAliasMiddlewares(stack *middleware.S return nil } +type idempotencyToken_initializeOpUpdateWorkspaceAlias struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpUpdateWorkspaceAlias) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpUpdateWorkspaceAlias) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*UpdateWorkspaceAliasInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *UpdateWorkspaceAliasInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opUpdateWorkspaceAliasMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpUpdateWorkspaceAlias{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opUpdateWorkspaceAlias(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/appmesh/api_client.go b/service/appmesh/api_client.go index ac44a1c7bc4..0a27789e847 100644 --- a/service/appmesh/api_client.go +++ b/service/appmesh/api_client.go @@ -4,6 +4,7 @@ package appmesh import ( "context" + cryptorand "crypto/rand" "github.com/aws/aws-sdk-go-v2/aws" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" @@ -14,6 +15,7 @@ import ( smithydocument "github.com/aws/smithy-go/document" "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" + smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" "net/http" "time" @@ -43,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveDefaultEndpointConfiguration(&options) + resolveIdempotencyTokenProvider(&options) + for _, fn := range optFns { fn(&options) } @@ -75,6 +79,10 @@ type Options struct { // Signature Version 4 (SigV4) Signer HTTPSignerV4 HTTPSignerV4 + // Provides idempotency tokens values that will be automatically populated into + // idempotent API operations. + IdempotencyTokenProvider IdempotencyTokenProvider + // The logger writer interface to write logging messages to. Logger logging.Logger @@ -240,6 +248,13 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func resolveIdempotencyTokenProvider(o *Options) { + if o.IdempotencyTokenProvider != nil { + return + } + o.IdempotencyTokenProvider = smithyrand.NewUUIDIdempotencyToken(cryptorand.Reader) +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, @@ -278,6 +293,11 @@ func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error { return nil } +// IdempotencyTokenProvider interface for providing idempotency token +type IdempotencyTokenProvider interface { + GetIdempotencyToken() (string, error) +} + func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error { return awsmiddleware.AddRequestIDRetrieverMiddleware(stack) } diff --git a/service/appmesh/api_op_CreateGatewayRoute.go b/service/appmesh/api_op_CreateGatewayRoute.go index e3426f3644f..653a67d0ab1 100644 --- a/service/appmesh/api_op_CreateGatewayRoute.go +++ b/service/appmesh/api_op_CreateGatewayRoute.go @@ -4,6 +4,7 @@ package appmesh import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/appmesh/types" @@ -133,6 +134,9 @@ func (c *Client) addOperationCreateGatewayRouteMiddlewares(stack *middleware.Sta if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateGatewayRouteMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateGatewayRouteValidationMiddleware(stack); err != nil { return err } @@ -151,6 +155,39 @@ func (c *Client) addOperationCreateGatewayRouteMiddlewares(stack *middleware.Sta return nil } +type idempotencyToken_initializeOpCreateGatewayRoute struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateGatewayRoute) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateGatewayRoute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateGatewayRouteInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateGatewayRouteInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateGatewayRouteMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateGatewayRoute{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateGatewayRoute(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/appmesh/api_op_CreateMesh.go b/service/appmesh/api_op_CreateMesh.go index 664b91dbe79..e870cbc8250 100644 --- a/service/appmesh/api_op_CreateMesh.go +++ b/service/appmesh/api_op_CreateMesh.go @@ -4,6 +4,7 @@ package appmesh import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/appmesh/types" @@ -115,6 +116,9 @@ func (c *Client) addOperationCreateMeshMiddlewares(stack *middleware.Stack, opti if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateMeshMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateMeshValidationMiddleware(stack); err != nil { return err } @@ -133,6 +137,39 @@ func (c *Client) addOperationCreateMeshMiddlewares(stack *middleware.Stack, opti return nil } +type idempotencyToken_initializeOpCreateMesh struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateMesh) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateMesh) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateMeshInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateMeshInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateMeshMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateMesh{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateMesh(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/appmesh/api_op_CreateRoute.go b/service/appmesh/api_op_CreateRoute.go index ba65a5ca3c4..3e8cd389284 100644 --- a/service/appmesh/api_op_CreateRoute.go +++ b/service/appmesh/api_op_CreateRoute.go @@ -4,6 +4,7 @@ package appmesh import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/appmesh/types" @@ -134,6 +135,9 @@ func (c *Client) addOperationCreateRouteMiddlewares(stack *middleware.Stack, opt if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateRouteMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateRouteValidationMiddleware(stack); err != nil { return err } @@ -152,6 +156,39 @@ func (c *Client) addOperationCreateRouteMiddlewares(stack *middleware.Stack, opt return nil } +type idempotencyToken_initializeOpCreateRoute struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateRoute) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateRoute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateRouteInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateRouteInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateRouteMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateRoute{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateRoute(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/appmesh/api_op_CreateVirtualGateway.go b/service/appmesh/api_op_CreateVirtualGateway.go index 073f15e5935..63718f4223b 100644 --- a/service/appmesh/api_op_CreateVirtualGateway.go +++ b/service/appmesh/api_op_CreateVirtualGateway.go @@ -4,6 +4,7 @@ package appmesh import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/appmesh/types" @@ -129,6 +130,9 @@ func (c *Client) addOperationCreateVirtualGatewayMiddlewares(stack *middleware.S if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateVirtualGatewayMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateVirtualGatewayValidationMiddleware(stack); err != nil { return err } @@ -147,6 +151,39 @@ func (c *Client) addOperationCreateVirtualGatewayMiddlewares(stack *middleware.S return nil } +type idempotencyToken_initializeOpCreateVirtualGateway struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateVirtualGateway) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateVirtualGateway) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateVirtualGatewayInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateVirtualGatewayInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateVirtualGatewayMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateVirtualGateway{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateVirtualGateway(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/appmesh/api_op_CreateVirtualNode.go b/service/appmesh/api_op_CreateVirtualNode.go index a21f963ad93..dcc2bd6caf6 100644 --- a/service/appmesh/api_op_CreateVirtualNode.go +++ b/service/appmesh/api_op_CreateVirtualNode.go @@ -4,6 +4,7 @@ package appmesh import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/appmesh/types" @@ -146,6 +147,9 @@ func (c *Client) addOperationCreateVirtualNodeMiddlewares(stack *middleware.Stac if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateVirtualNodeMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateVirtualNodeValidationMiddleware(stack); err != nil { return err } @@ -164,6 +168,39 @@ func (c *Client) addOperationCreateVirtualNodeMiddlewares(stack *middleware.Stac return nil } +type idempotencyToken_initializeOpCreateVirtualNode struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateVirtualNode) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateVirtualNode) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateVirtualNodeInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateVirtualNodeInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateVirtualNodeMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateVirtualNode{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateVirtualNode(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/appmesh/api_op_CreateVirtualRouter.go b/service/appmesh/api_op_CreateVirtualRouter.go index fabe3f4f8e6..b7a1e196687 100644 --- a/service/appmesh/api_op_CreateVirtualRouter.go +++ b/service/appmesh/api_op_CreateVirtualRouter.go @@ -4,6 +4,7 @@ package appmesh import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/appmesh/types" @@ -131,6 +132,9 @@ func (c *Client) addOperationCreateVirtualRouterMiddlewares(stack *middleware.St if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateVirtualRouterMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateVirtualRouterValidationMiddleware(stack); err != nil { return err } @@ -149,6 +153,39 @@ func (c *Client) addOperationCreateVirtualRouterMiddlewares(stack *middleware.St return nil } +type idempotencyToken_initializeOpCreateVirtualRouter struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateVirtualRouter) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateVirtualRouter) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateVirtualRouterInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateVirtualRouterInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateVirtualRouterMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateVirtualRouter{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateVirtualRouter(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/appmesh/api_op_CreateVirtualService.go b/service/appmesh/api_op_CreateVirtualService.go index 8a7612319b5..a55d9c64ac4 100644 --- a/service/appmesh/api_op_CreateVirtualService.go +++ b/service/appmesh/api_op_CreateVirtualService.go @@ -4,6 +4,7 @@ package appmesh import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/appmesh/types" @@ -130,6 +131,9 @@ func (c *Client) addOperationCreateVirtualServiceMiddlewares(stack *middleware.S if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateVirtualServiceMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateVirtualServiceValidationMiddleware(stack); err != nil { return err } @@ -148,6 +152,39 @@ func (c *Client) addOperationCreateVirtualServiceMiddlewares(stack *middleware.S return nil } +type idempotencyToken_initializeOpCreateVirtualService struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateVirtualService) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateVirtualService) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateVirtualServiceInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateVirtualServiceInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateVirtualServiceMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateVirtualService{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateVirtualService(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/appmesh/api_op_UpdateGatewayRoute.go b/service/appmesh/api_op_UpdateGatewayRoute.go index 45478c27f42..6abb9316e37 100644 --- a/service/appmesh/api_op_UpdateGatewayRoute.go +++ b/service/appmesh/api_op_UpdateGatewayRoute.go @@ -4,6 +4,7 @@ package appmesh import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/appmesh/types" @@ -121,6 +122,9 @@ func (c *Client) addOperationUpdateGatewayRouteMiddlewares(stack *middleware.Sta if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opUpdateGatewayRouteMiddleware(stack, options); err != nil { + return err + } if err = addOpUpdateGatewayRouteValidationMiddleware(stack); err != nil { return err } @@ -139,6 +143,39 @@ func (c *Client) addOperationUpdateGatewayRouteMiddlewares(stack *middleware.Sta return nil } +type idempotencyToken_initializeOpUpdateGatewayRoute struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpUpdateGatewayRoute) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpUpdateGatewayRoute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*UpdateGatewayRouteInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *UpdateGatewayRouteInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opUpdateGatewayRouteMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpUpdateGatewayRoute{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opUpdateGatewayRoute(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/appmesh/api_op_UpdateMesh.go b/service/appmesh/api_op_UpdateMesh.go index 86a91ebd811..20c9d728787 100644 --- a/service/appmesh/api_op_UpdateMesh.go +++ b/service/appmesh/api_op_UpdateMesh.go @@ -4,6 +4,7 @@ package appmesh import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/appmesh/types" @@ -104,6 +105,9 @@ func (c *Client) addOperationUpdateMeshMiddlewares(stack *middleware.Stack, opti if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opUpdateMeshMiddleware(stack, options); err != nil { + return err + } if err = addOpUpdateMeshValidationMiddleware(stack); err != nil { return err } @@ -122,6 +126,39 @@ func (c *Client) addOperationUpdateMeshMiddlewares(stack *middleware.Stack, opti return nil } +type idempotencyToken_initializeOpUpdateMesh struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpUpdateMesh) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpUpdateMesh) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*UpdateMeshInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *UpdateMeshInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opUpdateMeshMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpUpdateMesh{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opUpdateMesh(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/appmesh/api_op_UpdateRoute.go b/service/appmesh/api_op_UpdateRoute.go index dbda5bd3290..d823938f480 100644 --- a/service/appmesh/api_op_UpdateRoute.go +++ b/service/appmesh/api_op_UpdateRoute.go @@ -4,6 +4,7 @@ package appmesh import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/appmesh/types" @@ -122,6 +123,9 @@ func (c *Client) addOperationUpdateRouteMiddlewares(stack *middleware.Stack, opt if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opUpdateRouteMiddleware(stack, options); err != nil { + return err + } if err = addOpUpdateRouteValidationMiddleware(stack); err != nil { return err } @@ -140,6 +144,39 @@ func (c *Client) addOperationUpdateRouteMiddlewares(stack *middleware.Stack, opt return nil } +type idempotencyToken_initializeOpUpdateRoute struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpUpdateRoute) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpUpdateRoute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*UpdateRouteInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *UpdateRouteInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opUpdateRouteMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpUpdateRoute{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opUpdateRoute(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/appmesh/api_op_UpdateVirtualGateway.go b/service/appmesh/api_op_UpdateVirtualGateway.go index 799a1890877..ada4f8d7bc0 100644 --- a/service/appmesh/api_op_UpdateVirtualGateway.go +++ b/service/appmesh/api_op_UpdateVirtualGateway.go @@ -4,6 +4,7 @@ package appmesh import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/appmesh/types" @@ -116,6 +117,9 @@ func (c *Client) addOperationUpdateVirtualGatewayMiddlewares(stack *middleware.S if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opUpdateVirtualGatewayMiddleware(stack, options); err != nil { + return err + } if err = addOpUpdateVirtualGatewayValidationMiddleware(stack); err != nil { return err } @@ -134,6 +138,39 @@ func (c *Client) addOperationUpdateVirtualGatewayMiddlewares(stack *middleware.S return nil } +type idempotencyToken_initializeOpUpdateVirtualGateway struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpUpdateVirtualGateway) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpUpdateVirtualGateway) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*UpdateVirtualGatewayInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *UpdateVirtualGatewayInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opUpdateVirtualGatewayMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpUpdateVirtualGateway{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opUpdateVirtualGateway(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/appmesh/api_op_UpdateVirtualNode.go b/service/appmesh/api_op_UpdateVirtualNode.go index b90daf1a26d..9b7a8600199 100644 --- a/service/appmesh/api_op_UpdateVirtualNode.go +++ b/service/appmesh/api_op_UpdateVirtualNode.go @@ -4,6 +4,7 @@ package appmesh import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/appmesh/types" @@ -117,6 +118,9 @@ func (c *Client) addOperationUpdateVirtualNodeMiddlewares(stack *middleware.Stac if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opUpdateVirtualNodeMiddleware(stack, options); err != nil { + return err + } if err = addOpUpdateVirtualNodeValidationMiddleware(stack); err != nil { return err } @@ -135,6 +139,39 @@ func (c *Client) addOperationUpdateVirtualNodeMiddlewares(stack *middleware.Stac return nil } +type idempotencyToken_initializeOpUpdateVirtualNode struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpUpdateVirtualNode) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpUpdateVirtualNode) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*UpdateVirtualNodeInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *UpdateVirtualNodeInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opUpdateVirtualNodeMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpUpdateVirtualNode{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opUpdateVirtualNode(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/appmesh/api_op_UpdateVirtualRouter.go b/service/appmesh/api_op_UpdateVirtualRouter.go index 82d9dacfb8d..446ff5ec989 100644 --- a/service/appmesh/api_op_UpdateVirtualRouter.go +++ b/service/appmesh/api_op_UpdateVirtualRouter.go @@ -4,6 +4,7 @@ package appmesh import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/appmesh/types" @@ -118,6 +119,9 @@ func (c *Client) addOperationUpdateVirtualRouterMiddlewares(stack *middleware.St if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opUpdateVirtualRouterMiddleware(stack, options); err != nil { + return err + } if err = addOpUpdateVirtualRouterValidationMiddleware(stack); err != nil { return err } @@ -136,6 +140,39 @@ func (c *Client) addOperationUpdateVirtualRouterMiddlewares(stack *middleware.St return nil } +type idempotencyToken_initializeOpUpdateVirtualRouter struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpUpdateVirtualRouter) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpUpdateVirtualRouter) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*UpdateVirtualRouterInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *UpdateVirtualRouterInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opUpdateVirtualRouterMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpUpdateVirtualRouter{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opUpdateVirtualRouter(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/appmesh/api_op_UpdateVirtualService.go b/service/appmesh/api_op_UpdateVirtualService.go index c9621e0da23..4a41845900b 100644 --- a/service/appmesh/api_op_UpdateVirtualService.go +++ b/service/appmesh/api_op_UpdateVirtualService.go @@ -4,6 +4,7 @@ package appmesh import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/appmesh/types" @@ -118,6 +119,9 @@ func (c *Client) addOperationUpdateVirtualServiceMiddlewares(stack *middleware.S if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opUpdateVirtualServiceMiddleware(stack, options); err != nil { + return err + } if err = addOpUpdateVirtualServiceValidationMiddleware(stack); err != nil { return err } @@ -136,6 +140,39 @@ func (c *Client) addOperationUpdateVirtualServiceMiddlewares(stack *middleware.S return nil } +type idempotencyToken_initializeOpUpdateVirtualService struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpUpdateVirtualService) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpUpdateVirtualService) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*UpdateVirtualServiceInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *UpdateVirtualServiceInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opUpdateVirtualServiceMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpUpdateVirtualService{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opUpdateVirtualService(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/braket/api_client.go b/service/braket/api_client.go index d0999297f91..8015f508356 100644 --- a/service/braket/api_client.go +++ b/service/braket/api_client.go @@ -4,6 +4,7 @@ package braket import ( "context" + cryptorand "crypto/rand" "github.com/aws/aws-sdk-go-v2/aws" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" @@ -14,6 +15,7 @@ import ( smithydocument "github.com/aws/smithy-go/document" "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" + smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" "net/http" "time" @@ -43,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveDefaultEndpointConfiguration(&options) + resolveIdempotencyTokenProvider(&options) + for _, fn := range optFns { fn(&options) } @@ -75,6 +79,10 @@ type Options struct { // Signature Version 4 (SigV4) Signer HTTPSignerV4 HTTPSignerV4 + // Provides idempotency tokens values that will be automatically populated into + // idempotent API operations. + IdempotencyTokenProvider IdempotencyTokenProvider + // The logger writer interface to write logging messages to. Logger logging.Logger @@ -240,6 +248,13 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func resolveIdempotencyTokenProvider(o *Options) { + if o.IdempotencyTokenProvider != nil { + return + } + o.IdempotencyTokenProvider = smithyrand.NewUUIDIdempotencyToken(cryptorand.Reader) +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, @@ -278,6 +293,11 @@ func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error { return nil } +// IdempotencyTokenProvider interface for providing idempotency token +type IdempotencyTokenProvider interface { + GetIdempotencyToken() (string, error) +} + func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error { return awsmiddleware.AddRequestIDRetrieverMiddleware(stack) } diff --git a/service/braket/api_op_CancelQuantumTask.go b/service/braket/api_op_CancelQuantumTask.go index 13c8055babe..76ff6ef412b 100644 --- a/service/braket/api_op_CancelQuantumTask.go +++ b/service/braket/api_op_CancelQuantumTask.go @@ -4,6 +4,7 @@ package braket import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/braket/types" @@ -105,6 +106,9 @@ func (c *Client) addOperationCancelQuantumTaskMiddlewares(stack *middleware.Stac if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCancelQuantumTaskMiddleware(stack, options); err != nil { + return err + } if err = addOpCancelQuantumTaskValidationMiddleware(stack); err != nil { return err } @@ -123,6 +127,39 @@ func (c *Client) addOperationCancelQuantumTaskMiddlewares(stack *middleware.Stac return nil } +type idempotencyToken_initializeOpCancelQuantumTask struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCancelQuantumTask) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCancelQuantumTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CancelQuantumTaskInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CancelQuantumTaskInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCancelQuantumTaskMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCancelQuantumTask{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCancelQuantumTask(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/braket/api_op_CreateJob.go b/service/braket/api_op_CreateJob.go index 77fa932e3e5..22e8b662476 100644 --- a/service/braket/api_op_CreateJob.go +++ b/service/braket/api_op_CreateJob.go @@ -4,6 +4,7 @@ package braket import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/braket/types" @@ -153,6 +154,9 @@ func (c *Client) addOperationCreateJobMiddlewares(stack *middleware.Stack, optio if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateJobMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateJobValidationMiddleware(stack); err != nil { return err } @@ -171,6 +175,39 @@ func (c *Client) addOperationCreateJobMiddlewares(stack *middleware.Stack, optio return nil } +type idempotencyToken_initializeOpCreateJob struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateJob) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateJobInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateJobInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateJobMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateJob{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateJob(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/braket/api_op_CreateQuantumTask.go b/service/braket/api_op_CreateQuantumTask.go index aadab502e2f..50bbd1163e5 100644 --- a/service/braket/api_op_CreateQuantumTask.go +++ b/service/braket/api_op_CreateQuantumTask.go @@ -4,6 +4,7 @@ package braket import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -132,6 +133,9 @@ func (c *Client) addOperationCreateQuantumTaskMiddlewares(stack *middleware.Stac if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateQuantumTaskMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateQuantumTaskValidationMiddleware(stack); err != nil { return err } @@ -150,6 +154,39 @@ func (c *Client) addOperationCreateQuantumTaskMiddlewares(stack *middleware.Stac return nil } +type idempotencyToken_initializeOpCreateQuantumTask struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateQuantumTask) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateQuantumTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateQuantumTaskInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateQuantumTaskInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateQuantumTaskMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateQuantumTask{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateQuantumTask(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/codeguruprofiler/api_client.go b/service/codeguruprofiler/api_client.go index a552694ff8a..da9b44f7d87 100644 --- a/service/codeguruprofiler/api_client.go +++ b/service/codeguruprofiler/api_client.go @@ -4,6 +4,7 @@ package codeguruprofiler import ( "context" + cryptorand "crypto/rand" "github.com/aws/aws-sdk-go-v2/aws" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" @@ -14,6 +15,7 @@ import ( smithydocument "github.com/aws/smithy-go/document" "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" + smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" "net/http" "time" @@ -44,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveDefaultEndpointConfiguration(&options) + resolveIdempotencyTokenProvider(&options) + for _, fn := range optFns { fn(&options) } @@ -76,6 +80,10 @@ type Options struct { // Signature Version 4 (SigV4) Signer HTTPSignerV4 HTTPSignerV4 + // Provides idempotency tokens values that will be automatically populated into + // idempotent API operations. + IdempotencyTokenProvider IdempotencyTokenProvider + // The logger writer interface to write logging messages to. Logger logging.Logger @@ -241,6 +249,13 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func resolveIdempotencyTokenProvider(o *Options) { + if o.IdempotencyTokenProvider != nil { + return + } + o.IdempotencyTokenProvider = smithyrand.NewUUIDIdempotencyToken(cryptorand.Reader) +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, @@ -279,6 +294,11 @@ func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error { return nil } +// IdempotencyTokenProvider interface for providing idempotency token +type IdempotencyTokenProvider interface { + GetIdempotencyToken() (string, error) +} + func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error { return awsmiddleware.AddRequestIDRetrieverMiddleware(stack) } diff --git a/service/codeguruprofiler/api_op_CreateProfilingGroup.go b/service/codeguruprofiler/api_op_CreateProfilingGroup.go index f3d6f34b614..b6bdf832ba2 100644 --- a/service/codeguruprofiler/api_op_CreateProfilingGroup.go +++ b/service/codeguruprofiler/api_op_CreateProfilingGroup.go @@ -4,6 +4,7 @@ package codeguruprofiler import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/codeguruprofiler/types" @@ -119,6 +120,9 @@ func (c *Client) addOperationCreateProfilingGroupMiddlewares(stack *middleware.S if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateProfilingGroupMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateProfilingGroupValidationMiddleware(stack); err != nil { return err } @@ -137,6 +141,39 @@ func (c *Client) addOperationCreateProfilingGroupMiddlewares(stack *middleware.S return nil } +type idempotencyToken_initializeOpCreateProfilingGroup struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateProfilingGroup) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateProfilingGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateProfilingGroupInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateProfilingGroupInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateProfilingGroupMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateProfilingGroup{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateProfilingGroup(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/codeguruprofiler/api_op_PostAgentProfile.go b/service/codeguruprofiler/api_op_PostAgentProfile.go index cba339ce1c1..7ba5414ba0a 100644 --- a/service/codeguruprofiler/api_op_PostAgentProfile.go +++ b/service/codeguruprofiler/api_op_PostAgentProfile.go @@ -4,6 +4,7 @@ package codeguruprofiler import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -116,6 +117,9 @@ func (c *Client) addOperationPostAgentProfileMiddlewares(stack *middleware.Stack if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opPostAgentProfileMiddleware(stack, options); err != nil { + return err + } if err = addOpPostAgentProfileValidationMiddleware(stack); err != nil { return err } @@ -134,6 +138,39 @@ func (c *Client) addOperationPostAgentProfileMiddlewares(stack *middleware.Stack return nil } +type idempotencyToken_initializeOpPostAgentProfile struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpPostAgentProfile) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpPostAgentProfile) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*PostAgentProfileInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *PostAgentProfileInput ") + } + + if input.ProfileToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ProfileToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opPostAgentProfileMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpPostAgentProfile{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opPostAgentProfile(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/evidently/api_op_BatchEvaluateFeature.go b/service/evidently/api_op_BatchEvaluateFeature.go index 3aa4ba29fb6..f5d9cf11883 100644 --- a/service/evidently/api_op_BatchEvaluateFeature.go +++ b/service/evidently/api_op_BatchEvaluateFeature.go @@ -4,6 +4,7 @@ package evidently import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/evidently/types" @@ -115,6 +116,9 @@ func (c *Client) addOperationBatchEvaluateFeatureMiddlewares(stack *middleware.S if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opBatchEvaluateFeatureMiddleware(stack); err != nil { + return err + } if err = addOpBatchEvaluateFeatureValidationMiddleware(stack); err != nil { return err } @@ -133,6 +137,33 @@ func (c *Client) addOperationBatchEvaluateFeatureMiddlewares(stack *middleware.S return nil } +type endpointPrefix_opBatchEvaluateFeatureMiddleware struct { +} + +func (*endpointPrefix_opBatchEvaluateFeatureMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opBatchEvaluateFeatureMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "dataplane." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opBatchEvaluateFeatureMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opBatchEvaluateFeatureMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opBatchEvaluateFeature(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/evidently/api_op_EvaluateFeature.go b/service/evidently/api_op_EvaluateFeature.go index 34c57586e8f..c0017f7a98b 100644 --- a/service/evidently/api_op_EvaluateFeature.go +++ b/service/evidently/api_op_EvaluateFeature.go @@ -4,6 +4,7 @@ package evidently import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/evidently/types" @@ -142,6 +143,9 @@ func (c *Client) addOperationEvaluateFeatureMiddlewares(stack *middleware.Stack, if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opEvaluateFeatureMiddleware(stack); err != nil { + return err + } if err = addOpEvaluateFeatureValidationMiddleware(stack); err != nil { return err } @@ -160,6 +164,33 @@ func (c *Client) addOperationEvaluateFeatureMiddlewares(stack *middleware.Stack, return nil } +type endpointPrefix_opEvaluateFeatureMiddleware struct { +} + +func (*endpointPrefix_opEvaluateFeatureMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opEvaluateFeatureMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "dataplane." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opEvaluateFeatureMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opEvaluateFeatureMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opEvaluateFeature(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/evidently/api_op_PutProjectEvents.go b/service/evidently/api_op_PutProjectEvents.go index 4e5a1c49f4c..a3a5502380c 100644 --- a/service/evidently/api_op_PutProjectEvents.go +++ b/service/evidently/api_op_PutProjectEvents.go @@ -4,6 +4,7 @@ package evidently import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/evidently/types" @@ -104,6 +105,9 @@ func (c *Client) addOperationPutProjectEventsMiddlewares(stack *middleware.Stack if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opPutProjectEventsMiddleware(stack); err != nil { + return err + } if err = addOpPutProjectEventsValidationMiddleware(stack); err != nil { return err } @@ -122,6 +126,33 @@ func (c *Client) addOperationPutProjectEventsMiddlewares(stack *middleware.Stack return nil } +type endpointPrefix_opPutProjectEventsMiddleware struct { +} + +func (*endpointPrefix_opPutProjectEventsMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opPutProjectEventsMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "dataplane." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opPutProjectEventsMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opPutProjectEventsMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opPutProjectEvents(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/grafana/api_client.go b/service/grafana/api_client.go index a39a4ae9c31..3605d847d07 100644 --- a/service/grafana/api_client.go +++ b/service/grafana/api_client.go @@ -4,6 +4,7 @@ package grafana import ( "context" + cryptorand "crypto/rand" "github.com/aws/aws-sdk-go-v2/aws" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" @@ -14,6 +15,7 @@ import ( smithydocument "github.com/aws/smithy-go/document" "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" + smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" "net/http" "time" @@ -44,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveDefaultEndpointConfiguration(&options) + resolveIdempotencyTokenProvider(&options) + for _, fn := range optFns { fn(&options) } @@ -76,6 +80,10 @@ type Options struct { // Signature Version 4 (SigV4) Signer HTTPSignerV4 HTTPSignerV4 + // Provides idempotency tokens values that will be automatically populated into + // idempotent API operations. + IdempotencyTokenProvider IdempotencyTokenProvider + // The logger writer interface to write logging messages to. Logger logging.Logger @@ -241,6 +249,13 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func resolveIdempotencyTokenProvider(o *Options) { + if o.IdempotencyTokenProvider != nil { + return + } + o.IdempotencyTokenProvider = smithyrand.NewUUIDIdempotencyToken(cryptorand.Reader) +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, @@ -279,6 +294,11 @@ func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error { return nil } +// IdempotencyTokenProvider interface for providing idempotency token +type IdempotencyTokenProvider interface { + GetIdempotencyToken() (string, error) +} + func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error { return awsmiddleware.AddRequestIDRetrieverMiddleware(stack) } diff --git a/service/grafana/api_op_CreateWorkspace.go b/service/grafana/api_op_CreateWorkspace.go index e9d1eee0310..e61f208d419 100644 --- a/service/grafana/api_op_CreateWorkspace.go +++ b/service/grafana/api_op_CreateWorkspace.go @@ -4,6 +4,7 @@ package grafana import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/grafana/types" @@ -175,6 +176,9 @@ func (c *Client) addOperationCreateWorkspaceMiddlewares(stack *middleware.Stack, if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateWorkspaceMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateWorkspaceValidationMiddleware(stack); err != nil { return err } @@ -193,6 +197,39 @@ func (c *Client) addOperationCreateWorkspaceMiddlewares(stack *middleware.Stack, return nil } +type idempotencyToken_initializeOpCreateWorkspace struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateWorkspace) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateWorkspace) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateWorkspaceInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateWorkspaceInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateWorkspaceMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateWorkspace{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateWorkspace(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_AssociateTrackerConsumer.go b/service/location/api_op_AssociateTrackerConsumer.go index 57061982dcb..4a71dcb0aec 100644 --- a/service/location/api_op_AssociateTrackerConsumer.go +++ b/service/location/api_op_AssociateTrackerConsumer.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -103,6 +104,9 @@ func (c *Client) addOperationAssociateTrackerConsumerMiddlewares(stack *middlewa if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opAssociateTrackerConsumerMiddleware(stack); err != nil { + return err + } if err = addOpAssociateTrackerConsumerValidationMiddleware(stack); err != nil { return err } @@ -121,6 +125,33 @@ func (c *Client) addOperationAssociateTrackerConsumerMiddlewares(stack *middlewa return nil } +type endpointPrefix_opAssociateTrackerConsumerMiddleware struct { +} + +func (*endpointPrefix_opAssociateTrackerConsumerMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opAssociateTrackerConsumerMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "tracking." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opAssociateTrackerConsumerMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opAssociateTrackerConsumerMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opAssociateTrackerConsumer(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_BatchDeleteDevicePositionHistory.go b/service/location/api_op_BatchDeleteDevicePositionHistory.go index 0938ed3762c..6b1ce2fbdc0 100644 --- a/service/location/api_op_BatchDeleteDevicePositionHistory.go +++ b/service/location/api_op_BatchDeleteDevicePositionHistory.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" @@ -103,6 +104,9 @@ func (c *Client) addOperationBatchDeleteDevicePositionHistoryMiddlewares(stack * if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opBatchDeleteDevicePositionHistoryMiddleware(stack); err != nil { + return err + } if err = addOpBatchDeleteDevicePositionHistoryValidationMiddleware(stack); err != nil { return err } @@ -121,6 +125,33 @@ func (c *Client) addOperationBatchDeleteDevicePositionHistoryMiddlewares(stack * return nil } +type endpointPrefix_opBatchDeleteDevicePositionHistoryMiddleware struct { +} + +func (*endpointPrefix_opBatchDeleteDevicePositionHistoryMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opBatchDeleteDevicePositionHistoryMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "tracking." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opBatchDeleteDevicePositionHistoryMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opBatchDeleteDevicePositionHistoryMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opBatchDeleteDevicePositionHistory(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_BatchDeleteGeofence.go b/service/location/api_op_BatchDeleteGeofence.go index b7b8c26a41d..5b640ab0e19 100644 --- a/service/location/api_op_BatchDeleteGeofence.go +++ b/service/location/api_op_BatchDeleteGeofence.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" @@ -101,6 +102,9 @@ func (c *Client) addOperationBatchDeleteGeofenceMiddlewares(stack *middleware.St if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opBatchDeleteGeofenceMiddleware(stack); err != nil { + return err + } if err = addOpBatchDeleteGeofenceValidationMiddleware(stack); err != nil { return err } @@ -119,6 +123,33 @@ func (c *Client) addOperationBatchDeleteGeofenceMiddlewares(stack *middleware.St return nil } +type endpointPrefix_opBatchDeleteGeofenceMiddleware struct { +} + +func (*endpointPrefix_opBatchDeleteGeofenceMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opBatchDeleteGeofenceMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "geofencing." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opBatchDeleteGeofenceMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opBatchDeleteGeofenceMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opBatchDeleteGeofence(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_BatchEvaluateGeofences.go b/service/location/api_op_BatchEvaluateGeofences.go index 8623d8e8d21..d9ae7e7958b 100644 --- a/service/location/api_op_BatchEvaluateGeofences.go +++ b/service/location/api_op_BatchEvaluateGeofences.go @@ -4,7 +4,9 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" @@ -92,9 +94,15 @@ func (c *Client) addOperationBatchEvaluateGeofencesMiddlewares(stack *middleware if err = addResolveEndpointMiddleware(stack, options); err != nil { return err } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } if err = addRetryMiddlewares(stack, options); err != nil { return err } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { return err } @@ -110,6 +118,9 @@ func (c *Client) addOperationBatchEvaluateGeofencesMiddlewares(stack *middleware if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opBatchEvaluateGeofencesMiddleware(stack); err != nil { + return err + } if err = addOpBatchEvaluateGeofencesValidationMiddleware(stack); err != nil { return err } @@ -128,10 +139,38 @@ func (c *Client) addOperationBatchEvaluateGeofencesMiddlewares(stack *middleware return nil } +type endpointPrefix_opBatchEvaluateGeofencesMiddleware struct { +} + +func (*endpointPrefix_opBatchEvaluateGeofencesMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opBatchEvaluateGeofencesMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "geofencing." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opBatchEvaluateGeofencesMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opBatchEvaluateGeofencesMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opBatchEvaluateGeofences(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, ServiceID: ServiceID, + SigningName: "geo", OperationName: "BatchEvaluateGeofences", } } diff --git a/service/location/api_op_BatchGetDevicePosition.go b/service/location/api_op_BatchGetDevicePosition.go index 897f912e212..066c1a32ec5 100644 --- a/service/location/api_op_BatchGetDevicePosition.go +++ b/service/location/api_op_BatchGetDevicePosition.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" @@ -110,6 +111,9 @@ func (c *Client) addOperationBatchGetDevicePositionMiddlewares(stack *middleware if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opBatchGetDevicePositionMiddleware(stack); err != nil { + return err + } if err = addOpBatchGetDevicePositionValidationMiddleware(stack); err != nil { return err } @@ -128,6 +132,33 @@ func (c *Client) addOperationBatchGetDevicePositionMiddlewares(stack *middleware return nil } +type endpointPrefix_opBatchGetDevicePositionMiddleware struct { +} + +func (*endpointPrefix_opBatchGetDevicePositionMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opBatchGetDevicePositionMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "tracking." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opBatchGetDevicePositionMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opBatchGetDevicePositionMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opBatchGetDevicePosition(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_BatchPutGeofence.go b/service/location/api_op_BatchPutGeofence.go index bee6989fb01..2de4da7972f 100644 --- a/service/location/api_op_BatchPutGeofence.go +++ b/service/location/api_op_BatchPutGeofence.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" @@ -108,6 +109,9 @@ func (c *Client) addOperationBatchPutGeofenceMiddlewares(stack *middleware.Stack if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opBatchPutGeofenceMiddleware(stack); err != nil { + return err + } if err = addOpBatchPutGeofenceValidationMiddleware(stack); err != nil { return err } @@ -126,6 +130,33 @@ func (c *Client) addOperationBatchPutGeofenceMiddlewares(stack *middleware.Stack return nil } +type endpointPrefix_opBatchPutGeofenceMiddleware struct { +} + +func (*endpointPrefix_opBatchPutGeofenceMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opBatchPutGeofenceMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "geofencing." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opBatchPutGeofenceMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opBatchPutGeofenceMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opBatchPutGeofence(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_BatchUpdateDevicePosition.go b/service/location/api_op_BatchUpdateDevicePosition.go index 3e1b24d88f3..f428b7f1791 100644 --- a/service/location/api_op_BatchUpdateDevicePosition.go +++ b/service/location/api_op_BatchUpdateDevicePosition.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" @@ -110,6 +111,9 @@ func (c *Client) addOperationBatchUpdateDevicePositionMiddlewares(stack *middlew if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opBatchUpdateDevicePositionMiddleware(stack); err != nil { + return err + } if err = addOpBatchUpdateDevicePositionValidationMiddleware(stack); err != nil { return err } @@ -128,6 +132,33 @@ func (c *Client) addOperationBatchUpdateDevicePositionMiddlewares(stack *middlew return nil } +type endpointPrefix_opBatchUpdateDevicePositionMiddleware struct { +} + +func (*endpointPrefix_opBatchUpdateDevicePositionMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opBatchUpdateDevicePositionMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "tracking." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opBatchUpdateDevicePositionMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opBatchUpdateDevicePositionMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opBatchUpdateDevicePosition(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_CalculateRoute.go b/service/location/api_op_CalculateRoute.go index 6ccc315cb95..7cc79fcdac8 100644 --- a/service/location/api_op_CalculateRoute.go +++ b/service/location/api_op_CalculateRoute.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" @@ -239,6 +240,9 @@ func (c *Client) addOperationCalculateRouteMiddlewares(stack *middleware.Stack, if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opCalculateRouteMiddleware(stack); err != nil { + return err + } if err = addOpCalculateRouteValidationMiddleware(stack); err != nil { return err } @@ -257,6 +261,33 @@ func (c *Client) addOperationCalculateRouteMiddlewares(stack *middleware.Stack, return nil } +type endpointPrefix_opCalculateRouteMiddleware struct { +} + +func (*endpointPrefix_opCalculateRouteMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opCalculateRouteMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "routes." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opCalculateRouteMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opCalculateRouteMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opCalculateRoute(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_CreateGeofenceCollection.go b/service/location/api_op_CreateGeofenceCollection.go index 3b1d44aef78..d5c24f98629 100644 --- a/service/location/api_op_CreateGeofenceCollection.go +++ b/service/location/api_op_CreateGeofenceCollection.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" @@ -172,6 +173,9 @@ func (c *Client) addOperationCreateGeofenceCollectionMiddlewares(stack *middlewa if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opCreateGeofenceCollectionMiddleware(stack); err != nil { + return err + } if err = addOpCreateGeofenceCollectionValidationMiddleware(stack); err != nil { return err } @@ -190,6 +194,33 @@ func (c *Client) addOperationCreateGeofenceCollectionMiddlewares(stack *middlewa return nil } +type endpointPrefix_opCreateGeofenceCollectionMiddleware struct { +} + +func (*endpointPrefix_opCreateGeofenceCollectionMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opCreateGeofenceCollectionMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "geofencing." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opCreateGeofenceCollectionMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opCreateGeofenceCollectionMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opCreateGeofenceCollection(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_CreateMap.go b/service/location/api_op_CreateMap.go index 7522774796f..e3af864938a 100644 --- a/service/location/api_op_CreateMap.go +++ b/service/location/api_op_CreateMap.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" @@ -157,6 +158,9 @@ func (c *Client) addOperationCreateMapMiddlewares(stack *middleware.Stack, optio if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opCreateMapMiddleware(stack); err != nil { + return err + } if err = addOpCreateMapValidationMiddleware(stack); err != nil { return err } @@ -175,6 +179,33 @@ func (c *Client) addOperationCreateMapMiddlewares(stack *middleware.Stack, optio return nil } +type endpointPrefix_opCreateMapMiddleware struct { +} + +func (*endpointPrefix_opCreateMapMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opCreateMapMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "maps." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opCreateMapMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opCreateMapMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opCreateMap(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_CreatePlaceIndex.go b/service/location/api_op_CreatePlaceIndex.go index e71a04bb9be..d78f0856d63 100644 --- a/service/location/api_op_CreatePlaceIndex.go +++ b/service/location/api_op_CreatePlaceIndex.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" @@ -188,6 +189,9 @@ func (c *Client) addOperationCreatePlaceIndexMiddlewares(stack *middleware.Stack if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opCreatePlaceIndexMiddleware(stack); err != nil { + return err + } if err = addOpCreatePlaceIndexValidationMiddleware(stack); err != nil { return err } @@ -206,6 +210,33 @@ func (c *Client) addOperationCreatePlaceIndexMiddlewares(stack *middleware.Stack return nil } +type endpointPrefix_opCreatePlaceIndexMiddleware struct { +} + +func (*endpointPrefix_opCreatePlaceIndexMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opCreatePlaceIndexMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "places." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opCreatePlaceIndexMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opCreatePlaceIndexMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opCreatePlaceIndex(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_CreateRouteCalculator.go b/service/location/api_op_CreateRouteCalculator.go index ae4e971f1ba..10bdc59975f 100644 --- a/service/location/api_op_CreateRouteCalculator.go +++ b/service/location/api_op_CreateRouteCalculator.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" @@ -193,6 +194,9 @@ func (c *Client) addOperationCreateRouteCalculatorMiddlewares(stack *middleware. if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opCreateRouteCalculatorMiddleware(stack); err != nil { + return err + } if err = addOpCreateRouteCalculatorValidationMiddleware(stack); err != nil { return err } @@ -211,6 +215,33 @@ func (c *Client) addOperationCreateRouteCalculatorMiddlewares(stack *middleware. return nil } +type endpointPrefix_opCreateRouteCalculatorMiddleware struct { +} + +func (*endpointPrefix_opCreateRouteCalculatorMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opCreateRouteCalculatorMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "routes." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opCreateRouteCalculatorMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opCreateRouteCalculatorMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opCreateRouteCalculator(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_CreateTracker.go b/service/location/api_op_CreateTracker.go index 4bac8500b85..e6cf41cbf39 100644 --- a/service/location/api_op_CreateTracker.go +++ b/service/location/api_op_CreateTracker.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" @@ -192,6 +193,9 @@ func (c *Client) addOperationCreateTrackerMiddlewares(stack *middleware.Stack, o if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opCreateTrackerMiddleware(stack); err != nil { + return err + } if err = addOpCreateTrackerValidationMiddleware(stack); err != nil { return err } @@ -210,6 +214,33 @@ func (c *Client) addOperationCreateTrackerMiddlewares(stack *middleware.Stack, o return nil } +type endpointPrefix_opCreateTrackerMiddleware struct { +} + +func (*endpointPrefix_opCreateTrackerMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opCreateTrackerMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "tracking." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opCreateTrackerMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opCreateTrackerMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opCreateTracker(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_DeleteGeofenceCollection.go b/service/location/api_op_DeleteGeofenceCollection.go index 89f6858de26..ee280ae9c32 100644 --- a/service/location/api_op_DeleteGeofenceCollection.go +++ b/service/location/api_op_DeleteGeofenceCollection.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -90,6 +91,9 @@ func (c *Client) addOperationDeleteGeofenceCollectionMiddlewares(stack *middlewa if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opDeleteGeofenceCollectionMiddleware(stack); err != nil { + return err + } if err = addOpDeleteGeofenceCollectionValidationMiddleware(stack); err != nil { return err } @@ -108,6 +112,33 @@ func (c *Client) addOperationDeleteGeofenceCollectionMiddlewares(stack *middlewa return nil } +type endpointPrefix_opDeleteGeofenceCollectionMiddleware struct { +} + +func (*endpointPrefix_opDeleteGeofenceCollectionMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opDeleteGeofenceCollectionMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "geofencing." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opDeleteGeofenceCollectionMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opDeleteGeofenceCollectionMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opDeleteGeofenceCollection(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_DeleteMap.go b/service/location/api_op_DeleteMap.go index 88f5c1101fa..3ec457d5035 100644 --- a/service/location/api_op_DeleteMap.go +++ b/service/location/api_op_DeleteMap.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -90,6 +91,9 @@ func (c *Client) addOperationDeleteMapMiddlewares(stack *middleware.Stack, optio if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opDeleteMapMiddleware(stack); err != nil { + return err + } if err = addOpDeleteMapValidationMiddleware(stack); err != nil { return err } @@ -108,6 +112,33 @@ func (c *Client) addOperationDeleteMapMiddlewares(stack *middleware.Stack, optio return nil } +type endpointPrefix_opDeleteMapMiddleware struct { +} + +func (*endpointPrefix_opDeleteMapMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opDeleteMapMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "maps." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opDeleteMapMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opDeleteMapMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opDeleteMap(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_DeletePlaceIndex.go b/service/location/api_op_DeletePlaceIndex.go index c3e96a4bd6d..8c2d7112e40 100644 --- a/service/location/api_op_DeletePlaceIndex.go +++ b/service/location/api_op_DeletePlaceIndex.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -89,6 +90,9 @@ func (c *Client) addOperationDeletePlaceIndexMiddlewares(stack *middleware.Stack if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opDeletePlaceIndexMiddleware(stack); err != nil { + return err + } if err = addOpDeletePlaceIndexValidationMiddleware(stack); err != nil { return err } @@ -107,6 +111,33 @@ func (c *Client) addOperationDeletePlaceIndexMiddlewares(stack *middleware.Stack return nil } +type endpointPrefix_opDeletePlaceIndexMiddleware struct { +} + +func (*endpointPrefix_opDeletePlaceIndexMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opDeletePlaceIndexMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "places." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opDeletePlaceIndexMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opDeletePlaceIndexMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opDeletePlaceIndex(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_DeleteRouteCalculator.go b/service/location/api_op_DeleteRouteCalculator.go index 07abdc127b2..e381bbba113 100644 --- a/service/location/api_op_DeleteRouteCalculator.go +++ b/service/location/api_op_DeleteRouteCalculator.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -89,6 +90,9 @@ func (c *Client) addOperationDeleteRouteCalculatorMiddlewares(stack *middleware. if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opDeleteRouteCalculatorMiddleware(stack); err != nil { + return err + } if err = addOpDeleteRouteCalculatorValidationMiddleware(stack); err != nil { return err } @@ -107,6 +111,33 @@ func (c *Client) addOperationDeleteRouteCalculatorMiddlewares(stack *middleware. return nil } +type endpointPrefix_opDeleteRouteCalculatorMiddleware struct { +} + +func (*endpointPrefix_opDeleteRouteCalculatorMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opDeleteRouteCalculatorMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "routes." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opDeleteRouteCalculatorMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opDeleteRouteCalculatorMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opDeleteRouteCalculator(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_DeleteTracker.go b/service/location/api_op_DeleteTracker.go index 9784fc3d2af..238aa24bfa7 100644 --- a/service/location/api_op_DeleteTracker.go +++ b/service/location/api_op_DeleteTracker.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -91,6 +92,9 @@ func (c *Client) addOperationDeleteTrackerMiddlewares(stack *middleware.Stack, o if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opDeleteTrackerMiddleware(stack); err != nil { + return err + } if err = addOpDeleteTrackerValidationMiddleware(stack); err != nil { return err } @@ -109,6 +113,33 @@ func (c *Client) addOperationDeleteTrackerMiddlewares(stack *middleware.Stack, o return nil } +type endpointPrefix_opDeleteTrackerMiddleware struct { +} + +func (*endpointPrefix_opDeleteTrackerMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opDeleteTrackerMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "tracking." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opDeleteTrackerMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opDeleteTrackerMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opDeleteTracker(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_DescribeGeofenceCollection.go b/service/location/api_op_DescribeGeofenceCollection.go index 513e381a05d..c393efc679f 100644 --- a/service/location/api_op_DescribeGeofenceCollection.go +++ b/service/location/api_op_DescribeGeofenceCollection.go @@ -4,7 +4,9 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" @@ -117,9 +119,15 @@ func (c *Client) addOperationDescribeGeofenceCollectionMiddlewares(stack *middle if err = addResolveEndpointMiddleware(stack, options); err != nil { return err } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } if err = addRetryMiddlewares(stack, options); err != nil { return err } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { return err } @@ -135,6 +143,9 @@ func (c *Client) addOperationDescribeGeofenceCollectionMiddlewares(stack *middle if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opDescribeGeofenceCollectionMiddleware(stack); err != nil { + return err + } if err = addOpDescribeGeofenceCollectionValidationMiddleware(stack); err != nil { return err } @@ -153,10 +164,38 @@ func (c *Client) addOperationDescribeGeofenceCollectionMiddlewares(stack *middle return nil } +type endpointPrefix_opDescribeGeofenceCollectionMiddleware struct { +} + +func (*endpointPrefix_opDescribeGeofenceCollectionMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opDescribeGeofenceCollectionMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "geofencing." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opDescribeGeofenceCollectionMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opDescribeGeofenceCollectionMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opDescribeGeofenceCollection(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, ServiceID: ServiceID, + SigningName: "geo", OperationName: "DescribeGeofenceCollection", } } diff --git a/service/location/api_op_DescribeMap.go b/service/location/api_op_DescribeMap.go index 13d773183d8..67268b6c4d4 100644 --- a/service/location/api_op_DescribeMap.go +++ b/service/location/api_op_DescribeMap.go @@ -4,7 +4,9 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" @@ -118,9 +120,15 @@ func (c *Client) addOperationDescribeMapMiddlewares(stack *middleware.Stack, opt if err = addResolveEndpointMiddleware(stack, options); err != nil { return err } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } if err = addRetryMiddlewares(stack, options); err != nil { return err } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { return err } @@ -136,6 +144,9 @@ func (c *Client) addOperationDescribeMapMiddlewares(stack *middleware.Stack, opt if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opDescribeMapMiddleware(stack); err != nil { + return err + } if err = addOpDescribeMapValidationMiddleware(stack); err != nil { return err } @@ -154,10 +165,38 @@ func (c *Client) addOperationDescribeMapMiddlewares(stack *middleware.Stack, opt return nil } +type endpointPrefix_opDescribeMapMiddleware struct { +} + +func (*endpointPrefix_opDescribeMapMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opDescribeMapMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "maps." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opDescribeMapMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opDescribeMapMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opDescribeMap(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, ServiceID: ServiceID, + SigningName: "geo", OperationName: "DescribeMap", } } diff --git a/service/location/api_op_DescribePlaceIndex.go b/service/location/api_op_DescribePlaceIndex.go index f23a2a2e37e..80dc22312e0 100644 --- a/service/location/api_op_DescribePlaceIndex.go +++ b/service/location/api_op_DescribePlaceIndex.go @@ -4,7 +4,9 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" @@ -128,9 +130,15 @@ func (c *Client) addOperationDescribePlaceIndexMiddlewares(stack *middleware.Sta if err = addResolveEndpointMiddleware(stack, options); err != nil { return err } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } if err = addRetryMiddlewares(stack, options); err != nil { return err } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { return err } @@ -146,6 +154,9 @@ func (c *Client) addOperationDescribePlaceIndexMiddlewares(stack *middleware.Sta if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opDescribePlaceIndexMiddleware(stack); err != nil { + return err + } if err = addOpDescribePlaceIndexValidationMiddleware(stack); err != nil { return err } @@ -164,10 +175,38 @@ func (c *Client) addOperationDescribePlaceIndexMiddlewares(stack *middleware.Sta return nil } +type endpointPrefix_opDescribePlaceIndexMiddleware struct { +} + +func (*endpointPrefix_opDescribePlaceIndexMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opDescribePlaceIndexMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "places." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opDescribePlaceIndexMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opDescribePlaceIndexMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opDescribePlaceIndex(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, ServiceID: ServiceID, + SigningName: "geo", OperationName: "DescribePlaceIndex", } } diff --git a/service/location/api_op_DescribeRouteCalculator.go b/service/location/api_op_DescribeRouteCalculator.go index b933acb4260..99420142c1a 100644 --- a/service/location/api_op_DescribeRouteCalculator.go +++ b/service/location/api_op_DescribeRouteCalculator.go @@ -4,7 +4,9 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" @@ -127,9 +129,15 @@ func (c *Client) addOperationDescribeRouteCalculatorMiddlewares(stack *middlewar if err = addResolveEndpointMiddleware(stack, options); err != nil { return err } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } if err = addRetryMiddlewares(stack, options); err != nil { return err } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { return err } @@ -145,6 +153,9 @@ func (c *Client) addOperationDescribeRouteCalculatorMiddlewares(stack *middlewar if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opDescribeRouteCalculatorMiddleware(stack); err != nil { + return err + } if err = addOpDescribeRouteCalculatorValidationMiddleware(stack); err != nil { return err } @@ -163,10 +174,38 @@ func (c *Client) addOperationDescribeRouteCalculatorMiddlewares(stack *middlewar return nil } +type endpointPrefix_opDescribeRouteCalculatorMiddleware struct { +} + +func (*endpointPrefix_opDescribeRouteCalculatorMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opDescribeRouteCalculatorMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "routes." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opDescribeRouteCalculatorMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opDescribeRouteCalculatorMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opDescribeRouteCalculator(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, ServiceID: ServiceID, + SigningName: "geo", OperationName: "DescribeRouteCalculator", } } diff --git a/service/location/api_op_DescribeTracker.go b/service/location/api_op_DescribeTracker.go index 45f7b04038e..40f90a754eb 100644 --- a/service/location/api_op_DescribeTracker.go +++ b/service/location/api_op_DescribeTracker.go @@ -4,7 +4,9 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" "github.com/aws/smithy-go/middleware" smithyhttp "github.com/aws/smithy-go/transport/http" @@ -120,9 +122,15 @@ func (c *Client) addOperationDescribeTrackerMiddlewares(stack *middleware.Stack, if err = addResolveEndpointMiddleware(stack, options); err != nil { return err } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } if err = addRetryMiddlewares(stack, options); err != nil { return err } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { return err } @@ -138,6 +146,9 @@ func (c *Client) addOperationDescribeTrackerMiddlewares(stack *middleware.Stack, if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opDescribeTrackerMiddleware(stack); err != nil { + return err + } if err = addOpDescribeTrackerValidationMiddleware(stack); err != nil { return err } @@ -156,10 +167,38 @@ func (c *Client) addOperationDescribeTrackerMiddlewares(stack *middleware.Stack, return nil } +type endpointPrefix_opDescribeTrackerMiddleware struct { +} + +func (*endpointPrefix_opDescribeTrackerMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opDescribeTrackerMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "tracking." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opDescribeTrackerMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opDescribeTrackerMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opDescribeTracker(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, ServiceID: ServiceID, + SigningName: "geo", OperationName: "DescribeTracker", } } diff --git a/service/location/api_op_DisassociateTrackerConsumer.go b/service/location/api_op_DisassociateTrackerConsumer.go index 7ed24503f0c..ab3d9309c88 100644 --- a/service/location/api_op_DisassociateTrackerConsumer.go +++ b/service/location/api_op_DisassociateTrackerConsumer.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -100,6 +101,9 @@ func (c *Client) addOperationDisassociateTrackerConsumerMiddlewares(stack *middl if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opDisassociateTrackerConsumerMiddleware(stack); err != nil { + return err + } if err = addOpDisassociateTrackerConsumerValidationMiddleware(stack); err != nil { return err } @@ -118,6 +122,33 @@ func (c *Client) addOperationDisassociateTrackerConsumerMiddlewares(stack *middl return nil } +type endpointPrefix_opDisassociateTrackerConsumerMiddleware struct { +} + +func (*endpointPrefix_opDisassociateTrackerConsumerMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opDisassociateTrackerConsumerMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "tracking." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opDisassociateTrackerConsumerMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opDisassociateTrackerConsumerMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opDisassociateTrackerConsumer(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_GetDevicePosition.go b/service/location/api_op_GetDevicePosition.go index 0e9c5b25cf0..088af2caa2f 100644 --- a/service/location/api_op_GetDevicePosition.go +++ b/service/location/api_op_GetDevicePosition.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -118,6 +119,9 @@ func (c *Client) addOperationGetDevicePositionMiddlewares(stack *middleware.Stac if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opGetDevicePositionMiddleware(stack); err != nil { + return err + } if err = addOpGetDevicePositionValidationMiddleware(stack); err != nil { return err } @@ -136,6 +140,33 @@ func (c *Client) addOperationGetDevicePositionMiddlewares(stack *middleware.Stac return nil } +type endpointPrefix_opGetDevicePositionMiddleware struct { +} + +func (*endpointPrefix_opGetDevicePositionMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opGetDevicePositionMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "tracking." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opGetDevicePositionMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opGetDevicePositionMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opGetDevicePosition(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_GetDevicePositionHistory.go b/service/location/api_op_GetDevicePositionHistory.go index 987d6c514af..c4cabeb169d 100644 --- a/service/location/api_op_GetDevicePositionHistory.go +++ b/service/location/api_op_GetDevicePositionHistory.go @@ -129,6 +129,9 @@ func (c *Client) addOperationGetDevicePositionHistoryMiddlewares(stack *middlewa if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opGetDevicePositionHistoryMiddleware(stack); err != nil { + return err + } if err = addOpGetDevicePositionHistoryValidationMiddleware(stack); err != nil { return err } @@ -147,6 +150,33 @@ func (c *Client) addOperationGetDevicePositionHistoryMiddlewares(stack *middlewa return nil } +type endpointPrefix_opGetDevicePositionHistoryMiddleware struct { +} + +func (*endpointPrefix_opGetDevicePositionHistoryMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opGetDevicePositionHistoryMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "tracking." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opGetDevicePositionHistoryMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opGetDevicePositionHistoryMiddleware{}, `OperationSerializer`, middleware.After) +} + // GetDevicePositionHistoryAPIClient is a client that implements the // GetDevicePositionHistory operation. type GetDevicePositionHistoryAPIClient interface { diff --git a/service/location/api_op_GetGeofence.go b/service/location/api_op_GetGeofence.go index 14ff242cb6f..00d765ea7b0 100644 --- a/service/location/api_op_GetGeofence.go +++ b/service/location/api_op_GetGeofence.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" @@ -139,6 +140,9 @@ func (c *Client) addOperationGetGeofenceMiddlewares(stack *middleware.Stack, opt if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opGetGeofenceMiddleware(stack); err != nil { + return err + } if err = addOpGetGeofenceValidationMiddleware(stack); err != nil { return err } @@ -157,6 +161,33 @@ func (c *Client) addOperationGetGeofenceMiddlewares(stack *middleware.Stack, opt return nil } +type endpointPrefix_opGetGeofenceMiddleware struct { +} + +func (*endpointPrefix_opGetGeofenceMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opGetGeofenceMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "geofencing." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opGetGeofenceMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opGetGeofenceMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opGetGeofence(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_GetMapGlyphs.go b/service/location/api_op_GetMapGlyphs.go index e81f90f87fd..792694fb5c4 100644 --- a/service/location/api_op_GetMapGlyphs.go +++ b/service/location/api_op_GetMapGlyphs.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -132,6 +133,9 @@ func (c *Client) addOperationGetMapGlyphsMiddlewares(stack *middleware.Stack, op if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opGetMapGlyphsMiddleware(stack); err != nil { + return err + } if err = addOpGetMapGlyphsValidationMiddleware(stack); err != nil { return err } @@ -150,6 +154,33 @@ func (c *Client) addOperationGetMapGlyphsMiddlewares(stack *middleware.Stack, op return nil } +type endpointPrefix_opGetMapGlyphsMiddleware struct { +} + +func (*endpointPrefix_opGetMapGlyphsMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opGetMapGlyphsMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "maps." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opGetMapGlyphsMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opGetMapGlyphsMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opGetMapGlyphs(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_GetMapSprites.go b/service/location/api_op_GetMapSprites.go index fa00d5e1c81..66268c4b26a 100644 --- a/service/location/api_op_GetMapSprites.go +++ b/service/location/api_op_GetMapSprites.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -117,6 +118,9 @@ func (c *Client) addOperationGetMapSpritesMiddlewares(stack *middleware.Stack, o if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opGetMapSpritesMiddleware(stack); err != nil { + return err + } if err = addOpGetMapSpritesValidationMiddleware(stack); err != nil { return err } @@ -135,6 +139,33 @@ func (c *Client) addOperationGetMapSpritesMiddlewares(stack *middleware.Stack, o return nil } +type endpointPrefix_opGetMapSpritesMiddleware struct { +} + +func (*endpointPrefix_opGetMapSpritesMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opGetMapSpritesMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "maps." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opGetMapSpritesMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opGetMapSpritesMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opGetMapSprites(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_GetMapStyleDescriptor.go b/service/location/api_op_GetMapStyleDescriptor.go index 99d41fecc20..0fa0ff1f287 100644 --- a/service/location/api_op_GetMapStyleDescriptor.go +++ b/service/location/api_op_GetMapStyleDescriptor.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -98,6 +99,9 @@ func (c *Client) addOperationGetMapStyleDescriptorMiddlewares(stack *middleware. if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opGetMapStyleDescriptorMiddleware(stack); err != nil { + return err + } if err = addOpGetMapStyleDescriptorValidationMiddleware(stack); err != nil { return err } @@ -116,6 +120,33 @@ func (c *Client) addOperationGetMapStyleDescriptorMiddlewares(stack *middleware. return nil } +type endpointPrefix_opGetMapStyleDescriptorMiddleware struct { +} + +func (*endpointPrefix_opGetMapStyleDescriptorMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opGetMapStyleDescriptorMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "maps." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opGetMapStyleDescriptorMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opGetMapStyleDescriptorMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opGetMapStyleDescriptor(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_GetMapTile.go b/service/location/api_op_GetMapTile.go index 6af5dea50ff..7232d8dfa4b 100644 --- a/service/location/api_op_GetMapTile.go +++ b/service/location/api_op_GetMapTile.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -115,6 +116,9 @@ func (c *Client) addOperationGetMapTileMiddlewares(stack *middleware.Stack, opti if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opGetMapTileMiddleware(stack); err != nil { + return err + } if err = addOpGetMapTileValidationMiddleware(stack); err != nil { return err } @@ -133,6 +137,33 @@ func (c *Client) addOperationGetMapTileMiddlewares(stack *middleware.Stack, opti return nil } +type endpointPrefix_opGetMapTileMiddleware struct { +} + +func (*endpointPrefix_opGetMapTileMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opGetMapTileMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "maps." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opGetMapTileMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opGetMapTileMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opGetMapTile(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_ListDevicePositions.go b/service/location/api_op_ListDevicePositions.go index 74fadc59392..8ae0d26d0ce 100644 --- a/service/location/api_op_ListDevicePositions.go +++ b/service/location/api_op_ListDevicePositions.go @@ -110,6 +110,9 @@ func (c *Client) addOperationListDevicePositionsMiddlewares(stack *middleware.St if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opListDevicePositionsMiddleware(stack); err != nil { + return err + } if err = addOpListDevicePositionsValidationMiddleware(stack); err != nil { return err } @@ -128,6 +131,33 @@ func (c *Client) addOperationListDevicePositionsMiddlewares(stack *middleware.St return nil } +type endpointPrefix_opListDevicePositionsMiddleware struct { +} + +func (*endpointPrefix_opListDevicePositionsMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opListDevicePositionsMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "tracking." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opListDevicePositionsMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opListDevicePositionsMiddleware{}, `OperationSerializer`, middleware.After) +} + // ListDevicePositionsAPIClient is a client that implements the ListDevicePositions // operation. type ListDevicePositionsAPIClient interface { diff --git a/service/location/api_op_ListGeofenceCollections.go b/service/location/api_op_ListGeofenceCollections.go index 9996990afcf..403ee574c3b 100644 --- a/service/location/api_op_ListGeofenceCollections.go +++ b/service/location/api_op_ListGeofenceCollections.go @@ -103,6 +103,9 @@ func (c *Client) addOperationListGeofenceCollectionsMiddlewares(stack *middlewar if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opListGeofenceCollectionsMiddleware(stack); err != nil { + return err + } if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListGeofenceCollections(options.Region), middleware.Before); err != nil { return err } @@ -118,6 +121,33 @@ func (c *Client) addOperationListGeofenceCollectionsMiddlewares(stack *middlewar return nil } +type endpointPrefix_opListGeofenceCollectionsMiddleware struct { +} + +func (*endpointPrefix_opListGeofenceCollectionsMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opListGeofenceCollectionsMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "geofencing." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opListGeofenceCollectionsMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opListGeofenceCollectionsMiddleware{}, `OperationSerializer`, middleware.After) +} + // ListGeofenceCollectionsAPIClient is a client that implements the // ListGeofenceCollections operation. type ListGeofenceCollectionsAPIClient interface { diff --git a/service/location/api_op_ListGeofences.go b/service/location/api_op_ListGeofences.go index d1df3861611..c0b68baf503 100644 --- a/service/location/api_op_ListGeofences.go +++ b/service/location/api_op_ListGeofences.go @@ -104,6 +104,9 @@ func (c *Client) addOperationListGeofencesMiddlewares(stack *middleware.Stack, o if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opListGeofencesMiddleware(stack); err != nil { + return err + } if err = addOpListGeofencesValidationMiddleware(stack); err != nil { return err } @@ -122,6 +125,33 @@ func (c *Client) addOperationListGeofencesMiddlewares(stack *middleware.Stack, o return nil } +type endpointPrefix_opListGeofencesMiddleware struct { +} + +func (*endpointPrefix_opListGeofencesMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opListGeofencesMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "geofencing." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opListGeofencesMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opListGeofencesMiddleware{}, `OperationSerializer`, middleware.After) +} + // ListGeofencesAPIClient is a client that implements the ListGeofences operation. type ListGeofencesAPIClient interface { ListGeofences(context.Context, *ListGeofencesInput, ...func(*Options)) (*ListGeofencesOutput, error) diff --git a/service/location/api_op_ListMaps.go b/service/location/api_op_ListMaps.go index 077e00e4262..533c1685186 100644 --- a/service/location/api_op_ListMaps.go +++ b/service/location/api_op_ListMaps.go @@ -103,6 +103,9 @@ func (c *Client) addOperationListMapsMiddlewares(stack *middleware.Stack, option if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opListMapsMiddleware(stack); err != nil { + return err + } if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListMaps(options.Region), middleware.Before); err != nil { return err } @@ -118,6 +121,33 @@ func (c *Client) addOperationListMapsMiddlewares(stack *middleware.Stack, option return nil } +type endpointPrefix_opListMapsMiddleware struct { +} + +func (*endpointPrefix_opListMapsMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opListMapsMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "maps." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opListMapsMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opListMapsMiddleware{}, `OperationSerializer`, middleware.After) +} + // ListMapsAPIClient is a client that implements the ListMaps operation. type ListMapsAPIClient interface { ListMaps(context.Context, *ListMapsInput, ...func(*Options)) (*ListMapsOutput, error) diff --git a/service/location/api_op_ListPlaceIndexes.go b/service/location/api_op_ListPlaceIndexes.go index 69520943ce0..ccb2d1c21df 100644 --- a/service/location/api_op_ListPlaceIndexes.go +++ b/service/location/api_op_ListPlaceIndexes.go @@ -103,6 +103,9 @@ func (c *Client) addOperationListPlaceIndexesMiddlewares(stack *middleware.Stack if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opListPlaceIndexesMiddleware(stack); err != nil { + return err + } if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListPlaceIndexes(options.Region), middleware.Before); err != nil { return err } @@ -118,6 +121,33 @@ func (c *Client) addOperationListPlaceIndexesMiddlewares(stack *middleware.Stack return nil } +type endpointPrefix_opListPlaceIndexesMiddleware struct { +} + +func (*endpointPrefix_opListPlaceIndexesMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opListPlaceIndexesMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "places." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opListPlaceIndexesMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opListPlaceIndexesMiddleware{}, `OperationSerializer`, middleware.After) +} + // ListPlaceIndexesAPIClient is a client that implements the ListPlaceIndexes // operation. type ListPlaceIndexesAPIClient interface { diff --git a/service/location/api_op_ListRouteCalculators.go b/service/location/api_op_ListRouteCalculators.go index 29bbb81aa77..69c7c208f6d 100644 --- a/service/location/api_op_ListRouteCalculators.go +++ b/service/location/api_op_ListRouteCalculators.go @@ -103,6 +103,9 @@ func (c *Client) addOperationListRouteCalculatorsMiddlewares(stack *middleware.S if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opListRouteCalculatorsMiddleware(stack); err != nil { + return err + } if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListRouteCalculators(options.Region), middleware.Before); err != nil { return err } @@ -118,6 +121,33 @@ func (c *Client) addOperationListRouteCalculatorsMiddlewares(stack *middleware.S return nil } +type endpointPrefix_opListRouteCalculatorsMiddleware struct { +} + +func (*endpointPrefix_opListRouteCalculatorsMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opListRouteCalculatorsMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "routes." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opListRouteCalculatorsMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opListRouteCalculatorsMiddleware{}, `OperationSerializer`, middleware.After) +} + // ListRouteCalculatorsAPIClient is a client that implements the // ListRouteCalculators operation. type ListRouteCalculatorsAPIClient interface { diff --git a/service/location/api_op_ListTagsForResource.go b/service/location/api_op_ListTagsForResource.go index ef06fb47327..d820fc73c07 100644 --- a/service/location/api_op_ListTagsForResource.go +++ b/service/location/api_op_ListTagsForResource.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -101,6 +102,9 @@ func (c *Client) addOperationListTagsForResourceMiddlewares(stack *middleware.St if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opListTagsForResourceMiddleware(stack); err != nil { + return err + } if err = addOpListTagsForResourceValidationMiddleware(stack); err != nil { return err } @@ -119,6 +123,33 @@ func (c *Client) addOperationListTagsForResourceMiddlewares(stack *middleware.St return nil } +type endpointPrefix_opListTagsForResourceMiddleware struct { +} + +func (*endpointPrefix_opListTagsForResourceMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opListTagsForResourceMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "metadata." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opListTagsForResourceMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opListTagsForResourceMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opListTagsForResource(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_ListTrackerConsumers.go b/service/location/api_op_ListTrackerConsumers.go index 99360292eb3..34e21089d87 100644 --- a/service/location/api_op_ListTrackerConsumers.go +++ b/service/location/api_op_ListTrackerConsumers.go @@ -108,6 +108,9 @@ func (c *Client) addOperationListTrackerConsumersMiddlewares(stack *middleware.S if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opListTrackerConsumersMiddleware(stack); err != nil { + return err + } if err = addOpListTrackerConsumersValidationMiddleware(stack); err != nil { return err } @@ -126,6 +129,33 @@ func (c *Client) addOperationListTrackerConsumersMiddlewares(stack *middleware.S return nil } +type endpointPrefix_opListTrackerConsumersMiddleware struct { +} + +func (*endpointPrefix_opListTrackerConsumersMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opListTrackerConsumersMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "tracking." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opListTrackerConsumersMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opListTrackerConsumersMiddleware{}, `OperationSerializer`, middleware.After) +} + // ListTrackerConsumersAPIClient is a client that implements the // ListTrackerConsumers operation. type ListTrackerConsumersAPIClient interface { diff --git a/service/location/api_op_ListTrackers.go b/service/location/api_op_ListTrackers.go index 7d92f8983a3..c75aaf01c00 100644 --- a/service/location/api_op_ListTrackers.go +++ b/service/location/api_op_ListTrackers.go @@ -104,6 +104,9 @@ func (c *Client) addOperationListTrackersMiddlewares(stack *middleware.Stack, op if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opListTrackersMiddleware(stack); err != nil { + return err + } if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListTrackers(options.Region), middleware.Before); err != nil { return err } @@ -119,6 +122,33 @@ func (c *Client) addOperationListTrackersMiddlewares(stack *middleware.Stack, op return nil } +type endpointPrefix_opListTrackersMiddleware struct { +} + +func (*endpointPrefix_opListTrackersMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opListTrackersMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "tracking." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opListTrackersMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opListTrackersMiddleware{}, `OperationSerializer`, middleware.After) +} + // ListTrackersAPIClient is a client that implements the ListTrackers operation. type ListTrackersAPIClient interface { ListTrackers(context.Context, *ListTrackersInput, ...func(*Options)) (*ListTrackersOutput, error) diff --git a/service/location/api_op_PutGeofence.go b/service/location/api_op_PutGeofence.go index 8cc8d812397..b769e5df8a6 100644 --- a/service/location/api_op_PutGeofence.go +++ b/service/location/api_op_PutGeofence.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" @@ -124,6 +125,9 @@ func (c *Client) addOperationPutGeofenceMiddlewares(stack *middleware.Stack, opt if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opPutGeofenceMiddleware(stack); err != nil { + return err + } if err = addOpPutGeofenceValidationMiddleware(stack); err != nil { return err } @@ -142,6 +146,33 @@ func (c *Client) addOperationPutGeofenceMiddlewares(stack *middleware.Stack, opt return nil } +type endpointPrefix_opPutGeofenceMiddleware struct { +} + +func (*endpointPrefix_opPutGeofenceMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opPutGeofenceMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "geofencing." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opPutGeofenceMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opPutGeofenceMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opPutGeofence(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_SearchPlaceIndexForPosition.go b/service/location/api_op_SearchPlaceIndexForPosition.go index f9eaca75964..3a4dbbd3e85 100644 --- a/service/location/api_op_SearchPlaceIndexForPosition.go +++ b/service/location/api_op_SearchPlaceIndexForPosition.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" @@ -123,6 +124,9 @@ func (c *Client) addOperationSearchPlaceIndexForPositionMiddlewares(stack *middl if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opSearchPlaceIndexForPositionMiddleware(stack); err != nil { + return err + } if err = addOpSearchPlaceIndexForPositionValidationMiddleware(stack); err != nil { return err } @@ -141,6 +145,33 @@ func (c *Client) addOperationSearchPlaceIndexForPositionMiddlewares(stack *middl return nil } +type endpointPrefix_opSearchPlaceIndexForPositionMiddleware struct { +} + +func (*endpointPrefix_opSearchPlaceIndexForPositionMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opSearchPlaceIndexForPositionMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "places." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opSearchPlaceIndexForPositionMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opSearchPlaceIndexForPositionMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opSearchPlaceIndexForPosition(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_SearchPlaceIndexForText.go b/service/location/api_op_SearchPlaceIndexForText.go index bdb646132bb..847182d1f65 100644 --- a/service/location/api_op_SearchPlaceIndexForText.go +++ b/service/location/api_op_SearchPlaceIndexForText.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" @@ -157,6 +158,9 @@ func (c *Client) addOperationSearchPlaceIndexForTextMiddlewares(stack *middlewar if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opSearchPlaceIndexForTextMiddleware(stack); err != nil { + return err + } if err = addOpSearchPlaceIndexForTextValidationMiddleware(stack); err != nil { return err } @@ -175,6 +179,33 @@ func (c *Client) addOperationSearchPlaceIndexForTextMiddlewares(stack *middlewar return nil } +type endpointPrefix_opSearchPlaceIndexForTextMiddleware struct { +} + +func (*endpointPrefix_opSearchPlaceIndexForTextMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opSearchPlaceIndexForTextMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "places." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opSearchPlaceIndexForTextMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opSearchPlaceIndexForTextMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opSearchPlaceIndexForText(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_TagResource.go b/service/location/api_op_TagResource.go index 9c8a63f9caf..63daf697563 100644 --- a/service/location/api_op_TagResource.go +++ b/service/location/api_op_TagResource.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -123,6 +124,9 @@ func (c *Client) addOperationTagResourceMiddlewares(stack *middleware.Stack, opt if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opTagResourceMiddleware(stack); err != nil { + return err + } if err = addOpTagResourceValidationMiddleware(stack); err != nil { return err } @@ -141,6 +145,33 @@ func (c *Client) addOperationTagResourceMiddlewares(stack *middleware.Stack, opt return nil } +type endpointPrefix_opTagResourceMiddleware struct { +} + +func (*endpointPrefix_opTagResourceMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opTagResourceMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "metadata." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opTagResourceMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opTagResourceMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opTagResource(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_UntagResource.go b/service/location/api_op_UntagResource.go index 29af7a87d77..3ac6b4f62b0 100644 --- a/service/location/api_op_UntagResource.go +++ b/service/location/api_op_UntagResource.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -97,6 +98,9 @@ func (c *Client) addOperationUntagResourceMiddlewares(stack *middleware.Stack, o if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opUntagResourceMiddleware(stack); err != nil { + return err + } if err = addOpUntagResourceValidationMiddleware(stack); err != nil { return err } @@ -115,6 +119,33 @@ func (c *Client) addOperationUntagResourceMiddlewares(stack *middleware.Stack, o return nil } +type endpointPrefix_opUntagResourceMiddleware struct { +} + +func (*endpointPrefix_opUntagResourceMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opUntagResourceMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "metadata." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opUntagResourceMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opUntagResourceMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opUntagResource(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_UpdateGeofenceCollection.go b/service/location/api_op_UpdateGeofenceCollection.go index 6300b8de36a..d9f80104d33 100644 --- a/service/location/api_op_UpdateGeofenceCollection.go +++ b/service/location/api_op_UpdateGeofenceCollection.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" @@ -131,6 +132,9 @@ func (c *Client) addOperationUpdateGeofenceCollectionMiddlewares(stack *middlewa if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opUpdateGeofenceCollectionMiddleware(stack); err != nil { + return err + } if err = addOpUpdateGeofenceCollectionValidationMiddleware(stack); err != nil { return err } @@ -149,6 +153,33 @@ func (c *Client) addOperationUpdateGeofenceCollectionMiddlewares(stack *middlewa return nil } +type endpointPrefix_opUpdateGeofenceCollectionMiddleware struct { +} + +func (*endpointPrefix_opUpdateGeofenceCollectionMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opUpdateGeofenceCollectionMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "geofencing." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opUpdateGeofenceCollectionMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opUpdateGeofenceCollectionMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opUpdateGeofenceCollection(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_UpdateMap.go b/service/location/api_op_UpdateMap.go index 8e80558f5af..6af12bc7074 100644 --- a/service/location/api_op_UpdateMap.go +++ b/service/location/api_op_UpdateMap.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" @@ -120,6 +121,9 @@ func (c *Client) addOperationUpdateMapMiddlewares(stack *middleware.Stack, optio if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opUpdateMapMiddleware(stack); err != nil { + return err + } if err = addOpUpdateMapValidationMiddleware(stack); err != nil { return err } @@ -138,6 +142,33 @@ func (c *Client) addOperationUpdateMapMiddlewares(stack *middleware.Stack, optio return nil } +type endpointPrefix_opUpdateMapMiddleware struct { +} + +func (*endpointPrefix_opUpdateMapMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opUpdateMapMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "maps." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opUpdateMapMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opUpdateMapMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opUpdateMap(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_UpdatePlaceIndex.go b/service/location/api_op_UpdatePlaceIndex.go index 81b8c704425..d7596eafc80 100644 --- a/service/location/api_op_UpdatePlaceIndex.go +++ b/service/location/api_op_UpdatePlaceIndex.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" @@ -123,6 +124,9 @@ func (c *Client) addOperationUpdatePlaceIndexMiddlewares(stack *middleware.Stack if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opUpdatePlaceIndexMiddleware(stack); err != nil { + return err + } if err = addOpUpdatePlaceIndexValidationMiddleware(stack); err != nil { return err } @@ -141,6 +145,33 @@ func (c *Client) addOperationUpdatePlaceIndexMiddlewares(stack *middleware.Stack return nil } +type endpointPrefix_opUpdatePlaceIndexMiddleware struct { +} + +func (*endpointPrefix_opUpdatePlaceIndexMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opUpdatePlaceIndexMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "places." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opUpdatePlaceIndexMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opUpdatePlaceIndexMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opUpdatePlaceIndex(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_UpdateRouteCalculator.go b/service/location/api_op_UpdateRouteCalculator.go index eaf941ee0f9..027d4b1ded5 100644 --- a/service/location/api_op_UpdateRouteCalculator.go +++ b/service/location/api_op_UpdateRouteCalculator.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" @@ -120,6 +121,9 @@ func (c *Client) addOperationUpdateRouteCalculatorMiddlewares(stack *middleware. if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opUpdateRouteCalculatorMiddleware(stack); err != nil { + return err + } if err = addOpUpdateRouteCalculatorValidationMiddleware(stack); err != nil { return err } @@ -138,6 +142,33 @@ func (c *Client) addOperationUpdateRouteCalculatorMiddlewares(stack *middleware. return nil } +type endpointPrefix_opUpdateRouteCalculatorMiddleware struct { +} + +func (*endpointPrefix_opUpdateRouteCalculatorMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opUpdateRouteCalculatorMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "routes." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opUpdateRouteCalculatorMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opUpdateRouteCalculatorMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opUpdateRouteCalculator(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/location/api_op_UpdateTracker.go b/service/location/api_op_UpdateTracker.go index d3b51585910..2c7b2911947 100644 --- a/service/location/api_op_UpdateTracker.go +++ b/service/location/api_op_UpdateTracker.go @@ -4,6 +4,7 @@ package location import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/location/types" @@ -147,6 +148,9 @@ func (c *Client) addOperationUpdateTrackerMiddlewares(stack *middleware.Stack, o if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addEndpointPrefix_opUpdateTrackerMiddleware(stack); err != nil { + return err + } if err = addOpUpdateTrackerValidationMiddleware(stack); err != nil { return err } @@ -165,6 +169,33 @@ func (c *Client) addOperationUpdateTrackerMiddlewares(stack *middleware.Stack, o return nil } +type endpointPrefix_opUpdateTrackerMiddleware struct { +} + +func (*endpointPrefix_opUpdateTrackerMiddleware) ID() string { + return "EndpointHostPrefix" +} + +func (m *endpointPrefix_opUpdateTrackerMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if smithyhttp.GetHostnameImmutable(ctx) || smithyhttp.IsEndpointHostPrefixDisabled(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + req.URL.Host = "tracking." + req.URL.Host + + return next.HandleSerialize(ctx, in) +} +func addEndpointPrefix_opUpdateTrackerMiddleware(stack *middleware.Stack) error { + return stack.Serialize.Insert(&endpointPrefix_opUpdateTrackerMiddleware{}, `OperationSerializer`, middleware.After) +} + func newServiceMetadataMiddleware_opUpdateTracker(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/nimble/api_client.go b/service/nimble/api_client.go index 30eedbd1e38..cb17a1b7886 100644 --- a/service/nimble/api_client.go +++ b/service/nimble/api_client.go @@ -4,6 +4,7 @@ package nimble import ( "context" + cryptorand "crypto/rand" "github.com/aws/aws-sdk-go-v2/aws" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" @@ -14,6 +15,7 @@ import ( smithydocument "github.com/aws/smithy-go/document" "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" + smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" "net/http" "time" @@ -43,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveDefaultEndpointConfiguration(&options) + resolveIdempotencyTokenProvider(&options) + for _, fn := range optFns { fn(&options) } @@ -75,6 +79,10 @@ type Options struct { // Signature Version 4 (SigV4) Signer HTTPSignerV4 HTTPSignerV4 + // Provides idempotency tokens values that will be automatically populated into + // idempotent API operations. + IdempotencyTokenProvider IdempotencyTokenProvider + // The logger writer interface to write logging messages to. Logger logging.Logger @@ -240,6 +248,13 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func resolveIdempotencyTokenProvider(o *Options) { + if o.IdempotencyTokenProvider != nil { + return + } + o.IdempotencyTokenProvider = smithyrand.NewUUIDIdempotencyToken(cryptorand.Reader) +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, @@ -278,6 +293,11 @@ func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error { return nil } +// IdempotencyTokenProvider interface for providing idempotency token +type IdempotencyTokenProvider interface { + GetIdempotencyToken() (string, error) +} + func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error { return awsmiddleware.AddRequestIDRetrieverMiddleware(stack) } diff --git a/service/nimble/api_op_AcceptEulas.go b/service/nimble/api_op_AcceptEulas.go index cb4eebef600..d8807cb27e7 100644 --- a/service/nimble/api_op_AcceptEulas.go +++ b/service/nimble/api_op_AcceptEulas.go @@ -4,6 +4,7 @@ package nimble import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/nimble/types" @@ -103,6 +104,9 @@ func (c *Client) addOperationAcceptEulasMiddlewares(stack *middleware.Stack, opt if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opAcceptEulasMiddleware(stack, options); err != nil { + return err + } if err = addOpAcceptEulasValidationMiddleware(stack); err != nil { return err } @@ -121,6 +125,39 @@ func (c *Client) addOperationAcceptEulasMiddlewares(stack *middleware.Stack, opt return nil } +type idempotencyToken_initializeOpAcceptEulas struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpAcceptEulas) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpAcceptEulas) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*AcceptEulasInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *AcceptEulasInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opAcceptEulasMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpAcceptEulas{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opAcceptEulas(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/nimble/api_op_CreateLaunchProfile.go b/service/nimble/api_op_CreateLaunchProfile.go index d448256ce72..9fb4ff47355 100644 --- a/service/nimble/api_op_CreateLaunchProfile.go +++ b/service/nimble/api_op_CreateLaunchProfile.go @@ -4,6 +4,7 @@ package nimble import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/nimble/types" @@ -135,6 +136,9 @@ func (c *Client) addOperationCreateLaunchProfileMiddlewares(stack *middleware.St if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateLaunchProfileMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateLaunchProfileValidationMiddleware(stack); err != nil { return err } @@ -153,6 +157,39 @@ func (c *Client) addOperationCreateLaunchProfileMiddlewares(stack *middleware.St return nil } +type idempotencyToken_initializeOpCreateLaunchProfile struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateLaunchProfile) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateLaunchProfile) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateLaunchProfileInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateLaunchProfileInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateLaunchProfileMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateLaunchProfile{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateLaunchProfile(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/nimble/api_op_CreateStreamingImage.go b/service/nimble/api_op_CreateStreamingImage.go index af272f1778d..48d74d83fad 100644 --- a/service/nimble/api_op_CreateStreamingImage.go +++ b/service/nimble/api_op_CreateStreamingImage.go @@ -4,6 +4,7 @@ package nimble import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/nimble/types" @@ -117,6 +118,9 @@ func (c *Client) addOperationCreateStreamingImageMiddlewares(stack *middleware.S if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateStreamingImageMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateStreamingImageValidationMiddleware(stack); err != nil { return err } @@ -135,6 +139,39 @@ func (c *Client) addOperationCreateStreamingImageMiddlewares(stack *middleware.S return nil } +type idempotencyToken_initializeOpCreateStreamingImage struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateStreamingImage) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateStreamingImage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateStreamingImageInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateStreamingImageInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateStreamingImageMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateStreamingImage{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateStreamingImage(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/nimble/api_op_CreateStreamingSession.go b/service/nimble/api_op_CreateStreamingSession.go index c86146abf6c..a16ebe61679 100644 --- a/service/nimble/api_op_CreateStreamingSession.go +++ b/service/nimble/api_op_CreateStreamingSession.go @@ -4,6 +4,7 @@ package nimble import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/nimble/types" @@ -117,6 +118,9 @@ func (c *Client) addOperationCreateStreamingSessionMiddlewares(stack *middleware if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateStreamingSessionMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateStreamingSessionValidationMiddleware(stack); err != nil { return err } @@ -135,6 +139,39 @@ func (c *Client) addOperationCreateStreamingSessionMiddlewares(stack *middleware return nil } +type idempotencyToken_initializeOpCreateStreamingSession struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateStreamingSession) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateStreamingSession) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateStreamingSessionInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateStreamingSessionInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateStreamingSessionMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateStreamingSession{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateStreamingSession(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/nimble/api_op_CreateStreamingSessionStream.go b/service/nimble/api_op_CreateStreamingSessionStream.go index ddc455eb987..47a8c0cf420 100644 --- a/service/nimble/api_op_CreateStreamingSessionStream.go +++ b/service/nimble/api_op_CreateStreamingSessionStream.go @@ -4,6 +4,7 @@ package nimble import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/nimble/types" @@ -110,6 +111,9 @@ func (c *Client) addOperationCreateStreamingSessionStreamMiddlewares(stack *midd if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateStreamingSessionStreamMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateStreamingSessionStreamValidationMiddleware(stack); err != nil { return err } @@ -128,6 +132,39 @@ func (c *Client) addOperationCreateStreamingSessionStreamMiddlewares(stack *midd return nil } +type idempotencyToken_initializeOpCreateStreamingSessionStream struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateStreamingSessionStream) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateStreamingSessionStream) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateStreamingSessionStreamInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateStreamingSessionStreamInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateStreamingSessionStreamMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateStreamingSessionStream{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateStreamingSessionStream(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/nimble/api_op_CreateStudio.go b/service/nimble/api_op_CreateStudio.go index 302e35c3b89..2f3e1d216d9 100644 --- a/service/nimble/api_op_CreateStudio.go +++ b/service/nimble/api_op_CreateStudio.go @@ -4,6 +4,7 @@ package nimble import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/nimble/types" @@ -140,6 +141,9 @@ func (c *Client) addOperationCreateStudioMiddlewares(stack *middleware.Stack, op if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateStudioMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateStudioValidationMiddleware(stack); err != nil { return err } @@ -158,6 +162,39 @@ func (c *Client) addOperationCreateStudioMiddlewares(stack *middleware.Stack, op return nil } +type idempotencyToken_initializeOpCreateStudio struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateStudio) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateStudio) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateStudioInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateStudioInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateStudioMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateStudio{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateStudio(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/nimble/api_op_CreateStudioComponent.go b/service/nimble/api_op_CreateStudioComponent.go index c121e67a661..2c559ef3105 100644 --- a/service/nimble/api_op_CreateStudioComponent.go +++ b/service/nimble/api_op_CreateStudioComponent.go @@ -4,6 +4,7 @@ package nimble import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/nimble/types" @@ -132,6 +133,9 @@ func (c *Client) addOperationCreateStudioComponentMiddlewares(stack *middleware. if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateStudioComponentMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateStudioComponentValidationMiddleware(stack); err != nil { return err } @@ -150,6 +154,39 @@ func (c *Client) addOperationCreateStudioComponentMiddlewares(stack *middleware. return nil } +type idempotencyToken_initializeOpCreateStudioComponent struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateStudioComponent) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateStudioComponent) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateStudioComponentInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateStudioComponentInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateStudioComponentMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateStudioComponent{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateStudioComponent(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/nimble/api_op_DeleteLaunchProfile.go b/service/nimble/api_op_DeleteLaunchProfile.go index d689a163c26..bedfceb86b9 100644 --- a/service/nimble/api_op_DeleteLaunchProfile.go +++ b/service/nimble/api_op_DeleteLaunchProfile.go @@ -4,6 +4,7 @@ package nimble import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/nimble/types" @@ -104,6 +105,9 @@ func (c *Client) addOperationDeleteLaunchProfileMiddlewares(stack *middleware.St if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opDeleteLaunchProfileMiddleware(stack, options); err != nil { + return err + } if err = addOpDeleteLaunchProfileValidationMiddleware(stack); err != nil { return err } @@ -122,6 +126,39 @@ func (c *Client) addOperationDeleteLaunchProfileMiddlewares(stack *middleware.St return nil } +type idempotencyToken_initializeOpDeleteLaunchProfile struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpDeleteLaunchProfile) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpDeleteLaunchProfile) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*DeleteLaunchProfileInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *DeleteLaunchProfileInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opDeleteLaunchProfileMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpDeleteLaunchProfile{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opDeleteLaunchProfile(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/nimble/api_op_DeleteLaunchProfileMember.go b/service/nimble/api_op_DeleteLaunchProfileMember.go index ea834670719..5135acfd938 100644 --- a/service/nimble/api_op_DeleteLaunchProfileMember.go +++ b/service/nimble/api_op_DeleteLaunchProfileMember.go @@ -4,6 +4,7 @@ package nimble import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -104,6 +105,9 @@ func (c *Client) addOperationDeleteLaunchProfileMemberMiddlewares(stack *middlew if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opDeleteLaunchProfileMemberMiddleware(stack, options); err != nil { + return err + } if err = addOpDeleteLaunchProfileMemberValidationMiddleware(stack); err != nil { return err } @@ -122,6 +126,39 @@ func (c *Client) addOperationDeleteLaunchProfileMemberMiddlewares(stack *middlew return nil } +type idempotencyToken_initializeOpDeleteLaunchProfileMember struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpDeleteLaunchProfileMember) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpDeleteLaunchProfileMember) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*DeleteLaunchProfileMemberInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *DeleteLaunchProfileMemberInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opDeleteLaunchProfileMemberMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpDeleteLaunchProfileMember{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opDeleteLaunchProfileMember(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/nimble/api_op_DeleteStreamingImage.go b/service/nimble/api_op_DeleteStreamingImage.go index 40665e4c72a..7ed3c1e6d07 100644 --- a/service/nimble/api_op_DeleteStreamingImage.go +++ b/service/nimble/api_op_DeleteStreamingImage.go @@ -4,6 +4,7 @@ package nimble import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/nimble/types" @@ -104,6 +105,9 @@ func (c *Client) addOperationDeleteStreamingImageMiddlewares(stack *middleware.S if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opDeleteStreamingImageMiddleware(stack, options); err != nil { + return err + } if err = addOpDeleteStreamingImageValidationMiddleware(stack); err != nil { return err } @@ -122,6 +126,39 @@ func (c *Client) addOperationDeleteStreamingImageMiddlewares(stack *middleware.S return nil } +type idempotencyToken_initializeOpDeleteStreamingImage struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpDeleteStreamingImage) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpDeleteStreamingImage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*DeleteStreamingImageInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *DeleteStreamingImageInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opDeleteStreamingImageMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpDeleteStreamingImage{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opDeleteStreamingImage(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/nimble/api_op_DeleteStreamingSession.go b/service/nimble/api_op_DeleteStreamingSession.go index 029c0004b55..8ad7658ebb7 100644 --- a/service/nimble/api_op_DeleteStreamingSession.go +++ b/service/nimble/api_op_DeleteStreamingSession.go @@ -4,6 +4,7 @@ package nimble import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/nimble/types" @@ -107,6 +108,9 @@ func (c *Client) addOperationDeleteStreamingSessionMiddlewares(stack *middleware if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opDeleteStreamingSessionMiddleware(stack, options); err != nil { + return err + } if err = addOpDeleteStreamingSessionValidationMiddleware(stack); err != nil { return err } @@ -125,6 +129,39 @@ func (c *Client) addOperationDeleteStreamingSessionMiddlewares(stack *middleware return nil } +type idempotencyToken_initializeOpDeleteStreamingSession struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpDeleteStreamingSession) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpDeleteStreamingSession) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*DeleteStreamingSessionInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *DeleteStreamingSessionInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opDeleteStreamingSessionMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpDeleteStreamingSession{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opDeleteStreamingSession(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/nimble/api_op_DeleteStudio.go b/service/nimble/api_op_DeleteStudio.go index 43047af5e4f..4da3ae26c2b 100644 --- a/service/nimble/api_op_DeleteStudio.go +++ b/service/nimble/api_op_DeleteStudio.go @@ -4,6 +4,7 @@ package nimble import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/nimble/types" @@ -101,6 +102,9 @@ func (c *Client) addOperationDeleteStudioMiddlewares(stack *middleware.Stack, op if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opDeleteStudioMiddleware(stack, options); err != nil { + return err + } if err = addOpDeleteStudioValidationMiddleware(stack); err != nil { return err } @@ -119,6 +123,39 @@ func (c *Client) addOperationDeleteStudioMiddlewares(stack *middleware.Stack, op return nil } +type idempotencyToken_initializeOpDeleteStudio struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpDeleteStudio) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpDeleteStudio) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*DeleteStudioInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *DeleteStudioInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opDeleteStudioMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpDeleteStudio{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opDeleteStudio(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/nimble/api_op_DeleteStudioComponent.go b/service/nimble/api_op_DeleteStudioComponent.go index f5ebbbef84d..f2086f0c059 100644 --- a/service/nimble/api_op_DeleteStudioComponent.go +++ b/service/nimble/api_op_DeleteStudioComponent.go @@ -4,6 +4,7 @@ package nimble import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/nimble/types" @@ -104,6 +105,9 @@ func (c *Client) addOperationDeleteStudioComponentMiddlewares(stack *middleware. if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opDeleteStudioComponentMiddleware(stack, options); err != nil { + return err + } if err = addOpDeleteStudioComponentValidationMiddleware(stack); err != nil { return err } @@ -122,6 +126,39 @@ func (c *Client) addOperationDeleteStudioComponentMiddlewares(stack *middleware. return nil } +type idempotencyToken_initializeOpDeleteStudioComponent struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpDeleteStudioComponent) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpDeleteStudioComponent) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*DeleteStudioComponentInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *DeleteStudioComponentInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opDeleteStudioComponentMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpDeleteStudioComponent{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opDeleteStudioComponent(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/nimble/api_op_DeleteStudioMember.go b/service/nimble/api_op_DeleteStudioMember.go index bbd8e881ed8..a438f12fced 100644 --- a/service/nimble/api_op_DeleteStudioMember.go +++ b/service/nimble/api_op_DeleteStudioMember.go @@ -4,6 +4,7 @@ package nimble import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/smithy-go/middleware" @@ -99,6 +100,9 @@ func (c *Client) addOperationDeleteStudioMemberMiddlewares(stack *middleware.Sta if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opDeleteStudioMemberMiddleware(stack, options); err != nil { + return err + } if err = addOpDeleteStudioMemberValidationMiddleware(stack); err != nil { return err } @@ -117,6 +121,39 @@ func (c *Client) addOperationDeleteStudioMemberMiddlewares(stack *middleware.Sta return nil } +type idempotencyToken_initializeOpDeleteStudioMember struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpDeleteStudioMember) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpDeleteStudioMember) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*DeleteStudioMemberInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *DeleteStudioMemberInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opDeleteStudioMemberMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpDeleteStudioMember{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opDeleteStudioMember(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/nimble/api_op_PutLaunchProfileMembers.go b/service/nimble/api_op_PutLaunchProfileMembers.go index bdb934be597..d5b96b0df99 100644 --- a/service/nimble/api_op_PutLaunchProfileMembers.go +++ b/service/nimble/api_op_PutLaunchProfileMembers.go @@ -4,6 +4,7 @@ package nimble import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/nimble/types" @@ -110,6 +111,9 @@ func (c *Client) addOperationPutLaunchProfileMembersMiddlewares(stack *middlewar if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opPutLaunchProfileMembersMiddleware(stack, options); err != nil { + return err + } if err = addOpPutLaunchProfileMembersValidationMiddleware(stack); err != nil { return err } @@ -128,6 +132,39 @@ func (c *Client) addOperationPutLaunchProfileMembersMiddlewares(stack *middlewar return nil } +type idempotencyToken_initializeOpPutLaunchProfileMembers struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpPutLaunchProfileMembers) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpPutLaunchProfileMembers) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*PutLaunchProfileMembersInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *PutLaunchProfileMembersInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opPutLaunchProfileMembersMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpPutLaunchProfileMembers{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opPutLaunchProfileMembers(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/nimble/api_op_PutStudioMembers.go b/service/nimble/api_op_PutStudioMembers.go index bbfb1cd5de1..940011adc97 100644 --- a/service/nimble/api_op_PutStudioMembers.go +++ b/service/nimble/api_op_PutStudioMembers.go @@ -4,6 +4,7 @@ package nimble import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/nimble/types" @@ -106,6 +107,9 @@ func (c *Client) addOperationPutStudioMembersMiddlewares(stack *middleware.Stack if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opPutStudioMembersMiddleware(stack, options); err != nil { + return err + } if err = addOpPutStudioMembersValidationMiddleware(stack); err != nil { return err } @@ -124,6 +128,39 @@ func (c *Client) addOperationPutStudioMembersMiddlewares(stack *middleware.Stack return nil } +type idempotencyToken_initializeOpPutStudioMembers struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpPutStudioMembers) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpPutStudioMembers) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*PutStudioMembersInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *PutStudioMembersInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opPutStudioMembersMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpPutStudioMembers{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opPutStudioMembers(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/nimble/api_op_StartStreamingSession.go b/service/nimble/api_op_StartStreamingSession.go index 5ddb13b9c82..76635dfeb99 100644 --- a/service/nimble/api_op_StartStreamingSession.go +++ b/service/nimble/api_op_StartStreamingSession.go @@ -4,6 +4,7 @@ package nimble import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/nimble/types" @@ -106,6 +107,9 @@ func (c *Client) addOperationStartStreamingSessionMiddlewares(stack *middleware. if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opStartStreamingSessionMiddleware(stack, options); err != nil { + return err + } if err = addOpStartStreamingSessionValidationMiddleware(stack); err != nil { return err } @@ -124,6 +128,39 @@ func (c *Client) addOperationStartStreamingSessionMiddlewares(stack *middleware. return nil } +type idempotencyToken_initializeOpStartStreamingSession struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpStartStreamingSession) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpStartStreamingSession) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*StartStreamingSessionInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *StartStreamingSessionInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opStartStreamingSessionMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpStartStreamingSession{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opStartStreamingSession(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/nimble/api_op_StartStudioSSOConfigurationRepair.go b/service/nimble/api_op_StartStudioSSOConfigurationRepair.go index 22d94e3ba95..5b88dc0cc70 100644 --- a/service/nimble/api_op_StartStudioSSOConfigurationRepair.go +++ b/service/nimble/api_op_StartStudioSSOConfigurationRepair.go @@ -4,6 +4,7 @@ package nimble import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/nimble/types" @@ -108,6 +109,9 @@ func (c *Client) addOperationStartStudioSSOConfigurationRepairMiddlewares(stack if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opStartStudioSSOConfigurationRepairMiddleware(stack, options); err != nil { + return err + } if err = addOpStartStudioSSOConfigurationRepairValidationMiddleware(stack); err != nil { return err } @@ -126,6 +130,39 @@ func (c *Client) addOperationStartStudioSSOConfigurationRepairMiddlewares(stack return nil } +type idempotencyToken_initializeOpStartStudioSSOConfigurationRepair struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpStartStudioSSOConfigurationRepair) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpStartStudioSSOConfigurationRepair) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*StartStudioSSOConfigurationRepairInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *StartStudioSSOConfigurationRepairInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opStartStudioSSOConfigurationRepairMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpStartStudioSSOConfigurationRepair{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opStartStudioSSOConfigurationRepair(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/nimble/api_op_StopStreamingSession.go b/service/nimble/api_op_StopStreamingSession.go index f666a0b917d..69807b7c1ba 100644 --- a/service/nimble/api_op_StopStreamingSession.go +++ b/service/nimble/api_op_StopStreamingSession.go @@ -4,6 +4,7 @@ package nimble import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/nimble/types" @@ -106,6 +107,9 @@ func (c *Client) addOperationStopStreamingSessionMiddlewares(stack *middleware.S if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opStopStreamingSessionMiddleware(stack, options); err != nil { + return err + } if err = addOpStopStreamingSessionValidationMiddleware(stack); err != nil { return err } @@ -124,6 +128,39 @@ func (c *Client) addOperationStopStreamingSessionMiddlewares(stack *middleware.S return nil } +type idempotencyToken_initializeOpStopStreamingSession struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpStopStreamingSession) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpStopStreamingSession) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*StopStreamingSessionInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *StopStreamingSessionInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opStopStreamingSessionMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpStopStreamingSession{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opStopStreamingSession(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/nimble/api_op_UpdateLaunchProfile.go b/service/nimble/api_op_UpdateLaunchProfile.go index 35aa6399ddc..68a08e89fff 100644 --- a/service/nimble/api_op_UpdateLaunchProfile.go +++ b/service/nimble/api_op_UpdateLaunchProfile.go @@ -4,6 +4,7 @@ package nimble import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/nimble/types" @@ -122,6 +123,9 @@ func (c *Client) addOperationUpdateLaunchProfileMiddlewares(stack *middleware.St if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opUpdateLaunchProfileMiddleware(stack, options); err != nil { + return err + } if err = addOpUpdateLaunchProfileValidationMiddleware(stack); err != nil { return err } @@ -140,6 +144,39 @@ func (c *Client) addOperationUpdateLaunchProfileMiddlewares(stack *middleware.St return nil } +type idempotencyToken_initializeOpUpdateLaunchProfile struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpUpdateLaunchProfile) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpUpdateLaunchProfile) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*UpdateLaunchProfileInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *UpdateLaunchProfileInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opUpdateLaunchProfileMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpUpdateLaunchProfile{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opUpdateLaunchProfile(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/nimble/api_op_UpdateLaunchProfileMember.go b/service/nimble/api_op_UpdateLaunchProfileMember.go index e952dfc64a9..76c9fd062c9 100644 --- a/service/nimble/api_op_UpdateLaunchProfileMember.go +++ b/service/nimble/api_op_UpdateLaunchProfileMember.go @@ -4,6 +4,7 @@ package nimble import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/nimble/types" @@ -114,6 +115,9 @@ func (c *Client) addOperationUpdateLaunchProfileMemberMiddlewares(stack *middlew if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opUpdateLaunchProfileMemberMiddleware(stack, options); err != nil { + return err + } if err = addOpUpdateLaunchProfileMemberValidationMiddleware(stack); err != nil { return err } @@ -132,6 +136,39 @@ func (c *Client) addOperationUpdateLaunchProfileMemberMiddlewares(stack *middlew return nil } +type idempotencyToken_initializeOpUpdateLaunchProfileMember struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpUpdateLaunchProfileMember) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpUpdateLaunchProfileMember) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*UpdateLaunchProfileMemberInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *UpdateLaunchProfileMemberInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opUpdateLaunchProfileMemberMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpUpdateLaunchProfileMember{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opUpdateLaunchProfileMember(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/nimble/api_op_UpdateStreamingImage.go b/service/nimble/api_op_UpdateStreamingImage.go index 81788b07120..9ea01ce7dda 100644 --- a/service/nimble/api_op_UpdateStreamingImage.go +++ b/service/nimble/api_op_UpdateStreamingImage.go @@ -4,6 +4,7 @@ package nimble import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/nimble/types" @@ -111,6 +112,9 @@ func (c *Client) addOperationUpdateStreamingImageMiddlewares(stack *middleware.S if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opUpdateStreamingImageMiddleware(stack, options); err != nil { + return err + } if err = addOpUpdateStreamingImageValidationMiddleware(stack); err != nil { return err } @@ -129,6 +133,39 @@ func (c *Client) addOperationUpdateStreamingImageMiddlewares(stack *middleware.S return nil } +type idempotencyToken_initializeOpUpdateStreamingImage struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpUpdateStreamingImage) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpUpdateStreamingImage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*UpdateStreamingImageInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *UpdateStreamingImageInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opUpdateStreamingImageMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpUpdateStreamingImage{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opUpdateStreamingImage(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/nimble/api_op_UpdateStudio.go b/service/nimble/api_op_UpdateStudio.go index 07c6649d5f7..4261534f04e 100644 --- a/service/nimble/api_op_UpdateStudio.go +++ b/service/nimble/api_op_UpdateStudio.go @@ -4,6 +4,7 @@ package nimble import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/nimble/types" @@ -114,6 +115,9 @@ func (c *Client) addOperationUpdateStudioMiddlewares(stack *middleware.Stack, op if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opUpdateStudioMiddleware(stack, options); err != nil { + return err + } if err = addOpUpdateStudioValidationMiddleware(stack); err != nil { return err } @@ -132,6 +136,39 @@ func (c *Client) addOperationUpdateStudioMiddlewares(stack *middleware.Stack, op return nil } +type idempotencyToken_initializeOpUpdateStudio struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpUpdateStudio) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpUpdateStudio) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*UpdateStudioInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *UpdateStudioInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opUpdateStudioMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpUpdateStudio{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opUpdateStudio(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/nimble/api_op_UpdateStudioComponent.go b/service/nimble/api_op_UpdateStudioComponent.go index 424568ae411..5189851668d 100644 --- a/service/nimble/api_op_UpdateStudioComponent.go +++ b/service/nimble/api_op_UpdateStudioComponent.go @@ -4,6 +4,7 @@ package nimble import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/nimble/types" @@ -129,6 +130,9 @@ func (c *Client) addOperationUpdateStudioComponentMiddlewares(stack *middleware. if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opUpdateStudioComponentMiddleware(stack, options); err != nil { + return err + } if err = addOpUpdateStudioComponentValidationMiddleware(stack); err != nil { return err } @@ -147,6 +151,39 @@ func (c *Client) addOperationUpdateStudioComponentMiddlewares(stack *middleware. return nil } +type idempotencyToken_initializeOpUpdateStudioComponent struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpUpdateStudioComponent) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpUpdateStudioComponent) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*UpdateStudioComponentInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *UpdateStudioComponentInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opUpdateStudioComponentMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpUpdateStudioComponent{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opUpdateStudioComponent(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/proton/api_client.go b/service/proton/api_client.go index 7a1f32cbd06..6d958cc5137 100644 --- a/service/proton/api_client.go +++ b/service/proton/api_client.go @@ -4,6 +4,7 @@ package proton import ( "context" + cryptorand "crypto/rand" "github.com/aws/aws-sdk-go-v2/aws" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" @@ -14,6 +15,7 @@ import ( smithydocument "github.com/aws/smithy-go/document" "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" + smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" "net/http" "time" @@ -43,6 +45,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveDefaultEndpointConfiguration(&options) + resolveIdempotencyTokenProvider(&options) + for _, fn := range optFns { fn(&options) } @@ -75,6 +79,10 @@ type Options struct { // Signature Version 4 (SigV4) Signer HTTPSignerV4 HTTPSignerV4 + // Provides idempotency tokens values that will be automatically populated into + // idempotent API operations. + IdempotencyTokenProvider IdempotencyTokenProvider + // The logger writer interface to write logging messages to. Logger logging.Logger @@ -240,6 +248,13 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func resolveIdempotencyTokenProvider(o *Options) { + if o.IdempotencyTokenProvider != nil { + return + } + o.IdempotencyTokenProvider = smithyrand.NewUUIDIdempotencyToken(cryptorand.Reader) +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, @@ -278,6 +293,11 @@ func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error { return nil } +// IdempotencyTokenProvider interface for providing idempotency token +type IdempotencyTokenProvider interface { + GetIdempotencyToken() (string, error) +} + func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error { return awsmiddleware.AddRequestIDRetrieverMiddleware(stack) } diff --git a/service/proton/api_op_CreateEnvironmentAccountConnection.go b/service/proton/api_op_CreateEnvironmentAccountConnection.go index e9f7d142dce..663822cd002 100644 --- a/service/proton/api_op_CreateEnvironmentAccountConnection.go +++ b/service/proton/api_op_CreateEnvironmentAccountConnection.go @@ -4,6 +4,7 @@ package proton import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/proton/types" @@ -130,6 +131,9 @@ func (c *Client) addOperationCreateEnvironmentAccountConnectionMiddlewares(stack if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateEnvironmentAccountConnectionMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateEnvironmentAccountConnectionValidationMiddleware(stack); err != nil { return err } @@ -148,6 +152,39 @@ func (c *Client) addOperationCreateEnvironmentAccountConnectionMiddlewares(stack return nil } +type idempotencyToken_initializeOpCreateEnvironmentAccountConnection struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateEnvironmentAccountConnection) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateEnvironmentAccountConnection) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateEnvironmentAccountConnectionInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateEnvironmentAccountConnectionInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateEnvironmentAccountConnectionMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateEnvironmentAccountConnection{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateEnvironmentAccountConnection(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/proton/api_op_CreateEnvironmentTemplateVersion.go b/service/proton/api_op_CreateEnvironmentTemplateVersion.go index 3a1e7a5b078..14939ae96ec 100644 --- a/service/proton/api_op_CreateEnvironmentTemplateVersion.go +++ b/service/proton/api_op_CreateEnvironmentTemplateVersion.go @@ -4,6 +4,7 @@ package proton import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/proton/types" @@ -119,6 +120,9 @@ func (c *Client) addOperationCreateEnvironmentTemplateVersionMiddlewares(stack * if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateEnvironmentTemplateVersionMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateEnvironmentTemplateVersionValidationMiddleware(stack); err != nil { return err } @@ -137,6 +141,39 @@ func (c *Client) addOperationCreateEnvironmentTemplateVersionMiddlewares(stack * return nil } +type idempotencyToken_initializeOpCreateEnvironmentTemplateVersion struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateEnvironmentTemplateVersion) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateEnvironmentTemplateVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateEnvironmentTemplateVersionInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateEnvironmentTemplateVersionInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateEnvironmentTemplateVersionMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateEnvironmentTemplateVersion{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateEnvironmentTemplateVersion(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/proton/api_op_CreateServiceTemplateVersion.go b/service/proton/api_op_CreateServiceTemplateVersion.go index 46d085302ec..de59e896f1f 100644 --- a/service/proton/api_op_CreateServiceTemplateVersion.go +++ b/service/proton/api_op_CreateServiceTemplateVersion.go @@ -4,6 +4,7 @@ package proton import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/proton/types" @@ -125,6 +126,9 @@ func (c *Client) addOperationCreateServiceTemplateVersionMiddlewares(stack *midd if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateServiceTemplateVersionMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateServiceTemplateVersionValidationMiddleware(stack); err != nil { return err } @@ -143,6 +147,39 @@ func (c *Client) addOperationCreateServiceTemplateVersionMiddlewares(stack *midd return nil } +type idempotencyToken_initializeOpCreateServiceTemplateVersion struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateServiceTemplateVersion) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateServiceTemplateVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateServiceTemplateVersionInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateServiceTemplateVersionInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateServiceTemplateVersionMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateServiceTemplateVersion{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateServiceTemplateVersion(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/snowdevicemanagement/api_client.go b/service/snowdevicemanagement/api_client.go index 00f1b294199..845af8419d6 100644 --- a/service/snowdevicemanagement/api_client.go +++ b/service/snowdevicemanagement/api_client.go @@ -4,6 +4,7 @@ package snowdevicemanagement import ( "context" + cryptorand "crypto/rand" "github.com/aws/aws-sdk-go-v2/aws" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" @@ -14,6 +15,7 @@ import ( smithydocument "github.com/aws/smithy-go/document" "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" + smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" "net/http" "time" @@ -44,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveDefaultEndpointConfiguration(&options) + resolveIdempotencyTokenProvider(&options) + for _, fn := range optFns { fn(&options) } @@ -76,6 +80,10 @@ type Options struct { // Signature Version 4 (SigV4) Signer HTTPSignerV4 HTTPSignerV4 + // Provides idempotency tokens values that will be automatically populated into + // idempotent API operations. + IdempotencyTokenProvider IdempotencyTokenProvider + // The logger writer interface to write logging messages to. Logger logging.Logger @@ -241,6 +249,13 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func resolveIdempotencyTokenProvider(o *Options) { + if o.IdempotencyTokenProvider != nil { + return + } + o.IdempotencyTokenProvider = smithyrand.NewUUIDIdempotencyToken(cryptorand.Reader) +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, @@ -279,6 +294,11 @@ func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error { return nil } +// IdempotencyTokenProvider interface for providing idempotency token +type IdempotencyTokenProvider interface { + GetIdempotencyToken() (string, error) +} + func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error { return awsmiddleware.AddRequestIDRetrieverMiddleware(stack) } diff --git a/service/snowdevicemanagement/api_op_CreateTask.go b/service/snowdevicemanagement/api_op_CreateTask.go index 57dbf5f5c45..ac33e1367f0 100644 --- a/service/snowdevicemanagement/api_op_CreateTask.go +++ b/service/snowdevicemanagement/api_op_CreateTask.go @@ -4,6 +4,7 @@ package snowdevicemanagement import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/snowdevicemanagement/types" @@ -111,6 +112,9 @@ func (c *Client) addOperationCreateTaskMiddlewares(stack *middleware.Stack, opti if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateTaskMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateTaskValidationMiddleware(stack); err != nil { return err } @@ -129,6 +133,39 @@ func (c *Client) addOperationCreateTaskMiddlewares(stack *middleware.Stack, opti return nil } +type idempotencyToken_initializeOpCreateTask struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateTask) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateTaskInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateTaskInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateTaskMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateTask{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateTask(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/wisdom/api_client.go b/service/wisdom/api_client.go index 395920f1161..dbb1b4a9fac 100644 --- a/service/wisdom/api_client.go +++ b/service/wisdom/api_client.go @@ -4,6 +4,7 @@ package wisdom import ( "context" + cryptorand "crypto/rand" "github.com/aws/aws-sdk-go-v2/aws" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/retry" @@ -14,6 +15,7 @@ import ( smithydocument "github.com/aws/smithy-go/document" "github.com/aws/smithy-go/logging" "github.com/aws/smithy-go/middleware" + smithyrand "github.com/aws/smithy-go/rand" smithyhttp "github.com/aws/smithy-go/transport/http" "net/http" "time" @@ -44,6 +46,8 @@ func New(options Options, optFns ...func(*Options)) *Client { resolveDefaultEndpointConfiguration(&options) + resolveIdempotencyTokenProvider(&options) + for _, fn := range optFns { fn(&options) } @@ -76,6 +80,10 @@ type Options struct { // Signature Version 4 (SigV4) Signer HTTPSignerV4 HTTPSignerV4 + // Provides idempotency tokens values that will be automatically populated into + // idempotent API operations. + IdempotencyTokenProvider IdempotencyTokenProvider + // The logger writer interface to write logging messages to. Logger logging.Logger @@ -241,6 +249,13 @@ func newDefaultV4Signer(o Options) *v4.Signer { }) } +func resolveIdempotencyTokenProvider(o *Options) { + if o.IdempotencyTokenProvider != nil { + return + } + o.IdempotencyTokenProvider = smithyrand.NewUUIDIdempotencyToken(cryptorand.Reader) +} + func addRetryMiddlewares(stack *middleware.Stack, o Options) error { mo := retry.AddRetryMiddlewaresOptions{ Retryer: o.Retryer, @@ -279,6 +294,11 @@ func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error { return nil } +// IdempotencyTokenProvider interface for providing idempotency token +type IdempotencyTokenProvider interface { + GetIdempotencyToken() (string, error) +} + func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error { return awsmiddleware.AddRequestIDRetrieverMiddleware(stack) } diff --git a/service/wisdom/api_op_CreateAssistant.go b/service/wisdom/api_op_CreateAssistant.go index 904445b2872..db720ae4b4e 100644 --- a/service/wisdom/api_op_CreateAssistant.go +++ b/service/wisdom/api_op_CreateAssistant.go @@ -4,6 +4,7 @@ package wisdom import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/wisdom/types" @@ -111,6 +112,9 @@ func (c *Client) addOperationCreateAssistantMiddlewares(stack *middleware.Stack, if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateAssistantMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateAssistantValidationMiddleware(stack); err != nil { return err } @@ -129,6 +133,39 @@ func (c *Client) addOperationCreateAssistantMiddlewares(stack *middleware.Stack, return nil } +type idempotencyToken_initializeOpCreateAssistant struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateAssistant) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateAssistant) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateAssistantInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateAssistantInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateAssistantMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateAssistant{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateAssistant(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/wisdom/api_op_CreateAssistantAssociation.go b/service/wisdom/api_op_CreateAssistantAssociation.go index a309193821a..3d0783c38b3 100644 --- a/service/wisdom/api_op_CreateAssistantAssociation.go +++ b/service/wisdom/api_op_CreateAssistantAssociation.go @@ -4,6 +4,7 @@ package wisdom import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/wisdom/types" @@ -113,6 +114,9 @@ func (c *Client) addOperationCreateAssistantAssociationMiddlewares(stack *middle if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateAssistantAssociationMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateAssistantAssociationValidationMiddleware(stack); err != nil { return err } @@ -131,6 +135,39 @@ func (c *Client) addOperationCreateAssistantAssociationMiddlewares(stack *middle return nil } +type idempotencyToken_initializeOpCreateAssistantAssociation struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateAssistantAssociation) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateAssistantAssociation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateAssistantAssociationInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateAssistantAssociationInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateAssistantAssociationMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateAssistantAssociation{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateAssistantAssociation(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/wisdom/api_op_CreateContent.go b/service/wisdom/api_op_CreateContent.go index 8e2368e1332..4e92d6434fa 100644 --- a/service/wisdom/api_op_CreateContent.go +++ b/service/wisdom/api_op_CreateContent.go @@ -4,6 +4,7 @@ package wisdom import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/wisdom/types" @@ -131,6 +132,9 @@ func (c *Client) addOperationCreateContentMiddlewares(stack *middleware.Stack, o if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateContentMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateContentValidationMiddleware(stack); err != nil { return err } @@ -149,6 +153,39 @@ func (c *Client) addOperationCreateContentMiddlewares(stack *middleware.Stack, o return nil } +type idempotencyToken_initializeOpCreateContent struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateContent) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateContent) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateContentInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateContentInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateContentMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateContent{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateContent(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/wisdom/api_op_CreateKnowledgeBase.go b/service/wisdom/api_op_CreateKnowledgeBase.go index 1ea3d10fa06..83f32f197d8 100644 --- a/service/wisdom/api_op_CreateKnowledgeBase.go +++ b/service/wisdom/api_op_CreateKnowledgeBase.go @@ -4,6 +4,7 @@ package wisdom import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/wisdom/types" @@ -142,6 +143,9 @@ func (c *Client) addOperationCreateKnowledgeBaseMiddlewares(stack *middleware.St if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateKnowledgeBaseMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateKnowledgeBaseValidationMiddleware(stack); err != nil { return err } @@ -160,6 +164,39 @@ func (c *Client) addOperationCreateKnowledgeBaseMiddlewares(stack *middleware.St return nil } +type idempotencyToken_initializeOpCreateKnowledgeBase struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateKnowledgeBase) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateKnowledgeBase) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateKnowledgeBaseInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateKnowledgeBaseInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateKnowledgeBaseMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateKnowledgeBase{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateKnowledgeBase(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region, diff --git a/service/wisdom/api_op_CreateSession.go b/service/wisdom/api_op_CreateSession.go index bcaf0b20019..839bc9f0b6d 100644 --- a/service/wisdom/api_op_CreateSession.go +++ b/service/wisdom/api_op_CreateSession.go @@ -4,6 +4,7 @@ package wisdom import ( "context" + "fmt" awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/wisdom/types" @@ -111,6 +112,9 @@ func (c *Client) addOperationCreateSessionMiddlewares(stack *middleware.Stack, o if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { return err } + if err = addIdempotencyToken_opCreateSessionMiddleware(stack, options); err != nil { + return err + } if err = addOpCreateSessionValidationMiddleware(stack); err != nil { return err } @@ -129,6 +133,39 @@ func (c *Client) addOperationCreateSessionMiddlewares(stack *middleware.Stack, o return nil } +type idempotencyToken_initializeOpCreateSession struct { + tokenProvider IdempotencyTokenProvider +} + +func (*idempotencyToken_initializeOpCreateSession) ID() string { + return "OperationIdempotencyTokenAutoFill" +} + +func (m *idempotencyToken_initializeOpCreateSession) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + if m.tokenProvider == nil { + return next.HandleInitialize(ctx, in) + } + + input, ok := in.Parameters.(*CreateSessionInput) + if !ok { + return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateSessionInput ") + } + + if input.ClientToken == nil { + t, err := m.tokenProvider.GetIdempotencyToken() + if err != nil { + return out, metadata, err + } + input.ClientToken = &t + } + return next.HandleInitialize(ctx, in) +} +func addIdempotencyToken_opCreateSessionMiddleware(stack *middleware.Stack, cfg Options) error { + return stack.Initialize.Add(&idempotencyToken_initializeOpCreateSession{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before) +} + func newServiceMetadataMiddleware_opCreateSession(region string) *awsmiddleware.RegisterServiceMetadata { return &awsmiddleware.RegisterServiceMetadata{ Region: region,