code.dwrz.net

Go monorepo.
Log | Files | Refs

middleware.go (3418B)

      1 package client
      2 
      3 import (
      4 	"context"
      5 	"encoding/json"
      6 	"fmt"
      7 	"net/url"
      8 
      9 	"github.com/aws/smithy-go"
     10 	smithymiddleware "github.com/aws/smithy-go/middleware"
     11 	smithyhttp "github.com/aws/smithy-go/transport/http"
     12 )
     13 
     14 type buildEndpoint struct {
     15 	Endpoint string
     16 }
     17 
     18 func (b *buildEndpoint) ID() string {
     19 	return "BuildEndpoint"
     20 }
     21 
     22 func (b *buildEndpoint) HandleBuild(ctx context.Context, in smithymiddleware.BuildInput, next smithymiddleware.BuildHandler) (
     23 	out smithymiddleware.BuildOutput, metadata smithymiddleware.Metadata, err error,
     24 ) {
     25 	request, ok := in.Request.(*smithyhttp.Request)
     26 	if !ok {
     27 		return out, metadata, fmt.Errorf("unknown transport, %T", in.Request)
     28 	}
     29 
     30 	if len(b.Endpoint) == 0 {
     31 		return out, metadata, fmt.Errorf("endpoint not provided")
     32 	}
     33 
     34 	parsed, err := url.Parse(b.Endpoint)
     35 	if err != nil {
     36 		return out, metadata, fmt.Errorf("failed to parse endpoint, %w", err)
     37 	}
     38 
     39 	request.URL = parsed
     40 
     41 	return next.HandleBuild(ctx, in)
     42 }
     43 
     44 type serializeOpGetCredential struct{}
     45 
     46 func (s *serializeOpGetCredential) ID() string {
     47 	return "OperationSerializer"
     48 }
     49 
     50 func (s *serializeOpGetCredential) HandleSerialize(ctx context.Context, in smithymiddleware.SerializeInput, next smithymiddleware.SerializeHandler) (
     51 	out smithymiddleware.SerializeOutput, metadata smithymiddleware.Metadata, err error,
     52 ) {
     53 	request, ok := in.Request.(*smithyhttp.Request)
     54 	if !ok {
     55 		return out, metadata, fmt.Errorf("unknown transport type, %T", in.Request)
     56 	}
     57 
     58 	params, ok := in.Parameters.(*GetCredentialsInput)
     59 	if !ok {
     60 		return out, metadata, fmt.Errorf("unknown input parameters, %T", in.Parameters)
     61 	}
     62 
     63 	const acceptHeader = "Accept"
     64 	request.Header[acceptHeader] = append(request.Header[acceptHeader][:0], "application/json")
     65 
     66 	if len(params.AuthorizationToken) > 0 {
     67 		const authHeader = "Authorization"
     68 		request.Header[authHeader] = append(request.Header[authHeader][:0], params.AuthorizationToken)
     69 	}
     70 
     71 	return next.HandleSerialize(ctx, in)
     72 }
     73 
     74 type deserializeOpGetCredential struct{}
     75 
     76 func (d *deserializeOpGetCredential) ID() string {
     77 	return "OperationDeserializer"
     78 }
     79 
     80 func (d *deserializeOpGetCredential) HandleDeserialize(ctx context.Context, in smithymiddleware.DeserializeInput, next smithymiddleware.DeserializeHandler) (
     81 	out smithymiddleware.DeserializeOutput, metadata smithymiddleware.Metadata, err error,
     82 ) {
     83 	out, metadata, err = next.HandleDeserialize(ctx, in)
     84 	if err != nil {
     85 		return out, metadata, err
     86 	}
     87 
     88 	response, ok := out.RawResponse.(*smithyhttp.Response)
     89 	if !ok {
     90 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
     91 	}
     92 
     93 	if response.StatusCode < 200 || response.StatusCode >= 300 {
     94 		return out, metadata, deserializeError(response)
     95 	}
     96 
     97 	var shape *GetCredentialsOutput
     98 	if err = json.NewDecoder(response.Body).Decode(&shape); err != nil {
     99 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to deserialize json response, %w", err)}
    100 	}
    101 
    102 	out.Result = shape
    103 	return out, metadata, err
    104 }
    105 
    106 func deserializeError(response *smithyhttp.Response) error {
    107 	var errShape *EndpointError
    108 	err := json.NewDecoder(response.Body).Decode(&errShape)
    109 	if err != nil {
    110 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to decode error message, %w", err)}
    111 	}
    112 
    113 	if response.StatusCode >= 500 {
    114 		errShape.Fault = smithy.FaultServer
    115 	} else {
    116 		errShape.Fault = smithy.FaultClient
    117 	}
    118 
    119 	return errShape
    120 }