Refactor Middlewares and Codegen (#861)

aws/middleware/metadata.go

@@ -16,7 +16,7 @@ type RegisterServiceMetadata struct {
 }
 
 // ID returns the middleware identifier.
-func (s RegisterServiceMetadata) ID() string {
+func (s *RegisterServiceMetadata) ID() string {
 	return "RegisterServiceMetadata"
 }
 

aws/middleware/middleware.go

@@ -13,17 +13,17 @@ import (
 	smithyhttp "github.com/awslabs/smithy-go/transport/http"
 )
 
-// RequestInvocationIDMiddleware is a Smithy BuildMiddleware that will generate a unique ID for logical API operation
+// ClientRequestID is a Smithy BuildMiddleware that will generate a unique ID for logical API operation
 // invocation.
-type RequestInvocationIDMiddleware struct{}
+type ClientRequestID struct{}
 
-// ID the identifier for the RequestInvocationIDMiddleware
-func (r RequestInvocationIDMiddleware) ID() string {
-	return "RequestInvocationIDMiddleware"
+// ID the identifier for the ClientRequestID
+func (r *ClientRequestID) ID() string {
+	return "ClientRequestID"
 }
 
 // HandleBuild attaches a unique operation invocation id for the operation to the request
-func (r RequestInvocationIDMiddleware) HandleBuild(ctx context.Context, in middleware.BuildInput, next middleware.BuildHandler) (
+func (r ClientRequestID) HandleBuild(ctx context.Context, in middleware.BuildInput, next middleware.BuildHandler) (
 	out middleware.BuildOutput, metadata middleware.Metadata, err error,
 ) {
 	req, ok := in.Request.(*smithyhttp.Request)
@@ -42,17 +42,17 @@ func (r RequestInvocationIDMiddleware) HandleBuild(ctx context.Context, in middl
 	return next.HandleBuild(ctx, in)
 }
 
-// AttemptClockSkewMiddleware calculates the clock skew of the SDK client
+// AttemptClockSkew calculates the clock skew of the SDK client
 // TODO: Could be a better name, since this calculates more then skew
-type AttemptClockSkewMiddleware struct{}
+type AttemptClockSkew struct{}
 
 // ID is the middleware identifier
-func (a AttemptClockSkewMiddleware) ID() string {
-	return "AttemptClockSkewMiddleware"
+func (a *AttemptClockSkew) ID() string {
+	return "AttemptClockSkew"
 }
 
 // HandleDeserialize calculates response metadata and clock skew
-func (a AttemptClockSkewMiddleware) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (a AttemptClockSkew) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
 ) {
 	respMeta := ResponseMetadata{}
@@ -103,14 +103,12 @@ func setResponseMetadata(metadata *middleware.Metadata, responseMetadata Respons
 	metadata.Set(responseMetadataKey{}, responseMetadata)
 }
 
-// AddRequestInvocationIDMiddleware adds RequestInvocationIDMiddleware to the middleware stack
-func AddRequestInvocationIDMiddleware(stack *middleware.Stack) {
-	requestInvocationIDMiddleware := RequestInvocationIDMiddleware{}
-	stack.Build.Add(requestInvocationIDMiddleware, middleware.After)
+// AddClientRequestIDMiddleware adds ClientRequestID to the middleware stack
+func AddClientRequestIDMiddleware(stack *middleware.Stack) error {
+	return stack.Build.Add(&ClientRequestID{}, middleware.After)
 }
 
-// AddAttemptClockSkewMiddleware adds AttemptClockSkewMiddleware to the middleware stack
-func AddAttemptClockSkewMiddleware(stack *middleware.Stack) {
-	attemptClockSkeyMiddleware := AttemptClockSkewMiddleware{}
-	stack.Deserialize.Add(attemptClockSkeyMiddleware, middleware.After)
+// AddAttemptClockSkewMiddleware adds AttemptClockSkew to the middleware stack
+func AddAttemptClockSkewMiddleware(stack *middleware.Stack) error {
+	return stack.Deserialize.Add(&AttemptClockSkew{}, middleware.After)
 }

aws/middleware/middleware_test.go

@@ -16,14 +16,14 @@ import (
 	smithyhttp "github.com/awslabs/smithy-go/transport/http"
 )
 
-func TestRequestInvocationIDMiddleware(t *testing.T) {
+func TestClientRequestID(t *testing.T) {
 	oReader := rand.Reader
 	defer func() {
 		rand.Reader = oReader
 	}()
 	rand.Reader = bytes.NewReader(make([]byte, 16))
 
-	mid := middleware.RequestInvocationIDMiddleware{}
+	mid := middleware.ClientRequestID{}
 
 	in := smithymiddleware.BuildInput{Request: &smithyhttp.Request{Request: &http.Request{Header: make(http.Header)}}}
 	ctx := context.Background()
@@ -163,7 +163,7 @@ func TestAttemptClockSkewHandler(t *testing.T) {
 				}()
 				sdk.NowTime = c.ResponseAt
 			}
-			mw := middleware.AttemptClockSkewMiddleware{}
+			mw := middleware.AttemptClockSkew{}
 			_, metadata, err := mw.HandleDeserialize(context.Background(), smithymiddleware.DeserializeInput{}, c.Next)
 			if err != nil {
 				t.Errorf("expect no error, got %v", err)

aws/middleware/request_id.go

@@ -4,23 +4,22 @@ import (
 	"github.com/awslabs/smithy-go/middleware"
 )
 
-// requestID is used to retrieve request id from response metadata
-type requestID struct {
-}
+// requestIDKey is used to retrieve request id from response metadata
+type requestIDKey struct{}
 
 // SetRequestIDMetadata sets the provided request id over middleware metadata
 func SetRequestIDMetadata(metadata *middleware.Metadata, id string) {
-	metadata.Set(requestID{}, id)
+	metadata.Set(requestIDKey{}, id)
 }
 
 // GetRequestIDMetadata retrieves the request id from middleware metadata
 // returns string and bool indicating value of request id, whether request id was set.
 func GetRequestIDMetadata(metadata middleware.Metadata) (string, bool) {
-	if !metadata.Has(requestID{}) {
+	if !metadata.Has(requestIDKey{}) {
 		return "", false
 	}
 
-	v, ok := metadata.Get(requestID{}).(string)
+	v, ok := metadata.Get(requestIDKey{}).(string)
 	if !ok {
 		return "", true
 	}

aws/middleware/request_id_retriever.go

@@ -8,21 +8,21 @@ import (
 )
 
 // AddRequestIDRetrieverMiddleware adds request id retriever middleware
-func AddRequestIDRetrieverMiddleware(stack *middleware.Stack) {
+func AddRequestIDRetrieverMiddleware(stack *middleware.Stack) error {
 	// add error wrapper middleware before operation deserializers so that it can wrap the error response
 	// returned by operation deserializers
-	stack.Deserialize.Insert(&requestIDRetrieverMiddleware{}, "OperationDeserializer", middleware.Before)
+	return stack.Deserialize.Insert(&requestIDRetriever{}, "OperationDeserializer", middleware.Before)
 }
 
-type requestIDRetrieverMiddleware struct {
+type requestIDRetriever struct {
 }
 
 // ID returns the middleware identifier
-func (m *requestIDRetrieverMiddleware) ID() string {
-	return "AWSRequestIDRetrieverMiddleware"
+func (m *requestIDRetriever) ID() string {
+	return "RequestIDRetriever"
 }
 
-func (m *requestIDRetrieverMiddleware) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *requestIDRetriever) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
 ) {
 	out, metadata, err = next.HandleDeserialize(ctx, in)

aws/middleware/user_agent.go

@@ -90,7 +90,7 @@ func (u *requestUserAgent) AddKeyValue(key, value string) {
 
 // ID the name of the middleware.
 func (u *requestUserAgent) ID() string {
-	return "requestUserAgent"
+	return "UserAgent"
 }
 
 // HandleBuild adds or appends the constructed user agent to the request.

aws/protocol/query/middleware.go

@@ -13,15 +13,14 @@ import (
 // operation serializer that will convert the query request body to a GET
 // operation with the query message in the HTTP request querystring.
 func AddAsGetRequestMiddleware(stack *middleware.Stack) error {
-	return stack.Serialize.Insert(&asGetRequestMiddleware{},
-		"OperationSerializer", middleware.After)
+	return stack.Serialize.Insert(&asGetRequest{}, "OperationSerializer", middleware.After)
 }
 
-type asGetRequestMiddleware struct{}
+type asGetRequest struct{}
 
-func (*asGetRequestMiddleware) ID() string { return "Query:AsGetRequestMiddleware" }
+func (*asGetRequest) ID() string { return "Query:AsGetRequest" }
 
-func (m *asGetRequestMiddleware) HandleSerialize(
+func (m *asGetRequest) HandleSerialize(
 	ctx context.Context, input middleware.SerializeInput, next middleware.SerializeHandler,
 ) (
 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,

aws/protocol/query/middleware_test.go

@@ -101,7 +101,7 @@ func TestAsGetRequestMiddleware(t *testing.T) {
 
 	for name, c := range cases {
 		t.Run(name, func(t *testing.T) {
-			m := &asGetRequestMiddleware{}
+			m := &asGetRequest{}
 
 			_, _, err := m.HandleSerialize(context.Background(), middleware.SerializeInput{
 				Parameters: struct{}{},

aws/retry/middleware.go

@@ -27,25 +27,25 @@ type retryMetadata struct {
 
 type retryMetadataKey struct{}
 
-// AttemptMiddleware is a Smithy FinalizeMiddleware that handles retry attempts using the provided
+// Attempt is a Smithy FinalizeMiddleware that handles retry attempts using the provided
 // Retryer implementation
-type AttemptMiddleware struct {
+type Attempt struct {
 	retryer       Retryer
 	requestCloner RequestCloner
 }
 
-// NewAttemptMiddleware returns a new AttemptMiddleware
-func NewAttemptMiddleware(retryer Retryer, requestCloner RequestCloner) AttemptMiddleware {
-	return AttemptMiddleware{retryer: retryer, requestCloner: requestCloner}
+// NewAttemptMiddleware returns a new Attempt
+func NewAttemptMiddleware(retryer Retryer, requestCloner RequestCloner) *Attempt {
+	return &Attempt{retryer: retryer, requestCloner: requestCloner}
 }
 
 // ID returns the middleware identifier
-func (r AttemptMiddleware) ID() string {
-	return "RetryAttemptMiddleware"
+func (r *Attempt) ID() string {
+	return "Retry"
 }
 
 // HandleFinalize utilizes the provider Retryer implementation to attempt retries over the next handler
-func (r AttemptMiddleware) HandleFinalize(ctx context.Context, in smithymiddle.FinalizeInput, next smithymiddle.FinalizeHandler) (
+func (r Attempt) HandleFinalize(ctx context.Context, in smithymiddle.FinalizeInput, next smithymiddle.FinalizeHandler) (
 	out smithymiddle.FinalizeOutput, metadata smithymiddle.Metadata, err error,
 ) {
 	var attemptNum, retryCount int
@@ -118,16 +118,16 @@ func (r AttemptMiddleware) HandleFinalize(ctx context.Context, in smithymiddle.F
 	}
 }
 
-// MetricsHeaderMiddleware attaches SDK request metric header for retries to the transport
-type MetricsHeaderMiddleware struct{}
+// MetricsHeader attaches SDK request metric header for retries to the transport
+type MetricsHeader struct{}
 
 // ID returns the middleware identifier
-func (r MetricsHeaderMiddleware) ID() string {
-	return "MetricsHeaderMiddleware"
+func (r *MetricsHeader) ID() string {
+	return "RetryMetricsHeader"
 }
 
 // HandleFinalize attaches the sdk request metric header to the transport layer
-func (r MetricsHeaderMiddleware) HandleFinalize(ctx context.Context, in smithymiddle.FinalizeInput, next smithymiddle.FinalizeHandler) (
+func (r MetricsHeader) HandleFinalize(ctx context.Context, in smithymiddle.FinalizeInput, next smithymiddle.FinalizeHandler) (
 	out smithymiddle.FinalizeOutput, metadata smithymiddle.Metadata, err error,
 ) {
 	retryMetadata, ok := getRetryMetadata(ctx)
@@ -183,11 +183,11 @@ type AddRetryMiddlewaresOptions struct {
 
 // AddRetryMiddlewares adds retry middleware to operation middleware stack
 func AddRetryMiddlewares(stack *smithymiddle.Stack, options AddRetryMiddlewaresOptions) error {
-	attemptMiddleware := NewAttemptMiddleware(options.Retryer, http.RequestCloner)
-	if err := stack.Finalize.Add(&attemptMiddleware, smithymiddle.After); err != nil {
+	attempt := NewAttemptMiddleware(options.Retryer, http.RequestCloner)
+	if err := stack.Finalize.Add(attempt, smithymiddle.After); err != nil {
 		return err
 	}
-	if err := stack.Finalize.Add(&MetricsHeaderMiddleware{}, smithymiddle.After); err != nil {
+	if err := stack.Finalize.Add(&MetricsHeader{}, smithymiddle.After); err != nil {
 		return err
 	}
 	return nil

aws/retry/middleware_test.go

@@ -57,7 +57,7 @@ func TestMetricsHeaderMiddleware(t *testing.T) {
 		},
 	}
 
-	retryMiddleware := MetricsHeaderMiddleware{}
+	retryMiddleware := MetricsHeader{}
 	for i, tt := range cases {
 		t.Run(strconv.Itoa(i), func(t *testing.T) {
 			ctx := tt.ctx