Switch to using the dep tool and update all the dependencies

vendor/github.com/aws/aws-sdk-go/private/protocol/ec2query/build.go

@@ -0,0 +1,35 @@
+// Package ec2query provides serialization of AWS EC2 requests and responses.
+package ec2query
+
+//go:generate go run -tags codegen ../../../models/protocol_tests/generate.go ../../../models/protocol_tests/input/ec2.json build_test.go
+
+import (
+	"net/url"
+
+	"github.com/aws/aws-sdk-go/aws/awserr"
+	"github.com/aws/aws-sdk-go/aws/request"
+	"github.com/aws/aws-sdk-go/private/protocol/query/queryutil"
+)
+
+// BuildHandler is a named request handler for building ec2query protocol requests
+var BuildHandler = request.NamedHandler{Name: "awssdk.ec2query.Build", Fn: Build}
+
+// Build builds a request for the EC2 protocol.
+func Build(r *request.Request) {
+	body := url.Values{
+		"Action":  {r.Operation.Name},
+		"Version": {r.ClientInfo.APIVersion},
+	}
+	if err := queryutil.Parse(body, r.Params, true); err != nil {
+		r.Error = awserr.New("SerializationError", "failed encoding EC2 Query request", err)
+	}
+
+	if r.ExpireTime == 0 {
+		r.HTTPRequest.Method = "POST"
+		r.HTTPRequest.Header.Set("Content-Type", "application/x-www-form-urlencoded; charset=utf-8")
+		r.SetBufferBody([]byte(body.Encode()))
+	} else { // This is a pre-signed request
+		r.HTTPRequest.Method = "GET"
+		r.HTTPRequest.URL.RawQuery = body.Encode()
+	}
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/ec2query/build_bench_test.go

@@ -0,0 +1,85 @@
+// +build bench
+
+package ec2query_test
+
+import (
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/request"
+	"github.com/aws/aws-sdk-go/awstesting"
+	"github.com/aws/aws-sdk-go/private/protocol/ec2query"
+	"github.com/aws/aws-sdk-go/service/ec2"
+)
+
+func BenchmarkEC2QueryBuild_Complex_ec2AuthorizeSecurityGroupEgress(b *testing.B) {
+	params := &ec2.AuthorizeSecurityGroupEgressInput{
+		GroupId:  aws.String("String"), // Required
+		CidrIp:   aws.String("String"),
+		DryRun:   aws.Bool(true),
+		FromPort: aws.Int64(1),
+		IpPermissions: []*ec2.IpPermission{
+			{ // Required
+				FromPort:   aws.Int64(1),
+				IpProtocol: aws.String("String"),
+				IpRanges: []*ec2.IpRange{
+					{ // Required
+						CidrIp: aws.String("String"),
+					},
+					// More values...
+				},
+				PrefixListIds: []*ec2.PrefixListId{
+					{ // Required
+						PrefixListId: aws.String("String"),
+					},
+					// More values...
+				},
+				ToPort: aws.Int64(1),
+				UserIdGroupPairs: []*ec2.UserIdGroupPair{
+					{ // Required
+						GroupId:   aws.String("String"),
+						GroupName: aws.String("String"),
+						UserId:    aws.String("String"),
+					},
+					// More values...
+				},
+			},
+			// More values...
+		},
+		IpProtocol:                 aws.String("String"),
+		SourceSecurityGroupName:    aws.String("String"),
+		SourceSecurityGroupOwnerId: aws.String("String"),
+		ToPort: aws.Int64(1),
+	}
+
+	benchEC2QueryBuild(b, "AuthorizeSecurityGroupEgress", params)
+}
+
+func BenchmarkEC2QueryBuild_Simple_ec2AttachNetworkInterface(b *testing.B) {
+	params := &ec2.AttachNetworkInterfaceInput{
+		DeviceIndex:        aws.Int64(1),         // Required
+		InstanceId:         aws.String("String"), // Required
+		NetworkInterfaceId: aws.String("String"), // Required
+		DryRun:             aws.Bool(true),
+	}
+
+	benchEC2QueryBuild(b, "AttachNetworkInterface", params)
+}
+
+func benchEC2QueryBuild(b *testing.B, opName string, params interface{}) {
+	svc := awstesting.NewClient()
+	svc.ServiceName = "ec2"
+	svc.APIVersion = "2015-04-15"
+
+	for i := 0; i < b.N; i++ {
+		r := svc.NewRequest(&request.Operation{
+			Name:       opName,
+			HTTPMethod: "POST",
+			HTTPPath:   "/",
+		}, params, nil)
+		ec2query.Build(r)
+		if r.Error != nil {
+			b.Fatal("Unexpected error", r.Error)
+		}
+	}
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/ec2query/unmarshal.go

@@ -0,0 +1,63 @@
+package ec2query
+
+//go:generate go run -tags codegen ../../../models/protocol_tests/generate.go ../../../models/protocol_tests/output/ec2.json unmarshal_test.go
+
+import (
+	"encoding/xml"
+	"io"
+
+	"github.com/aws/aws-sdk-go/aws/awserr"
+	"github.com/aws/aws-sdk-go/aws/request"
+	"github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil"
+)
+
+// UnmarshalHandler is a named request handler for unmarshaling ec2query protocol requests
+var UnmarshalHandler = request.NamedHandler{Name: "awssdk.ec2query.Unmarshal", Fn: Unmarshal}
+
+// UnmarshalMetaHandler is a named request handler for unmarshaling ec2query protocol request metadata
+var UnmarshalMetaHandler = request.NamedHandler{Name: "awssdk.ec2query.UnmarshalMeta", Fn: UnmarshalMeta}
+
+// UnmarshalErrorHandler is a named request handler for unmarshaling ec2query protocol request errors
+var UnmarshalErrorHandler = request.NamedHandler{Name: "awssdk.ec2query.UnmarshalError", Fn: UnmarshalError}
+
+// Unmarshal unmarshals a response body for the EC2 protocol.
+func Unmarshal(r *request.Request) {
+	defer r.HTTPResponse.Body.Close()
+	if r.DataFilled() {
+		decoder := xml.NewDecoder(r.HTTPResponse.Body)
+		err := xmlutil.UnmarshalXML(r.Data, decoder, "")
+		if err != nil {
+			r.Error = awserr.New("SerializationError", "failed decoding EC2 Query response", err)
+			return
+		}
+	}
+}
+
+// UnmarshalMeta unmarshals response headers for the EC2 protocol.
+func UnmarshalMeta(r *request.Request) {
+	// TODO implement unmarshaling of request IDs
+}
+
+type xmlErrorResponse struct {
+	XMLName   xml.Name `xml:"Response"`
+	Code      string   `xml:"Errors>Error>Code"`
+	Message   string   `xml:"Errors>Error>Message"`
+	RequestID string   `xml:"RequestID"`
+}
+
+// UnmarshalError unmarshals a response error for the EC2 protocol.
+func UnmarshalError(r *request.Request) {
+	defer r.HTTPResponse.Body.Close()
+
+	resp := &xmlErrorResponse{}
+	err := xml.NewDecoder(r.HTTPResponse.Body).Decode(resp)
+	if err != nil && err != io.EOF {
+		r.Error = awserr.New("SerializationError", "failed decoding EC2 Query error response", err)
+	} else {
+		r.Error = awserr.NewRequestFailure(
+			awserr.New(resp.Code, resp.Message, nil),
+			r.HTTPResponse.StatusCode,
+			resp.RequestID,
+		)
+	}
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/idempotency_test.go

@@ -0,0 +1,106 @@
+package protocol_test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/private/protocol"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCanSetIdempotencyToken(t *testing.T) {
+	cases := []struct {
+		CanSet bool
+		Case   interface{}
+	}{
+		{
+			true,
+			struct {
+				Field *string `idempotencyToken:"true"`
+			}{},
+		},
+		{
+			true,
+			struct {
+				Field string `idempotencyToken:"true"`
+			}{},
+		},
+		{
+			false,
+			struct {
+				Field *string `idempotencyToken:"true"`
+			}{Field: new(string)},
+		},
+		{
+			false,
+			struct {
+				Field string `idempotencyToken:"true"`
+			}{Field: "value"},
+		},
+		{
+			false,
+			struct {
+				Field *int `idempotencyToken:"true"`
+			}{},
+		},
+		{
+			false,
+			struct {
+				Field *string
+			}{},
+		},
+	}
+
+	for i, c := range cases {
+		v := reflect.Indirect(reflect.ValueOf(c.Case))
+		ty := v.Type()
+		canSet := protocol.CanSetIdempotencyToken(v.Field(0), ty.Field(0))
+		assert.Equal(t, c.CanSet, canSet, "Expect case %d can set to match", i)
+	}
+}
+
+func TestSetIdempotencyToken(t *testing.T) {
+	cases := []struct {
+		Case interface{}
+	}{
+		{
+			&struct {
+				Field *string `idempotencyToken:"true"`
+			}{},
+		},
+		{
+			&struct {
+				Field string `idempotencyToken:"true"`
+			}{},
+		},
+		{
+			&struct {
+				Field *string `idempotencyToken:"true"`
+			}{Field: new(string)},
+		},
+		{
+			&struct {
+				Field string `idempotencyToken:"true"`
+			}{Field: ""},
+		},
+	}
+
+	for i, c := range cases {
+		v := reflect.Indirect(reflect.ValueOf(c.Case))
+
+		protocol.SetIdempotencyToken(v.Field(0))
+		assert.NotEmpty(t, v.Field(0).Interface(), "Expect case %d to be set", i)
+	}
+}
+
+func TestUUIDVersion4(t *testing.T) {
+	uuid := protocol.UUIDVersion4(make([]byte, 16))
+	assert.Equal(t, `00000000-0000-4000-8000-000000000000`, uuid)
+
+	b := make([]byte, 16)
+	for i := 0; i < len(b); i++ {
+		b[i] = 1
+	}
+	uuid = protocol.UUIDVersion4(b)
+	assert.Equal(t, `01010101-0101-4101-8101-010101010101`, uuid)
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/json/jsonutil/build.go

@@ -0,0 +1,279 @@
+// Package jsonutil provides JSON serialization of AWS requests and responses.
+package jsonutil
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"math"
+	"reflect"
+	"sort"
+	"strconv"
+	"time"
+
+	"github.com/aws/aws-sdk-go/private/protocol"
+)
+
+var timeType = reflect.ValueOf(time.Time{}).Type()
+var byteSliceType = reflect.ValueOf([]byte{}).Type()
+
+// BuildJSON builds a JSON string for a given object v.
+func BuildJSON(v interface{}) ([]byte, error) {
+	var buf bytes.Buffer
+
+	err := buildAny(reflect.ValueOf(v), &buf, "")
+	return buf.Bytes(), err
+}
+
+func buildAny(value reflect.Value, buf *bytes.Buffer, tag reflect.StructTag) error {
+	origVal := value
+	value = reflect.Indirect(value)
+	if !value.IsValid() {
+		return nil
+	}
+
+	vtype := value.Type()
+
+	t := tag.Get("type")
+	if t == "" {
+		switch vtype.Kind() {
+		case reflect.Struct:
+			// also it can't be a time object
+			if value.Type() != timeType {
+				t = "structure"
+			}
+		case reflect.Slice:
+			// also it can't be a byte slice
+			if _, ok := value.Interface().([]byte); !ok {
+				t = "list"
+			}
+		case reflect.Map:
+			t = "map"
+		}
+	}
+
+	switch t {
+	case "structure":
+		if field, ok := vtype.FieldByName("_"); ok {
+			tag = field.Tag
+		}
+		return buildStruct(value, buf, tag)
+	case "list":
+		return buildList(value, buf, tag)
+	case "map":
+		return buildMap(value, buf, tag)
+	default:
+		return buildScalar(origVal, buf, tag)
+	}
+}
+
+func buildStruct(value reflect.Value, buf *bytes.Buffer, tag reflect.StructTag) error {
+	if !value.IsValid() {
+		return nil
+	}
+
+	// unwrap payloads
+	if payload := tag.Get("payload"); payload != "" {
+		field, _ := value.Type().FieldByName(payload)
+		tag = field.Tag
+		value = elemOf(value.FieldByName(payload))
+
+		if !value.IsValid() {
+			return nil
+		}
+	}
+
+	buf.WriteByte('{')
+
+	t := value.Type()
+	first := true
+	for i := 0; i < t.NumField(); i++ {
+		member := value.Field(i)
+
+		// This allocates the most memory.
+		// Additionally, we cannot skip nil fields due to
+		// idempotency auto filling.
+		field := t.Field(i)
+
+		if field.PkgPath != "" {
+			continue // ignore unexported fields
+		}
+		if field.Tag.Get("json") == "-" {
+			continue
+		}
+		if field.Tag.Get("location") != "" {
+			continue // ignore non-body elements
+		}
+		if field.Tag.Get("ignore") != "" {
+			continue
+		}
+
+		if protocol.CanSetIdempotencyToken(member, field) {
+			token := protocol.GetIdempotencyToken()
+			member = reflect.ValueOf(&token)
+		}
+
+		if (member.Kind() == reflect.Ptr || member.Kind() == reflect.Slice || member.Kind() == reflect.Map) && member.IsNil() {
+			continue // ignore unset fields
+		}
+
+		if first {
+			first = false
+		} else {
+			buf.WriteByte(',')
+		}
+
+		// figure out what this field is called
+		name := field.Name
+		if locName := field.Tag.Get("locationName"); locName != "" {
+			name = locName
+		}
+
+		writeString(name, buf)
+		buf.WriteString(`:`)
+
+		err := buildAny(member, buf, field.Tag)
+		if err != nil {
+			return err
+		}
+
+	}
+
+	buf.WriteString("}")
+
+	return nil
+}
+
+func buildList(value reflect.Value, buf *bytes.Buffer, tag reflect.StructTag) error {
+	buf.WriteString("[")
+
+	for i := 0; i < value.Len(); i++ {
+		buildAny(value.Index(i), buf, "")
+
+		if i < value.Len()-1 {
+			buf.WriteString(",")
+		}
+	}
+
+	buf.WriteString("]")
+
+	return nil
+}
+
+type sortedValues []reflect.Value
+
+func (sv sortedValues) Len() int           { return len(sv) }
+func (sv sortedValues) Swap(i, j int)      { sv[i], sv[j] = sv[j], sv[i] }
+func (sv sortedValues) Less(i, j int) bool { return sv[i].String() < sv[j].String() }
+
+func buildMap(value reflect.Value, buf *bytes.Buffer, tag reflect.StructTag) error {
+	buf.WriteString("{")
+
+	sv := sortedValues(value.MapKeys())
+	sort.Sort(sv)
+
+	for i, k := range sv {
+		if i > 0 {
+			buf.WriteByte(',')
+		}
+
+		writeString(k.String(), buf)
+		buf.WriteString(`:`)
+
+		buildAny(value.MapIndex(k), buf, "")
+	}
+
+	buf.WriteString("}")
+
+	return nil
+}
+
+func buildScalar(v reflect.Value, buf *bytes.Buffer, tag reflect.StructTag) error {
+	// prevents allocation on the heap.
+	scratch := [64]byte{}
+	switch value := reflect.Indirect(v); value.Kind() {
+	case reflect.String:
+		writeString(value.String(), buf)
+	case reflect.Bool:
+		if value.Bool() {
+			buf.WriteString("true")
+		} else {
+			buf.WriteString("false")
+		}
+	case reflect.Int64:
+		buf.Write(strconv.AppendInt(scratch[:0], value.Int(), 10))
+	case reflect.Float64:
+		f := value.Float()
+		if math.IsInf(f, 0) || math.IsNaN(f) {
+			return &json.UnsupportedValueError{Value: v, Str: strconv.FormatFloat(f, 'f', -1, 64)}
+		}
+		buf.Write(strconv.AppendFloat(scratch[:0], f, 'f', -1, 64))
+	default:
+		switch value.Type() {
+		case timeType:
+			converted := v.Interface().(*time.Time)
+
+			buf.Write(strconv.AppendInt(scratch[:0], converted.UTC().Unix(), 10))
+		case byteSliceType:
+			if !value.IsNil() {
+				converted := value.Interface().([]byte)
+				buf.WriteByte('"')
+				if len(converted) < 1024 {
+					// for small buffers, using Encode directly is much faster.
+					dst := make([]byte, base64.StdEncoding.EncodedLen(len(converted)))
+					base64.StdEncoding.Encode(dst, converted)
+					buf.Write(dst)
+				} else {
+					// for large buffers, avoid unnecessary extra temporary
+					// buffer space.
+					enc := base64.NewEncoder(base64.StdEncoding, buf)
+					enc.Write(converted)
+					enc.Close()
+				}
+				buf.WriteByte('"')
+			}
+		default:
+			return fmt.Errorf("unsupported JSON value %v (%s)", value.Interface(), value.Type())
+		}
+	}
+	return nil
+}
+
+var hex = "0123456789abcdef"
+
+func writeString(s string, buf *bytes.Buffer) {
+	buf.WriteByte('"')
+	for i := 0; i < len(s); i++ {
+		if s[i] == '"' {
+			buf.WriteString(`\"`)
+		} else if s[i] == '\\' {
+			buf.WriteString(`\\`)
+		} else if s[i] == '\b' {
+			buf.WriteString(`\b`)
+		} else if s[i] == '\f' {
+			buf.WriteString(`\f`)
+		} else if s[i] == '\r' {
+			buf.WriteString(`\r`)
+		} else if s[i] == '\t' {
+			buf.WriteString(`\t`)
+		} else if s[i] == '\n' {
+			buf.WriteString(`\n`)
+		} else if s[i] < 32 {
+			buf.WriteString("\\u00")
+			buf.WriteByte(hex[s[i]>>4])
+			buf.WriteByte(hex[s[i]&0xF])
+		} else {
+			buf.WriteByte(s[i])
+		}
+	}
+	buf.WriteByte('"')
+}
+
+// Returns the reflection element of a value, if it is a pointer.
+func elemOf(value reflect.Value) reflect.Value {
+	for value.Kind() == reflect.Ptr {
+		value = value.Elem()
+	}
+	return value
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/json/jsonutil/build_test.go

@@ -0,0 +1,109 @@
+package jsonutil_test
+
+import (
+	"encoding/json"
+	"testing"
+	"time"
+
+	"github.com/aws/aws-sdk-go/private/protocol/json/jsonutil"
+	"github.com/stretchr/testify/assert"
+)
+
+func S(s string) *string {
+	return &s
+}
+
+func D(s int64) *int64 {
+	return &s
+}
+
+func F(s float64) *float64 {
+	return &s
+}
+
+func T(s time.Time) *time.Time {
+	return &s
+}
+
+type J struct {
+	S  *string
+	SS []string
+	D  *int64
+	F  *float64
+	T  *time.Time
+}
+
+var zero = 0.0
+
+var jsonTests = []struct {
+	in  interface{}
+	out string
+	err string
+}{
+	{
+		J{},
+		`{}`,
+		``,
+	},
+	{
+		J{
+			S:  S("str"),
+			SS: []string{"A", "B", "C"},
+			D:  D(123),
+			F:  F(4.56),
+			T:  T(time.Unix(987, 0)),
+		},
+		`{"S":"str","SS":["A","B","C"],"D":123,"F":4.56,"T":987}`,
+		``,
+	},
+	{
+		J{
+			S: S(`"''"`),
+		},
+		`{"S":"\"''\""}`,
+		``,
+	},
+	{
+		J{
+			S: S("\x00føø\u00FF\n\\\"\r\t\b\f"),
+		},
+		`{"S":"\u0000føøÿ\n\\\"\r\t\b\f"}`,
+		``,
+	},
+	{
+		J{
+			F: F(4.56 / zero),
+		},
+		"",
+		`json: unsupported value: +Inf`,
+	},
+}
+
+func TestBuildJSON(t *testing.T) {
+	for _, test := range jsonTests {
+		out, err := jsonutil.BuildJSON(test.in)
+		if test.err != "" {
+			assert.Error(t, err)
+			assert.Contains(t, err.Error(), test.err)
+		} else {
+			assert.NoError(t, err)
+			assert.Equal(t, string(out), test.out)
+		}
+	}
+}
+
+func BenchmarkBuildJSON(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, test := range jsonTests {
+			jsonutil.BuildJSON(test.in)
+		}
+	}
+}
+
+func BenchmarkStdlibJSON(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, test := range jsonTests {
+			json.Marshal(test.in)
+		}
+	}
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/json/jsonutil/unmarshal.go

@@ -0,0 +1,213 @@
+package jsonutil
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"reflect"
+	"time"
+)
+
+// UnmarshalJSON reads a stream and unmarshals the results in object v.
+func UnmarshalJSON(v interface{}, stream io.Reader) error {
+	var out interface{}
+
+	b, err := ioutil.ReadAll(stream)
+	if err != nil {
+		return err
+	}
+
+	if len(b) == 0 {
+		return nil
+	}
+
+	if err := json.Unmarshal(b, &out); err != nil {
+		return err
+	}
+
+	return unmarshalAny(reflect.ValueOf(v), out, "")
+}
+
+func unmarshalAny(value reflect.Value, data interface{}, tag reflect.StructTag) error {
+	vtype := value.Type()
+	if vtype.Kind() == reflect.Ptr {
+		vtype = vtype.Elem() // check kind of actual element type
+	}
+
+	t := tag.Get("type")
+	if t == "" {
+		switch vtype.Kind() {
+		case reflect.Struct:
+			// also it can't be a time object
+			if _, ok := value.Interface().(*time.Time); !ok {
+				t = "structure"
+			}
+		case reflect.Slice:
+			// also it can't be a byte slice
+			if _, ok := value.Interface().([]byte); !ok {
+				t = "list"
+			}
+		case reflect.Map:
+			t = "map"
+		}
+	}
+
+	switch t {
+	case "structure":
+		if field, ok := vtype.FieldByName("_"); ok {
+			tag = field.Tag
+		}
+		return unmarshalStruct(value, data, tag)
+	case "list":
+		return unmarshalList(value, data, tag)
+	case "map":
+		return unmarshalMap(value, data, tag)
+	default:
+		return unmarshalScalar(value, data, tag)
+	}
+}
+
+func unmarshalStruct(value reflect.Value, data interface{}, tag reflect.StructTag) error {
+	if data == nil {
+		return nil
+	}
+	mapData, ok := data.(map[string]interface{})
+	if !ok {
+		return fmt.Errorf("JSON value is not a structure (%#v)", data)
+	}
+
+	t := value.Type()
+	if value.Kind() == reflect.Ptr {
+		if value.IsNil() { // create the structure if it's nil
+			s := reflect.New(value.Type().Elem())
+			value.Set(s)
+			value = s
+		}
+
+		value = value.Elem()
+		t = t.Elem()
+	}
+
+	// unwrap any payloads
+	if payload := tag.Get("payload"); payload != "" {
+		field, _ := t.FieldByName(payload)
+		return unmarshalAny(value.FieldByName(payload), data, field.Tag)
+	}
+
+	for i := 0; i < t.NumField(); i++ {
+		field := t.Field(i)
+		if field.PkgPath != "" {
+			continue // ignore unexported fields
+		}
+
+		// figure out what this field is called
+		name := field.Name
+		if locName := field.Tag.Get("locationName"); locName != "" {
+			name = locName
+		}
+
+		member := value.FieldByIndex(field.Index)
+		err := unmarshalAny(member, mapData[name], field.Tag)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func unmarshalList(value reflect.Value, data interface{}, tag reflect.StructTag) error {
+	if data == nil {
+		return nil
+	}
+	listData, ok := data.([]interface{})
+	if !ok {
+		return fmt.Errorf("JSON value is not a list (%#v)", data)
+	}
+
+	if value.IsNil() {
+		l := len(listData)
+		value.Set(reflect.MakeSlice(value.Type(), l, l))
+	}
+
+	for i, c := range listData {
+		err := unmarshalAny(value.Index(i), c, "")
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func unmarshalMap(value reflect.Value, data interface{}, tag reflect.StructTag) error {
+	if data == nil {
+		return nil
+	}
+	mapData, ok := data.(map[string]interface{})
+	if !ok {
+		return fmt.Errorf("JSON value is not a map (%#v)", data)
+	}
+
+	if value.IsNil() {
+		value.Set(reflect.MakeMap(value.Type()))
+	}
+
+	for k, v := range mapData {
+		kvalue := reflect.ValueOf(k)
+		vvalue := reflect.New(value.Type().Elem()).Elem()
+
+		unmarshalAny(vvalue, v, "")
+		value.SetMapIndex(kvalue, vvalue)
+	}
+
+	return nil
+}
+
+func unmarshalScalar(value reflect.Value, data interface{}, tag reflect.StructTag) error {
+	errf := func() error {
+		return fmt.Errorf("unsupported value: %v (%s)", value.Interface(), value.Type())
+	}
+
+	switch d := data.(type) {
+	case nil:
+		return nil // nothing to do here
+	case string:
+		switch value.Interface().(type) {
+		case *string:
+			value.Set(reflect.ValueOf(&d))
+		case []byte:
+			b, err := base64.StdEncoding.DecodeString(d)
+			if err != nil {
+				return err
+			}
+			value.Set(reflect.ValueOf(b))
+		default:
+			return errf()
+		}
+	case float64:
+		switch value.Interface().(type) {
+		case *int64:
+			di := int64(d)
+			value.Set(reflect.ValueOf(&di))
+		case *float64:
+			value.Set(reflect.ValueOf(&d))
+		case *time.Time:
+			t := time.Unix(int64(d), 0).UTC()
+			value.Set(reflect.ValueOf(&t))
+		default:
+			return errf()
+		}
+	case bool:
+		switch value.Interface().(type) {
+		case *bool:
+			value.Set(reflect.ValueOf(&d))
+		default:
+			return errf()
+		}
+	default:
+		return fmt.Errorf("unsupported JSON value (%v)", data)
+	}
+	return nil
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/jsonrpc/build_bench_test.go

@@ -0,0 +1,71 @@
+// +build bench
+
+package jsonrpc_test
+
+import (
+	"bytes"
+	"encoding/json"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/request"
+	"github.com/aws/aws-sdk-go/awstesting"
+	"github.com/aws/aws-sdk-go/private/protocol/json/jsonutil"
+	"github.com/aws/aws-sdk-go/private/protocol/jsonrpc"
+	"github.com/aws/aws-sdk-go/service/dynamodb"
+	"github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute"
+)
+
+func BenchmarkJSONRPCBuild_Simple_dynamodbPutItem(b *testing.B) {
+	svc := awstesting.NewClient()
+
+	params := getDynamodbPutItemParams(b)
+
+	for i := 0; i < b.N; i++ {
+		r := svc.NewRequest(&request.Operation{Name: "Operation"}, params, nil)
+		jsonrpc.Build(r)
+		if r.Error != nil {
+			b.Fatal("Unexpected error", r.Error)
+		}
+	}
+}
+
+func BenchmarkJSONUtilBuild_Simple_dynamodbPutItem(b *testing.B) {
+	svc := awstesting.NewClient()
+
+	params := getDynamodbPutItemParams(b)
+
+	for i := 0; i < b.N; i++ {
+		r := svc.NewRequest(&request.Operation{Name: "Operation"}, params, nil)
+		_, err := jsonutil.BuildJSON(r.Params)
+		if err != nil {
+			b.Fatal("Unexpected error", err)
+		}
+	}
+}
+
+func BenchmarkEncodingJSONMarshal_Simple_dynamodbPutItem(b *testing.B) {
+	params := getDynamodbPutItemParams(b)
+
+	for i := 0; i < b.N; i++ {
+		buf := &bytes.Buffer{}
+		encoder := json.NewEncoder(buf)
+		if err := encoder.Encode(params); err != nil {
+			b.Fatal("Unexpected error", err)
+		}
+	}
+}
+
+func getDynamodbPutItemParams(b *testing.B) *dynamodb.PutItemInput {
+	av, err := dynamodbattribute.ConvertToMap(struct {
+		Key  string
+		Data string
+	}{Key: "MyKey", Data: "MyData"})
+	if err != nil {
+		b.Fatal("benchPutItem, expect no ConvertToMap errors", err)
+	}
+	return &dynamodb.PutItemInput{
+		Item:      av,
+		TableName: aws.String("tablename"),
+	}
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/jsonrpc/jsonrpc.go

@@ -0,0 +1,111 @@
+// Package jsonrpc provides JSON RPC utilities for serialization of AWS
+// requests and responses.
+package jsonrpc
+
+//go:generate go run -tags codegen ../../../models/protocol_tests/generate.go ../../../models/protocol_tests/input/json.json build_test.go
+//go:generate go run -tags codegen ../../../models/protocol_tests/generate.go ../../../models/protocol_tests/output/json.json unmarshal_test.go
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"strings"
+
+	"github.com/aws/aws-sdk-go/aws/awserr"
+	"github.com/aws/aws-sdk-go/aws/request"
+	"github.com/aws/aws-sdk-go/private/protocol/json/jsonutil"
+	"github.com/aws/aws-sdk-go/private/protocol/rest"
+)
+
+var emptyJSON = []byte("{}")
+
+// BuildHandler is a named request handler for building jsonrpc protocol requests
+var BuildHandler = request.NamedHandler{Name: "awssdk.jsonrpc.Build", Fn: Build}
+
+// UnmarshalHandler is a named request handler for unmarshaling jsonrpc protocol requests
+var UnmarshalHandler = request.NamedHandler{Name: "awssdk.jsonrpc.Unmarshal", Fn: Unmarshal}
+
+// UnmarshalMetaHandler is a named request handler for unmarshaling jsonrpc protocol request metadata
+var UnmarshalMetaHandler = request.NamedHandler{Name: "awssdk.jsonrpc.UnmarshalMeta", Fn: UnmarshalMeta}
+
+// UnmarshalErrorHandler is a named request handler for unmarshaling jsonrpc protocol request errors
+var UnmarshalErrorHandler = request.NamedHandler{Name: "awssdk.jsonrpc.UnmarshalError", Fn: UnmarshalError}
+
+// Build builds a JSON payload for a JSON RPC request.
+func Build(req *request.Request) {
+	var buf []byte
+	var err error
+	if req.ParamsFilled() {
+		buf, err = jsonutil.BuildJSON(req.Params)
+		if err != nil {
+			req.Error = awserr.New("SerializationError", "failed encoding JSON RPC request", err)
+			return
+		}
+	} else {
+		buf = emptyJSON
+	}
+
+	if req.ClientInfo.TargetPrefix != "" || string(buf) != "{}" {
+		req.SetBufferBody(buf)
+	}
+
+	if req.ClientInfo.TargetPrefix != "" {
+		target := req.ClientInfo.TargetPrefix + "." + req.Operation.Name
+		req.HTTPRequest.Header.Add("X-Amz-Target", target)
+	}
+	if req.ClientInfo.JSONVersion != "" {
+		jsonVersion := req.ClientInfo.JSONVersion
+		req.HTTPRequest.Header.Add("Content-Type", "application/x-amz-json-"+jsonVersion)
+	}
+}
+
+// Unmarshal unmarshals a response for a JSON RPC service.
+func Unmarshal(req *request.Request) {
+	defer req.HTTPResponse.Body.Close()
+	if req.DataFilled() {
+		err := jsonutil.UnmarshalJSON(req.Data, req.HTTPResponse.Body)
+		if err != nil {
+			req.Error = awserr.New("SerializationError", "failed decoding JSON RPC response", err)
+		}
+	}
+	return
+}
+
+// UnmarshalMeta unmarshals headers from a response for a JSON RPC service.
+func UnmarshalMeta(req *request.Request) {
+	rest.UnmarshalMeta(req)
+}
+
+// UnmarshalError unmarshals an error response for a JSON RPC service.
+func UnmarshalError(req *request.Request) {
+	defer req.HTTPResponse.Body.Close()
+	bodyBytes, err := ioutil.ReadAll(req.HTTPResponse.Body)
+	if err != nil {
+		req.Error = awserr.New("SerializationError", "failed reading JSON RPC error response", err)
+		return
+	}
+	if len(bodyBytes) == 0 {
+		req.Error = awserr.NewRequestFailure(
+			awserr.New("SerializationError", req.HTTPResponse.Status, nil),
+			req.HTTPResponse.StatusCode,
+			"",
+		)
+		return
+	}
+	var jsonErr jsonErrorResponse
+	if err := json.Unmarshal(bodyBytes, &jsonErr); err != nil {
+		req.Error = awserr.New("SerializationError", "failed decoding JSON RPC error response", err)
+		return
+	}
+
+	codes := strings.SplitN(jsonErr.Code, "#", 2)
+	req.Error = awserr.NewRequestFailure(
+		awserr.New(codes[len(codes)-1], jsonErr.Message, nil),
+		req.HTTPResponse.StatusCode,
+		req.RequestID,
+	)
+}
+
+type jsonErrorResponse struct {
+	Code    string `json:"__type"`
+	Message string `json:"message"`
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/protocol_test.go

@@ -0,0 +1,203 @@
+package protocol_test
+
+import (
+	"net/http"
+	"net/url"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/aws/aws-sdk-go/aws/client/metadata"
+	"github.com/aws/aws-sdk-go/aws/request"
+	"github.com/aws/aws-sdk-go/awstesting"
+	"github.com/aws/aws-sdk-go/private/protocol"
+	"github.com/aws/aws-sdk-go/private/protocol/ec2query"
+	"github.com/aws/aws-sdk-go/private/protocol/jsonrpc"
+	"github.com/aws/aws-sdk-go/private/protocol/query"
+	"github.com/aws/aws-sdk-go/private/protocol/rest"
+	"github.com/aws/aws-sdk-go/private/protocol/restjson"
+	"github.com/aws/aws-sdk-go/private/protocol/restxml"
+)
+
+func xmlData(set bool, b []byte, size, delta int) {
+	const openingTags = "<B><A>"
+	const closingTags = "</A></B>"
+	if !set {
+		copy(b, []byte(openingTags))
+	}
+	if size == 0 {
+		copy(b[delta-len(closingTags):], []byte(closingTags))
+	}
+}
+
+func jsonData(set bool, b []byte, size, delta int) {
+	if !set {
+		copy(b, []byte("{\"A\": \""))
+	}
+	if size == 0 {
+		copy(b[delta-len("\"}"):], []byte("\"}"))
+	}
+}
+
+func buildNewRequest(data interface{}) *request.Request {
+	v := url.Values{}
+	v.Set("test", "TEST")
+	v.Add("test1", "TEST1")
+
+	req := &request.Request{
+		HTTPRequest: &http.Request{
+			Header: make(http.Header),
+			Body:   &awstesting.ReadCloser{Size: 2048},
+			URL: &url.URL{
+				RawQuery: v.Encode(),
+			},
+		},
+		Params: &struct {
+			LocationName string `locationName:"test"`
+		}{
+			"Test",
+		},
+		ClientInfo: metadata.ClientInfo{
+			ServiceName:   "test",
+			TargetPrefix:  "test",
+			JSONVersion:   "test",
+			APIVersion:    "test",
+			Endpoint:      "test",
+			SigningName:   "test",
+			SigningRegion: "test",
+		},
+		Operation: &request.Operation{
+			Name: "test",
+		},
+	}
+	req.HTTPResponse = &http.Response{
+		Body: &awstesting.ReadCloser{Size: 2048},
+		Header: http.Header{
+			"X-Amzn-Requestid": []string{"1"},
+		},
+		StatusCode: http.StatusOK,
+	}
+
+	if data == nil {
+		data = &struct {
+			_            struct{} `type:"structure"`
+			LocationName *string  `locationName:"testName"`
+			Location     *string  `location:"statusCode"`
+			A            *string  `type:"string"`
+		}{}
+	}
+
+	req.Data = data
+
+	return req
+}
+
+type expected struct {
+	dataType  int
+	closed    bool
+	size      int
+	errExists bool
+}
+
+const (
+	jsonType = iota
+	xmlType
+)
+
+func checkForLeak(data interface{}, build, fn func(*request.Request), t *testing.T, result expected) {
+	req := buildNewRequest(data)
+	reader := req.HTTPResponse.Body.(*awstesting.ReadCloser)
+	switch result.dataType {
+	case jsonType:
+		reader.FillData = jsonData
+	case xmlType:
+		reader.FillData = xmlData
+	}
+	build(req)
+	fn(req)
+
+	if result.errExists {
+		assert.NotNil(t, req.Error)
+	} else {
+		assert.Nil(t, req.Error)
+	}
+
+	assert.Equal(t, reader.Closed, result.closed)
+	assert.Equal(t, reader.Size, result.size)
+}
+
+func TestJSONRpc(t *testing.T) {
+	checkForLeak(nil, jsonrpc.Build, jsonrpc.Unmarshal, t, expected{jsonType, true, 0, false})
+	checkForLeak(nil, jsonrpc.Build, jsonrpc.UnmarshalMeta, t, expected{jsonType, false, 2048, false})
+	checkForLeak(nil, jsonrpc.Build, jsonrpc.UnmarshalError, t, expected{jsonType, true, 0, true})
+}
+
+func TestQuery(t *testing.T) {
+	checkForLeak(nil, query.Build, query.Unmarshal, t, expected{jsonType, true, 0, false})
+	checkForLeak(nil, query.Build, query.UnmarshalMeta, t, expected{jsonType, false, 2048, false})
+	checkForLeak(nil, query.Build, query.UnmarshalError, t, expected{jsonType, true, 0, true})
+}
+
+func TestRest(t *testing.T) {
+	// case 1: Payload io.ReadSeeker
+	checkForLeak(nil, rest.Build, rest.Unmarshal, t, expected{jsonType, false, 2048, false})
+	checkForLeak(nil, query.Build, query.UnmarshalMeta, t, expected{jsonType, false, 2048, false})
+
+	// case 2: Payload *string
+	// should close the body
+	dataStr := struct {
+		_            struct{} `type:"structure" payload:"Payload"`
+		LocationName *string  `locationName:"testName"`
+		Location     *string  `location:"statusCode"`
+		A            *string  `type:"string"`
+		Payload      *string  `locationName:"payload" type:"blob" required:"true"`
+	}{}
+	checkForLeak(&dataStr, rest.Build, rest.Unmarshal, t, expected{jsonType, true, 0, false})
+	checkForLeak(&dataStr, query.Build, query.UnmarshalMeta, t, expected{jsonType, false, 2048, false})
+
+	// case 3: Payload []byte
+	// should close the body
+	dataBytes := struct {
+		_            struct{} `type:"structure" payload:"Payload"`
+		LocationName *string  `locationName:"testName"`
+		Location     *string  `location:"statusCode"`
+		A            *string  `type:"string"`
+		Payload      []byte   `locationName:"payload" type:"blob" required:"true"`
+	}{}
+	checkForLeak(&dataBytes, rest.Build, rest.Unmarshal, t, expected{jsonType, true, 0, false})
+	checkForLeak(&dataBytes, query.Build, query.UnmarshalMeta, t, expected{jsonType, false, 2048, false})
+
+	// case 4: Payload unsupported type
+	// should close the body
+	dataUnsupported := struct {
+		_            struct{} `type:"structure" payload:"Payload"`
+		LocationName *string  `locationName:"testName"`
+		Location     *string  `location:"statusCode"`
+		A            *string  `type:"string"`
+		Payload      string   `locationName:"payload" type:"blob" required:"true"`
+	}{}
+	checkForLeak(&dataUnsupported, rest.Build, rest.Unmarshal, t, expected{jsonType, true, 0, true})
+	checkForLeak(&dataUnsupported, query.Build, query.UnmarshalMeta, t, expected{jsonType, false, 2048, false})
+}
+
+func TestRestJSON(t *testing.T) {
+	checkForLeak(nil, restjson.Build, restjson.Unmarshal, t, expected{jsonType, true, 0, false})
+	checkForLeak(nil, restjson.Build, restjson.UnmarshalMeta, t, expected{jsonType, false, 2048, false})
+	checkForLeak(nil, restjson.Build, restjson.UnmarshalError, t, expected{jsonType, true, 0, true})
+}
+
+func TestRestXML(t *testing.T) {
+	checkForLeak(nil, restxml.Build, restxml.Unmarshal, t, expected{xmlType, true, 0, false})
+	checkForLeak(nil, restxml.Build, restxml.UnmarshalMeta, t, expected{xmlType, false, 2048, false})
+	checkForLeak(nil, restxml.Build, restxml.UnmarshalError, t, expected{xmlType, true, 0, true})
+}
+
+func TestXML(t *testing.T) {
+	checkForLeak(nil, ec2query.Build, ec2query.Unmarshal, t, expected{jsonType, true, 0, false})
+	checkForLeak(nil, ec2query.Build, ec2query.UnmarshalMeta, t, expected{jsonType, false, 2048, false})
+	checkForLeak(nil, ec2query.Build, ec2query.UnmarshalError, t, expected{jsonType, true, 0, true})
+}
+
+func TestProtocol(t *testing.T) {
+	checkForLeak(nil, restxml.Build, protocol.UnmarshalDiscardBody, t, expected{xmlType, true, 0, false})
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/query/queryutil/queryutil.go

@@ -80,7 +80,6 @@ func (q *queryParser) parseStruct(v url.Values, value reflect.Value, prefix stri
 			continue
 		}
 
-
 		if protocol.CanSetIdempotencyToken(value.Field(i), field) {
 			token := protocol.GetIdempotencyToken()
 			elemValue = reflect.ValueOf(token)
@@ -124,7 +123,11 @@ func (q *queryParser) parseList(v url.Values, value reflect.Value, prefix string
 
 	// check for unflattened list member
 	if !q.isEC2 && tag.Get("flattened") == "" {
-		prefix += ".member"
+		if listName := tag.Get("locationNameList"); listName == "" {
+			prefix += ".member"
+		} else {
+			prefix += "." + listName
+		}
 	}
 
 	for i := 0; i < value.Len(); i++ {

vendor/github.com/aws/aws-sdk-go/private/protocol/rest/build.go

@@ -4,6 +4,7 @@ package rest
 import (
 	"bytes"
 	"encoding/base64"
+	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
@@ -82,8 +83,12 @@ func buildLocationElements(r *request.Request, v reflect.Value, buildGETQuery bo
 			if name == "" {
 				name = field.Name
 			}
-			if m.Kind() == reflect.Ptr {
+			if kind := m.Kind(); kind == reflect.Ptr {
 				m = m.Elem()
+			} else if kind == reflect.Interface {
+				if !m.Elem().IsValid() {
+					continue
+				}
 			}
 			if !m.IsValid() {
 				continue
@@ -95,16 +100,16 @@ func buildLocationElements(r *request.Request, v reflect.Value, buildGETQuery bo
 			var err error
 			switch field.Tag.Get("location") {
 			case "headers": // header maps
-				err = buildHeaderMap(&r.HTTPRequest.Header, m, field.Tag.Get("locationName"))
+				err = buildHeaderMap(&r.HTTPRequest.Header, m, field.Tag)
 			case "header":
-				err = buildHeader(&r.HTTPRequest.Header, m, name)
+				err = buildHeader(&r.HTTPRequest.Header, m, name, field.Tag)
 			case "uri":
-				err = buildURI(r.HTTPRequest.URL, m, name)
+				err = buildURI(r.HTTPRequest.URL, m, name, field.Tag)
 			case "querystring":
-				err = buildQueryString(query, m, name)
+				err = buildQueryString(query, m, name, field.Tag)
 			default:
 				if buildGETQuery {
-					err = buildQueryString(query, m, name)
+					err = buildQueryString(query, m, name, field.Tag)
 				}
 			}
 			r.Error = err
@@ -145,8 +150,8 @@ func buildBody(r *request.Request, v reflect.Value) {
 	}
 }
 
-func buildHeader(header *http.Header, v reflect.Value, name string) error {
-	str, err := convertType(v)
+func buildHeader(header *http.Header, v reflect.Value, name string, tag reflect.StructTag) error {
+	str, err := convertType(v, tag)
 	if err == errValueNotSet {
 		return nil
 	} else if err != nil {
@@ -158,9 +163,10 @@ func buildHeader(header *http.Header, v reflect.Value, name string) error {
 	return nil
 }
 
-func buildHeaderMap(header *http.Header, v reflect.Value, prefix string) error {
+func buildHeaderMap(header *http.Header, v reflect.Value, tag reflect.StructTag) error {
+	prefix := tag.Get("locationName")
 	for _, key := range v.MapKeys() {
-		str, err := convertType(v.MapIndex(key))
+		str, err := convertType(v.MapIndex(key), tag)
 		if err == errValueNotSet {
 			continue
 		} else if err != nil {
@@ -173,8 +179,8 @@ func buildHeaderMap(header *http.Header, v reflect.Value, prefix string) error {
 	return nil
 }
 
-func buildURI(u *url.URL, v reflect.Value, name string) error {
-	value, err := convertType(v)
+func buildURI(u *url.URL, v reflect.Value, name string, tag reflect.StructTag) error {
+	value, err := convertType(v, tag)
 	if err == errValueNotSet {
 		return nil
 	} else if err != nil {
@@ -190,7 +196,7 @@ func buildURI(u *url.URL, v reflect.Value, name string) error {
 	return nil
 }
 
-func buildQueryString(query url.Values, v reflect.Value, name string) error {
+func buildQueryString(query url.Values, v reflect.Value, name string, tag reflect.StructTag) error {
 	switch value := v.Interface().(type) {
 	case []*string:
 		for _, item := range value {
@@ -207,7 +213,7 @@ func buildQueryString(query url.Values, v reflect.Value, name string) error {
 			}
 		}
 	default:
-		str, err := convertType(v)
+		str, err := convertType(v, tag)
 		if err == errValueNotSet {
 			return nil
 		} else if err != nil {
@@ -246,7 +252,7 @@ func EscapePath(path string, encodeSep bool) string {
 	return buf.String()
 }
 
-func convertType(v reflect.Value) (string, error) {
+func convertType(v reflect.Value, tag reflect.StructTag) (string, error) {
 	v = reflect.Indirect(v)
 	if !v.IsValid() {
 		return "", errValueNotSet
@@ -266,6 +272,16 @@ func convertType(v reflect.Value) (string, error) {
 		str = strconv.FormatFloat(value, 'f', -1, 64)
 	case time.Time:
 		str = value.UTC().Format(RFC822)
+	case aws.JSONValue:
+		b, err := json.Marshal(value)
+		if err != nil {
+			return "", err
+		}
+		if tag.Get("location") == "header" {
+			str = base64.StdEncoding.EncodeToString(b)
+		} else {
+			str = string(b)
+		}
 	default:
 		err := fmt.Errorf("Unsupported value for param %v (%s)", v.Interface(), v.Type())
 		return "", err

vendor/github.com/aws/aws-sdk-go/private/protocol/rest/build_test.go

@@ -0,0 +1,63 @@
+package rest
+
+import (
+	"net/http"
+	"net/url"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/request"
+)
+
+func TestCleanPath(t *testing.T) {
+	uri := &url.URL{
+		Path:   "//foo//bar",
+		Scheme: "https",
+		Host:   "host",
+	}
+	cleanPath(uri)
+
+	expected := "https://host/foo/bar"
+	if a, e := uri.String(), expected; a != e {
+		t.Errorf("expect %q URI, got %q", e, a)
+	}
+}
+
+func TestMarshalPath(t *testing.T) {
+	in := struct {
+		Bucket *string `location:"uri" locationName:"bucket"`
+		Key    *string `location:"uri" locationName:"key"`
+	}{
+		Bucket: aws.String("mybucket"),
+		Key:    aws.String("my/cool+thing space/object世界"),
+	}
+
+	expectURL := `/mybucket/my/cool+thing space/object世界`
+	expectEscapedURL := `/mybucket/my/cool%2Bthing%20space/object%E4%B8%96%E7%95%8C`
+
+	req := &request.Request{
+		HTTPRequest: &http.Request{
+			URL: &url.URL{Scheme: "https", Host: "exmaple.com", Path: "/{bucket}/{key+}"},
+		},
+		Params: &in,
+	}
+
+	Build(req)
+
+	if req.Error != nil {
+		t.Fatalf("unexpected error, %v", req.Error)
+	}
+
+	if a, e := req.HTTPRequest.URL.Path, expectURL; a != e {
+		t.Errorf("expect %q URI, got %q", e, a)
+	}
+
+	if a, e := req.HTTPRequest.URL.RawPath, expectEscapedURL; a != e {
+		t.Errorf("expect %q escaped URI, got %q", e, a)
+	}
+
+	if a, e := req.HTTPRequest.URL.EscapedPath(), expectEscapedURL; a != e {
+		t.Errorf("expect %q escaped URI, got %q", e, a)
+	}
+
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/rest/rest_test.go

@@ -0,0 +1,63 @@
+package rest_test
+
+import (
+	"bytes"
+	"io/ioutil"
+	"net/http"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/client"
+	"github.com/aws/aws-sdk-go/aws/client/metadata"
+	"github.com/aws/aws-sdk-go/aws/request"
+	"github.com/aws/aws-sdk-go/aws/signer/v4"
+	"github.com/aws/aws-sdk-go/awstesting/unit"
+	"github.com/aws/aws-sdk-go/private/protocol/rest"
+)
+
+func TestUnsetHeaders(t *testing.T) {
+	cfg := &aws.Config{Region: aws.String("us-west-2")}
+	c := unit.Session.ClientConfig("testService", cfg)
+	svc := client.New(
+		*cfg,
+		metadata.ClientInfo{
+			ServiceName:   "testService",
+			SigningName:   c.SigningName,
+			SigningRegion: c.SigningRegion,
+			Endpoint:      c.Endpoint,
+			APIVersion:    "",
+		},
+		c.Handlers,
+	)
+
+	// Handlers
+	svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler)
+	svc.Handlers.Build.PushBackNamed(rest.BuildHandler)
+	svc.Handlers.Unmarshal.PushBackNamed(rest.UnmarshalHandler)
+	svc.Handlers.UnmarshalMeta.PushBackNamed(rest.UnmarshalMetaHandler)
+	op := &request.Operation{
+		Name:     "test-operation",
+		HTTPPath: "/",
+	}
+
+	input := &struct {
+		Foo aws.JSONValue `location:"header" locationName:"x-amz-foo" type:"jsonvalue"`
+		Bar aws.JSONValue `location:"header" locationName:"x-amz-bar" type:"jsonvalue"`
+	}{}
+
+	output := &struct {
+		Foo aws.JSONValue `location:"header" locationName:"x-amz-foo" type:"jsonvalue"`
+		Bar aws.JSONValue `location:"header" locationName:"x-amz-bar" type:"jsonvalue"`
+	}{}
+
+	req := svc.NewRequest(op, input, output)
+	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(bytes.NewBuffer(nil)), Header: http.Header{}}
+	req.HTTPResponse.Header.Set("X-Amz-Foo", "e30=")
+
+	// unmarshal response
+	rest.UnmarshalMeta(req)
+	rest.Unmarshal(req)
+	if req.Error != nil {
+		t.Fatal(req.Error)
+	}
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/rest/unmarshal.go

@@ -3,6 +3,7 @@ package rest
 import (
 	"bytes"
 	"encoding/base64"
+	"encoding/json"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -12,6 +13,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/aws/request"
 )
@@ -111,7 +113,7 @@ func unmarshalLocationElements(r *request.Request, v reflect.Value) {
 			case "statusCode":
 				unmarshalStatusCode(m, r.HTTPResponse.StatusCode)
 			case "header":
-				err := unmarshalHeader(m, r.HTTPResponse.Header.Get(name))
+				err := unmarshalHeader(m, r.HTTPResponse.Header.Get(name), field.Tag)
 				if err != nil {
 					r.Error = awserr.New("SerializationError", "failed to decode REST response", err)
 					break
@@ -158,8 +160,13 @@ func unmarshalHeaderMap(r reflect.Value, headers http.Header, prefix string) err
 	return nil
 }
 
-func unmarshalHeader(v reflect.Value, header string) error {
-	if !v.IsValid() || (header == "" && v.Elem().Kind() != reflect.String) {
+func unmarshalHeader(v reflect.Value, header string, tag reflect.StructTag) error {
+	isJSONValue := tag.Get("type") == "jsonvalue"
+	if isJSONValue {
+		if len(header) == 0 {
+			return nil
+		}
+	} else if !v.IsValid() || (header == "" && v.Elem().Kind() != reflect.String) {
 		return nil
 	}
 
@@ -196,6 +203,22 @@ func unmarshalHeader(v reflect.Value, header string) error {
 			return err
 		}
 		v.Set(reflect.ValueOf(&t))
+	case aws.JSONValue:
+		b := []byte(header)
+		var err error
+		if tag.Get("location") == "header" {
+			b, err = base64.StdEncoding.DecodeString(header)
+			if err != nil {
+				return err
+			}
+		}
+
+		m := aws.JSONValue{}
+		err = json.Unmarshal(b, &m)
+		if err != nil {
+			return err
+		}
+		v.Set(reflect.ValueOf(m))
 	default:
 		err := fmt.Errorf("Unsupported value for param %v (%s)", v.Interface(), v.Type())
 		return err

vendor/github.com/aws/aws-sdk-go/private/protocol/restjson/build_bench_test.go

@@ -0,0 +1,356 @@
+// +build bench
+
+package restjson_test
+
+import (
+	"bytes"
+	"encoding/json"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/request"
+	"github.com/aws/aws-sdk-go/awstesting"
+	"github.com/aws/aws-sdk-go/private/protocol/rest"
+	"github.com/aws/aws-sdk-go/private/protocol/restjson"
+	"github.com/aws/aws-sdk-go/service/elastictranscoder"
+)
+
+func BenchmarkRESTJSONBuild_Complex_elastictranscoderCreateJobInput(b *testing.B) {
+	svc := awstesting.NewClient()
+	svc.ServiceName = "elastictranscoder"
+	svc.APIVersion = "2012-09-25"
+
+	for i := 0; i < b.N; i++ {
+		r := svc.NewRequest(&request.Operation{Name: "CreateJobInput"}, restjsonBuildParms, nil)
+		restjson.Build(r)
+		if r.Error != nil {
+			b.Fatal("Unexpected error", r.Error)
+		}
+	}
+}
+
+func BenchmarkRESTBuild_Complex_elastictranscoderCreateJobInput(b *testing.B) {
+	svc := awstesting.NewClient()
+	svc.ServiceName = "elastictranscoder"
+	svc.APIVersion = "2012-09-25"
+
+	for i := 0; i < b.N; i++ {
+		r := svc.NewRequest(&request.Operation{Name: "CreateJobInput"}, restjsonBuildParms, nil)
+		rest.Build(r)
+		if r.Error != nil {
+			b.Fatal("Unexpected error", r.Error)
+		}
+	}
+}
+
+func BenchmarkEncodingJSONMarshal_Complex_elastictranscoderCreateJobInput(b *testing.B) {
+	params := restjsonBuildParms
+
+	for i := 0; i < b.N; i++ {
+		buf := &bytes.Buffer{}
+		encoder := json.NewEncoder(buf)
+		if err := encoder.Encode(params); err != nil {
+			b.Fatal("Unexpected error", err)
+		}
+	}
+}
+
+func BenchmarkRESTJSONBuild_Simple_elastictranscoderListJobsByPipeline(b *testing.B) {
+	svc := awstesting.NewClient()
+	svc.ServiceName = "elastictranscoder"
+	svc.APIVersion = "2012-09-25"
+
+	params := &elastictranscoder.ListJobsByPipelineInput{
+		PipelineId: aws.String("Id"), // Required
+		Ascending:  aws.String("Ascending"),
+		PageToken:  aws.String("Id"),
+	}
+
+	for i := 0; i < b.N; i++ {
+		r := svc.NewRequest(&request.Operation{Name: "ListJobsByPipeline"}, params, nil)
+		restjson.Build(r)
+		if r.Error != nil {
+			b.Fatal("Unexpected error", r.Error)
+		}
+	}
+}
+
+func BenchmarkRESTBuild_Simple_elastictranscoderListJobsByPipeline(b *testing.B) {
+	svc := awstesting.NewClient()
+	svc.ServiceName = "elastictranscoder"
+	svc.APIVersion = "2012-09-25"
+
+	params := &elastictranscoder.ListJobsByPipelineInput{
+		PipelineId: aws.String("Id"), // Required
+		Ascending:  aws.String("Ascending"),
+		PageToken:  aws.String("Id"),
+	}
+
+	for i := 0; i < b.N; i++ {
+		r := svc.NewRequest(&request.Operation{Name: "ListJobsByPipeline"}, params, nil)
+		rest.Build(r)
+		if r.Error != nil {
+			b.Fatal("Unexpected error", r.Error)
+		}
+	}
+}
+
+func BenchmarkEncodingJSONMarshal_Simple_elastictranscoderListJobsByPipeline(b *testing.B) {
+	params := &elastictranscoder.ListJobsByPipelineInput{
+		PipelineId: aws.String("Id"), // Required
+		Ascending:  aws.String("Ascending"),
+		PageToken:  aws.String("Id"),
+	}
+
+	for i := 0; i < b.N; i++ {
+		buf := &bytes.Buffer{}
+		encoder := json.NewEncoder(buf)
+		if err := encoder.Encode(params); err != nil {
+			b.Fatal("Unexpected error", err)
+		}
+	}
+}
+
+var restjsonBuildParms = &elastictranscoder.CreateJobInput{
+	Input: &elastictranscoder.JobInput{ // Required
+		AspectRatio: aws.String("AspectRatio"),
+		Container:   aws.String("JobContainer"),
+		DetectedProperties: &elastictranscoder.DetectedProperties{
+			DurationMillis: aws.Int64(1),
+			FileSize:       aws.Int64(1),
+			FrameRate:      aws.String("FloatString"),
+			Height:         aws.Int64(1),
+			Width:          aws.Int64(1),
+		},
+		Encryption: &elastictranscoder.Encryption{
+			InitializationVector: aws.String("ZeroTo255String"),
+			Key:                  aws.String("Base64EncodedString"),
+			KeyMd5:               aws.String("Base64EncodedString"),
+			Mode:                 aws.String("EncryptionMode"),
+		},
+		FrameRate:  aws.String("FrameRate"),
+		Interlaced: aws.String("Interlaced"),
+		Key:        aws.String("Key"),
+		Resolution: aws.String("Resolution"),
+	},
+	PipelineId: aws.String("Id"), // Required
+	Output: &elastictranscoder.CreateJobOutput{
+		AlbumArt: &elastictranscoder.JobAlbumArt{
+			Artwork: []*elastictranscoder.Artwork{
+				{ // Required
+					AlbumArtFormat: aws.String("JpgOrPng"),
+					Encryption: &elastictranscoder.Encryption{
+						InitializationVector: aws.String("ZeroTo255String"),
+						Key:                  aws.String("Base64EncodedString"),
+						KeyMd5:               aws.String("Base64EncodedString"),
+						Mode:                 aws.String("EncryptionMode"),
+					},
+					InputKey:      aws.String("WatermarkKey"),
+					MaxHeight:     aws.String("DigitsOrAuto"),
+					MaxWidth:      aws.String("DigitsOrAuto"),
+					PaddingPolicy: aws.String("PaddingPolicy"),
+					SizingPolicy:  aws.String("SizingPolicy"),
+				},
+				// More values...
+			},
+			MergePolicy: aws.String("MergePolicy"),
+		},
+		Captions: &elastictranscoder.Captions{
+			CaptionFormats: []*elastictranscoder.CaptionFormat{
+				{ // Required
+					Encryption: &elastictranscoder.Encryption{
+						InitializationVector: aws.String("ZeroTo255String"),
+						Key:                  aws.String("Base64EncodedString"),
+						KeyMd5:               aws.String("Base64EncodedString"),
+						Mode:                 aws.String("EncryptionMode"),
+					},
+					Format:  aws.String("CaptionFormatFormat"),
+					Pattern: aws.String("CaptionFormatPattern"),
+				},
+				// More values...
+			},
+			CaptionSources: []*elastictranscoder.CaptionSource{
+				{ // Required
+					Encryption: &elastictranscoder.Encryption{
+						InitializationVector: aws.String("ZeroTo255String"),
+						Key:                  aws.String("Base64EncodedString"),
+						KeyMd5:               aws.String("Base64EncodedString"),
+						Mode:                 aws.String("EncryptionMode"),
+					},
+					Key:        aws.String("Key"),
+					Label:      aws.String("Name"),
+					Language:   aws.String("Key"),
+					TimeOffset: aws.String("TimeOffset"),
+				},
+				// More values...
+			},
+			MergePolicy: aws.String("CaptionMergePolicy"),
+		},
+		Composition: []*elastictranscoder.Clip{
+			{ // Required
+				TimeSpan: &elastictranscoder.TimeSpan{
+					Duration:  aws.String("Time"),
+					StartTime: aws.String("Time"),
+				},
+			},
+			// More values...
+		},
+		Encryption: &elastictranscoder.Encryption{
+			InitializationVector: aws.String("ZeroTo255String"),
+			Key:                  aws.String("Base64EncodedString"),
+			KeyMd5:               aws.String("Base64EncodedString"),
+			Mode:                 aws.String("EncryptionMode"),
+		},
+		Key:             aws.String("Key"),
+		PresetId:        aws.String("Id"),
+		Rotate:          aws.String("Rotate"),
+		SegmentDuration: aws.String("FloatString"),
+		ThumbnailEncryption: &elastictranscoder.Encryption{
+			InitializationVector: aws.String("ZeroTo255String"),
+			Key:                  aws.String("Base64EncodedString"),
+			KeyMd5:               aws.String("Base64EncodedString"),
+			Mode:                 aws.String("EncryptionMode"),
+		},
+		ThumbnailPattern: aws.String("ThumbnailPattern"),
+		Watermarks: []*elastictranscoder.JobWatermark{
+			{ // Required
+				Encryption: &elastictranscoder.Encryption{
+					InitializationVector: aws.String("ZeroTo255String"),
+					Key:                  aws.String("Base64EncodedString"),
+					KeyMd5:               aws.String("Base64EncodedString"),
+					Mode:                 aws.String("EncryptionMode"),
+				},
+				InputKey:          aws.String("WatermarkKey"),
+				PresetWatermarkId: aws.String("PresetWatermarkId"),
+			},
+			// More values...
+		},
+	},
+	OutputKeyPrefix: aws.String("Key"),
+	Outputs: []*elastictranscoder.CreateJobOutput{
+		{ // Required
+			AlbumArt: &elastictranscoder.JobAlbumArt{
+				Artwork: []*elastictranscoder.Artwork{
+					{ // Required
+						AlbumArtFormat: aws.String("JpgOrPng"),
+						Encryption: &elastictranscoder.Encryption{
+							InitializationVector: aws.String("ZeroTo255String"),
+							Key:                  aws.String("Base64EncodedString"),
+							KeyMd5:               aws.String("Base64EncodedString"),
+							Mode:                 aws.String("EncryptionMode"),
+						},
+						InputKey:      aws.String("WatermarkKey"),
+						MaxHeight:     aws.String("DigitsOrAuto"),
+						MaxWidth:      aws.String("DigitsOrAuto"),
+						PaddingPolicy: aws.String("PaddingPolicy"),
+						SizingPolicy:  aws.String("SizingPolicy"),
+					},
+					// More values...
+				},
+				MergePolicy: aws.String("MergePolicy"),
+			},
+			Captions: &elastictranscoder.Captions{
+				CaptionFormats: []*elastictranscoder.CaptionFormat{
+					{ // Required
+						Encryption: &elastictranscoder.Encryption{
+							InitializationVector: aws.String("ZeroTo255String"),
+							Key:                  aws.String("Base64EncodedString"),
+							KeyMd5:               aws.String("Base64EncodedString"),
+							Mode:                 aws.String("EncryptionMode"),
+						},
+						Format:  aws.String("CaptionFormatFormat"),
+						Pattern: aws.String("CaptionFormatPattern"),
+					},
+					// More values...
+				},
+				CaptionSources: []*elastictranscoder.CaptionSource{
+					{ // Required
+						Encryption: &elastictranscoder.Encryption{
+							InitializationVector: aws.String("ZeroTo255String"),
+							Key:                  aws.String("Base64EncodedString"),
+							KeyMd5:               aws.String("Base64EncodedString"),
+							Mode:                 aws.String("EncryptionMode"),
+						},
+						Key:        aws.String("Key"),
+						Label:      aws.String("Name"),
+						Language:   aws.String("Key"),
+						TimeOffset: aws.String("TimeOffset"),
+					},
+					// More values...
+				},
+				MergePolicy: aws.String("CaptionMergePolicy"),
+			},
+			Composition: []*elastictranscoder.Clip{
+				{ // Required
+					TimeSpan: &elastictranscoder.TimeSpan{
+						Duration:  aws.String("Time"),
+						StartTime: aws.String("Time"),
+					},
+				},
+				// More values...
+			},
+			Encryption: &elastictranscoder.Encryption{
+				InitializationVector: aws.String("ZeroTo255String"),
+				Key:                  aws.String("Base64EncodedString"),
+				KeyMd5:               aws.String("Base64EncodedString"),
+				Mode:                 aws.String("EncryptionMode"),
+			},
+			Key:             aws.String("Key"),
+			PresetId:        aws.String("Id"),
+			Rotate:          aws.String("Rotate"),
+			SegmentDuration: aws.String("FloatString"),
+			ThumbnailEncryption: &elastictranscoder.Encryption{
+				InitializationVector: aws.String("ZeroTo255String"),
+				Key:                  aws.String("Base64EncodedString"),
+				KeyMd5:               aws.String("Base64EncodedString"),
+				Mode:                 aws.String("EncryptionMode"),
+			},
+			ThumbnailPattern: aws.String("ThumbnailPattern"),
+			Watermarks: []*elastictranscoder.JobWatermark{
+				{ // Required
+					Encryption: &elastictranscoder.Encryption{
+						InitializationVector: aws.String("ZeroTo255String"),
+						Key:                  aws.String("Base64EncodedString"),
+						KeyMd5:               aws.String("Base64EncodedString"),
+						Mode:                 aws.String("EncryptionMode"),
+					},
+					InputKey:          aws.String("WatermarkKey"),
+					PresetWatermarkId: aws.String("PresetWatermarkId"),
+				},
+				// More values...
+			},
+		},
+		// More values...
+	},
+	Playlists: []*elastictranscoder.CreateJobPlaylist{
+		{ // Required
+			Format: aws.String("PlaylistFormat"),
+			HlsContentProtection: &elastictranscoder.HlsContentProtection{
+				InitializationVector:  aws.String("ZeroTo255String"),
+				Key:                   aws.String("Base64EncodedString"),
+				KeyMd5:                aws.String("Base64EncodedString"),
+				KeyStoragePolicy:      aws.String("KeyStoragePolicy"),
+				LicenseAcquisitionUrl: aws.String("ZeroTo512String"),
+				Method:                aws.String("HlsContentProtectionMethod"),
+			},
+			Name: aws.String("Filename"),
+			OutputKeys: []*string{
+				aws.String("Key"), // Required
+				// More values...
+			},
+			PlayReadyDrm: &elastictranscoder.PlayReadyDrm{
+				Format:                aws.String("PlayReadyDrmFormatString"),
+				InitializationVector:  aws.String("ZeroTo255String"),
+				Key:                   aws.String("NonEmptyBase64EncodedString"),
+				KeyId:                 aws.String("KeyIdGuid"),
+				KeyMd5:                aws.String("NonEmptyBase64EncodedString"),
+				LicenseAcquisitionUrl: aws.String("OneTo512String"),
+			},
+		},
+		// More values...
+	},
+	UserMetadata: map[string]*string{
+		"Key": aws.String("String"), // Required
+		// More values...
+	},
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/restjson/restjson.go

@@ -0,0 +1,92 @@
+// Package restjson provides RESTful JSON serialization of AWS
+// requests and responses.
+package restjson
+
+//go:generate go run -tags codegen ../../../models/protocol_tests/generate.go ../../../models/protocol_tests/input/rest-json.json build_test.go
+//go:generate go run -tags codegen ../../../models/protocol_tests/generate.go ../../../models/protocol_tests/output/rest-json.json unmarshal_test.go
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"strings"
+
+	"github.com/aws/aws-sdk-go/aws/awserr"
+	"github.com/aws/aws-sdk-go/aws/request"
+	"github.com/aws/aws-sdk-go/private/protocol/jsonrpc"
+	"github.com/aws/aws-sdk-go/private/protocol/rest"
+)
+
+// BuildHandler is a named request handler for building restjson protocol requests
+var BuildHandler = request.NamedHandler{Name: "awssdk.restjson.Build", Fn: Build}
+
+// UnmarshalHandler is a named request handler for unmarshaling restjson protocol requests
+var UnmarshalHandler = request.NamedHandler{Name: "awssdk.restjson.Unmarshal", Fn: Unmarshal}
+
+// UnmarshalMetaHandler is a named request handler for unmarshaling restjson protocol request metadata
+var UnmarshalMetaHandler = request.NamedHandler{Name: "awssdk.restjson.UnmarshalMeta", Fn: UnmarshalMeta}
+
+// UnmarshalErrorHandler is a named request handler for unmarshaling restjson protocol request errors
+var UnmarshalErrorHandler = request.NamedHandler{Name: "awssdk.restjson.UnmarshalError", Fn: UnmarshalError}
+
+// Build builds a request for the REST JSON protocol.
+func Build(r *request.Request) {
+	rest.Build(r)
+
+	if t := rest.PayloadType(r.Params); t == "structure" || t == "" {
+		jsonrpc.Build(r)
+	}
+}
+
+// Unmarshal unmarshals a response body for the REST JSON protocol.
+func Unmarshal(r *request.Request) {
+	if t := rest.PayloadType(r.Data); t == "structure" || t == "" {
+		jsonrpc.Unmarshal(r)
+	} else {
+		rest.Unmarshal(r)
+	}
+}
+
+// UnmarshalMeta unmarshals response headers for the REST JSON protocol.
+func UnmarshalMeta(r *request.Request) {
+	rest.UnmarshalMeta(r)
+}
+
+// UnmarshalError unmarshals a response error for the REST JSON protocol.
+func UnmarshalError(r *request.Request) {
+	defer r.HTTPResponse.Body.Close()
+	code := r.HTTPResponse.Header.Get("X-Amzn-Errortype")
+	bodyBytes, err := ioutil.ReadAll(r.HTTPResponse.Body)
+	if err != nil {
+		r.Error = awserr.New("SerializationError", "failed reading REST JSON error response", err)
+		return
+	}
+	if len(bodyBytes) == 0 {
+		r.Error = awserr.NewRequestFailure(
+			awserr.New("SerializationError", r.HTTPResponse.Status, nil),
+			r.HTTPResponse.StatusCode,
+			"",
+		)
+		return
+	}
+	var jsonErr jsonErrorResponse
+	if err := json.Unmarshal(bodyBytes, &jsonErr); err != nil {
+		r.Error = awserr.New("SerializationError", "failed decoding REST JSON error response", err)
+		return
+	}
+
+	if code == "" {
+		code = jsonErr.Code
+	}
+
+	code = strings.SplitN(code, ":", 2)[0]
+	r.Error = awserr.NewRequestFailure(
+		awserr.New(code, jsonErr.Message, nil),
+		r.HTTPResponse.StatusCode,
+		r.RequestID,
+	)
+}
+
+type jsonErrorResponse struct {
+	Code    string `json:"code"`
+	Message string `json:"message"`
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/restxml/build_bench_test.go

@@ -0,0 +1,246 @@
+// +build bench
+
+package restxml_test
+
+import (
+	"testing"
+
+	"bytes"
+	"encoding/xml"
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/request"
+	"github.com/aws/aws-sdk-go/awstesting"
+	"github.com/aws/aws-sdk-go/private/protocol/restxml"
+	"github.com/aws/aws-sdk-go/service/cloudfront"
+)
+
+func BenchmarkRESTXMLBuild_Complex_cloudfrontCreateDistribution(b *testing.B) {
+	params := restxmlBuildCreateDistroParms
+
+	op := &request.Operation{
+		Name:       "CreateDistribution",
+		HTTPMethod: "POST",
+		HTTPPath:   "/2015-04-17/distribution/{DistributionId}/invalidation",
+	}
+
+	benchRESTXMLBuild(b, op, params)
+}
+
+func BenchmarkRESTXMLBuild_Simple_cloudfrontDeleteStreamingDistribution(b *testing.B) {
+	params := &cloudfront.DeleteDistributionInput{
+		Id:      aws.String("string"), // Required
+		IfMatch: aws.String("string"),
+	}
+	op := &request.Operation{
+		Name:       "DeleteStreamingDistribution",
+		HTTPMethod: "DELETE",
+		HTTPPath:   "/2015-04-17/streaming-distribution/{Id}",
+	}
+	benchRESTXMLBuild(b, op, params)
+}
+
+func BenchmarkEncodingXMLMarshal_Simple_cloudfrontDeleteStreamingDistribution(b *testing.B) {
+	params := &cloudfront.DeleteDistributionInput{
+		Id:      aws.String("string"), // Required
+		IfMatch: aws.String("string"),
+	}
+
+	for i := 0; i < b.N; i++ {
+		buf := &bytes.Buffer{}
+		encoder := xml.NewEncoder(buf)
+		if err := encoder.Encode(params); err != nil {
+			b.Fatal("Unexpected error", err)
+		}
+	}
+}
+
+func benchRESTXMLBuild(b *testing.B, op *request.Operation, params interface{}) {
+	svc := awstesting.NewClient()
+	svc.ServiceName = "cloudfront"
+	svc.APIVersion = "2015-04-17"
+
+	for i := 0; i < b.N; i++ {
+		r := svc.NewRequest(op, params, nil)
+		restxml.Build(r)
+		if r.Error != nil {
+			b.Fatal("Unexpected error", r.Error)
+		}
+	}
+}
+
+var restxmlBuildCreateDistroParms = &cloudfront.CreateDistributionInput{
+	DistributionConfig: &cloudfront.DistributionConfig{ // Required
+		CallerReference: aws.String("string"), // Required
+		Comment:         aws.String("string"), // Required
+		DefaultCacheBehavior: &cloudfront.DefaultCacheBehavior{ // Required
+			ForwardedValues: &cloudfront.ForwardedValues{ // Required
+				Cookies: &cloudfront.CookiePreference{ // Required
+					Forward: aws.String("ItemSelection"), // Required
+					WhitelistedNames: &cloudfront.CookieNames{
+						Quantity: aws.Int64(1), // Required
+						Items: []*string{
+							aws.String("string"), // Required
+							// More values...
+						},
+					},
+				},
+				QueryString: aws.Bool(true), // Required
+				Headers: &cloudfront.Headers{
+					Quantity: aws.Int64(1), // Required
+					Items: []*string{
+						aws.String("string"), // Required
+						// More values...
+					},
+				},
+			},
+			MinTTL:         aws.Int64(1),         // Required
+			TargetOriginId: aws.String("string"), // Required
+			TrustedSigners: &cloudfront.TrustedSigners{ // Required
+				Enabled:  aws.Bool(true), // Required
+				Quantity: aws.Int64(1),   // Required
+				Items: []*string{
+					aws.String("string"), // Required
+					// More values...
+				},
+			},
+			ViewerProtocolPolicy: aws.String("ViewerProtocolPolicy"), // Required
+			AllowedMethods: &cloudfront.AllowedMethods{
+				Items: []*string{ // Required
+					aws.String("Method"), // Required
+					// More values...
+				},
+				Quantity: aws.Int64(1), // Required
+				CachedMethods: &cloudfront.CachedMethods{
+					Items: []*string{ // Required
+						aws.String("Method"), // Required
+						// More values...
+					},
+					Quantity: aws.Int64(1), // Required
+				},
+			},
+			DefaultTTL:      aws.Int64(1),
+			MaxTTL:          aws.Int64(1),
+			SmoothStreaming: aws.Bool(true),
+		},
+		Enabled: aws.Bool(true), // Required
+		Origins: &cloudfront.Origins{ // Required
+			Quantity: aws.Int64(1), // Required
+			Items: []*cloudfront.Origin{
+				{ // Required
+					DomainName: aws.String("string"), // Required
+					Id:         aws.String("string"), // Required
+					CustomOriginConfig: &cloudfront.CustomOriginConfig{
+						HTTPPort:             aws.Int64(1),                       // Required
+						HTTPSPort:            aws.Int64(1),                       // Required
+						OriginProtocolPolicy: aws.String("OriginProtocolPolicy"), // Required
+					},
+					OriginPath: aws.String("string"),
+					S3OriginConfig: &cloudfront.S3OriginConfig{
+						OriginAccessIdentity: aws.String("string"), // Required
+					},
+				},
+				// More values...
+			},
+		},
+		Aliases: &cloudfront.Aliases{
+			Quantity: aws.Int64(1), // Required
+			Items: []*string{
+				aws.String("string"), // Required
+				// More values...
+			},
+		},
+		CacheBehaviors: &cloudfront.CacheBehaviors{
+			Quantity: aws.Int64(1), // Required
+			Items: []*cloudfront.CacheBehavior{
+				{ // Required
+					ForwardedValues: &cloudfront.ForwardedValues{ // Required
+						Cookies: &cloudfront.CookiePreference{ // Required
+							Forward: aws.String("ItemSelection"), // Required
+							WhitelistedNames: &cloudfront.CookieNames{
+								Quantity: aws.Int64(1), // Required
+								Items: []*string{
+									aws.String("string"), // Required
+									// More values...
+								},
+							},
+						},
+						QueryString: aws.Bool(true), // Required
+						Headers: &cloudfront.Headers{
+							Quantity: aws.Int64(1), // Required
+							Items: []*string{
+								aws.String("string"), // Required
+								// More values...
+							},
+						},
+					},
+					MinTTL:         aws.Int64(1),         // Required
+					PathPattern:    aws.String("string"), // Required
+					TargetOriginId: aws.String("string"), // Required
+					TrustedSigners: &cloudfront.TrustedSigners{ // Required
+						Enabled:  aws.Bool(true), // Required
+						Quantity: aws.Int64(1),   // Required
+						Items: []*string{
+							aws.String("string"), // Required
+							// More values...
+						},
+					},
+					ViewerProtocolPolicy: aws.String("ViewerProtocolPolicy"), // Required
+					AllowedMethods: &cloudfront.AllowedMethods{
+						Items: []*string{ // Required
+							aws.String("Method"), // Required
+							// More values...
+						},
+						Quantity: aws.Int64(1), // Required
+						CachedMethods: &cloudfront.CachedMethods{
+							Items: []*string{ // Required
+								aws.String("Method"), // Required
+								// More values...
+							},
+							Quantity: aws.Int64(1), // Required
+						},
+					},
+					DefaultTTL:      aws.Int64(1),
+					MaxTTL:          aws.Int64(1),
+					SmoothStreaming: aws.Bool(true),
+				},
+				// More values...
+			},
+		},
+		CustomErrorResponses: &cloudfront.CustomErrorResponses{
+			Quantity: aws.Int64(1), // Required
+			Items: []*cloudfront.CustomErrorResponse{
+				{ // Required
+					ErrorCode:          aws.Int64(1), // Required
+					ErrorCachingMinTTL: aws.Int64(1),
+					ResponseCode:       aws.String("string"),
+					ResponsePagePath:   aws.String("string"),
+				},
+				// More values...
+			},
+		},
+		DefaultRootObject: aws.String("string"),
+		Logging: &cloudfront.LoggingConfig{
+			Bucket:         aws.String("string"), // Required
+			Enabled:        aws.Bool(true),       // Required
+			IncludeCookies: aws.Bool(true),       // Required
+			Prefix:         aws.String("string"), // Required
+		},
+		PriceClass: aws.String("PriceClass"),
+		Restrictions: &cloudfront.Restrictions{
+			GeoRestriction: &cloudfront.GeoRestriction{ // Required
+				Quantity:        aws.Int64(1),                     // Required
+				RestrictionType: aws.String("GeoRestrictionType"), // Required
+				Items: []*string{
+					aws.String("string"), // Required
+					// More values...
+				},
+			},
+		},
+		ViewerCertificate: &cloudfront.ViewerCertificate{
+			CloudFrontDefaultCertificate: aws.Bool(true),
+			IAMCertificateId:             aws.String("string"),
+			MinimumProtocolVersion:       aws.String("MinimumProtocolVersion"),
+			SSLSupportMethod:             aws.String("SSLSupportMethod"),
+		},
+	},
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/unmarshal_test.go

@@ -0,0 +1,40 @@
+package protocol_test
+
+import (
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws/request"
+	"github.com/aws/aws-sdk-go/private/protocol"
+	"github.com/stretchr/testify/assert"
+)
+
+type mockCloser struct {
+	*strings.Reader
+	Closed bool
+}
+
+func (m *mockCloser) Close() error {
+	m.Closed = true
+	return nil
+}
+
+func TestUnmarshalDrainBody(t *testing.T) {
+	b := &mockCloser{Reader: strings.NewReader("example body")}
+	r := &request.Request{HTTPResponse: &http.Response{
+		Body: b,
+	}}
+
+	protocol.UnmarshalDiscardBody(r)
+	assert.NoError(t, r.Error)
+	assert.Equal(t, 0, b.Len())
+	assert.True(t, b.Closed)
+}
+
+func TestUnmarshalDrainBodyNoBody(t *testing.T) {
+	r := &request.Request{HTTPResponse: &http.Response{}}
+
+	protocol.UnmarshalDiscardBody(r)
+	assert.NoError(t, r.Error)
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/build.go

@@ -131,7 +131,6 @@ func (b *xmlBuilder) buildStruct(value reflect.Value, current *XMLNode, tag refl
 			continue
 		}
 
-
 		mTag := field.Tag
 		if mTag.Get("location") != "" { // skip non-body members
 			continue

vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/unmarshal.go

@@ -15,7 +15,10 @@ import (
 // needs to match the shape of the XML expected to be decoded.
 // If the shape doesn't match unmarshaling will fail.
 func UnmarshalXML(v interface{}, d *xml.Decoder, wrapper string) error {
-	n, _ := XMLToStruct(d, nil)
+	n, err := XMLToStruct(d, nil)
+	if err != nil {
+		return err
+	}
 	if n.Children != nil {
 		for _, root := range n.Children {
 			for _, c := range root {
@@ -23,7 +26,7 @@ func UnmarshalXML(v interface{}, d *xml.Decoder, wrapper string) error {
 					c = wrappedChild[0] // pull out wrapped element
 				}
 
-				err := parse(reflect.ValueOf(v), c, "")
+				err = parse(reflect.ValueOf(v), c, "")
 				if err != nil {
 					if err == io.EOF {
 						return nil

vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/unmarshal_test.go

@@ -0,0 +1,142 @@
+package xmlutil
+
+import (
+	"encoding/xml"
+	"fmt"
+	"io"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/awsutil"
+)
+
+type mockBody struct {
+	DoneErr error
+	Body    io.Reader
+}
+
+func (m *mockBody) Read(p []byte) (int, error) {
+	n, err := m.Body.Read(p)
+	if (n == 0 || err == io.EOF) && m.DoneErr != nil {
+		return n, m.DoneErr
+	}
+
+	return n, err
+}
+
+type mockOutput struct {
+	_       struct{}          `type:"structure"`
+	String  *string           `type:"string"`
+	Integer *int64            `type:"integer"`
+	Nested  *mockNestedStruct `type:"structure"`
+	List    []*mockListElem   `locationName:"List" locationNameList:"Elem" type:"list"`
+	Closed  *mockClosedTags   `type:"structure"`
+}
+type mockNestedStruct struct {
+	_            struct{} `type:"structure"`
+	NestedString *string  `type:"string"`
+	NestedInt    *int64   `type:"integer"`
+}
+type mockClosedTags struct {
+	_    struct{} `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"`
+	Attr *string  `locationName:"xsi:attrval" type:"string" xmlAttribute:"true"`
+}
+type mockListElem struct {
+	_          struct{}            `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"`
+	String     *string             `type:"string"`
+	NestedElem *mockNestedListElem `type:"structure"`
+}
+type mockNestedListElem struct {
+	_ struct{} `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"`
+
+	String *string `type:"string"`
+	Type   *string `locationName:"xsi:type" type:"string" xmlAttribute:"true"`
+}
+
+func TestUnmarshal(t *testing.T) {
+	const xmlBodyStr = `<?xml version="1.0" encoding="UTF-8"?>
+<MockResponse xmlns="http://xmlns.example.com">
+	<String>string value</String>
+	<Integer>123</Integer>
+	<Closed xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:attrval="attr value"/>
+	<Nested>
+		<NestedString>nested string value</NestedString>
+		<NestedInt>321</NestedInt>
+	</Nested>
+	<List>
+		<Elem>
+			<NestedElem xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="type">
+				<String>nested elem string value</String>
+			</NestedElem>
+			<String>elem string value</String>
+		</Elem>
+	</List>
+</MockResponse>`
+
+	expect := mockOutput{
+		String:  aws.String("string value"),
+		Integer: aws.Int64(123),
+		Closed: &mockClosedTags{
+			Attr: aws.String("attr value"),
+		},
+		Nested: &mockNestedStruct{
+			NestedString: aws.String("nested string value"),
+			NestedInt:    aws.Int64(321),
+		},
+		List: []*mockListElem{
+			{
+				String: aws.String("elem string value"),
+				NestedElem: &mockNestedListElem{
+					String: aws.String("nested elem string value"),
+					Type:   aws.String("type"),
+				},
+			},
+		},
+	}
+
+	actual := mockOutput{}
+	decoder := xml.NewDecoder(strings.NewReader(xmlBodyStr))
+	err := UnmarshalXML(&actual, decoder, "")
+	if err != nil {
+		t.Fatalf("expect no error, got %v", err)
+	}
+
+	if !reflect.DeepEqual(expect, actual) {
+		t.Errorf("expect unmarshal to match\nExpect: %s\nActual: %s",
+			awsutil.Prettify(expect), awsutil.Prettify(actual))
+	}
+}
+
+func TestUnmarshal_UnexpectedEOF(t *testing.T) {
+	const partialXMLBody = `<?xml version="1.0" encoding="UTF-8"?>
+	<First>first value</First>
+	<Second>Second val`
+
+	out := struct {
+		First  *string `locationName:"First" type:"string"`
+		Second *string `locationName:"Second" type:"string"`
+	}{}
+
+	expect := out
+	expect.First = aws.String("first")
+	expect.Second = aws.String("second")
+
+	expectErr := fmt.Errorf("expected read error")
+
+	body := &mockBody{
+		DoneErr: expectErr,
+		Body:    strings.NewReader(partialXMLBody),
+	}
+
+	decoder := xml.NewDecoder(body)
+	err := UnmarshalXML(&out, decoder, "")
+
+	if err == nil {
+		t.Fatalf("expect error, got none")
+	}
+	if e, a := expectErr, err; e != a {
+		t.Errorf("expect %v error in %v, but was not", e, a)
+	}
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/xml_to_struct.go

@@ -40,11 +40,16 @@ func XMLToStruct(d *xml.Decoder, s *xml.StartElement) (*XMLNode, error) {
 	out := &XMLNode{}
 	for {
 		tok, err := d.Token()
-		if tok == nil || err == io.EOF {
-			break
-		}
 		if err != nil {
-			return out, err
+			if err == io.EOF {
+				break
+			} else {
+				return out, err
+			}
+		}
+
+		if tok == nil {
+			break
 		}
 
 		switch typed := tok.(type) {

vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/xml_to_struct_test.go

@@ -0,0 +1,66 @@
+package xmlutil_test
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/awstesting/unit"
+	"github.com/aws/aws-sdk-go/service/s3"
+)
+
+func TestUnmarshal(t *testing.T) {
+	xmlVal := []byte(`<?xml version="1.0" encoding="UTF-8"?>
+<AccessControlPolicy xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+	<Owner>
+		<ID>foo-id</ID>
+		<DisplayName>user</DisplayName>
+	</Owner>
+	<AccessControlList>
+		<Grant>
+		<Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="type">
+			<ID>foo-id</ID>
+			<DisplayName>user</DisplayName>
+		</Grantee>
+		<Permission>FULL_CONTROL</Permission>
+		</Grant>
+	</AccessControlList>
+</AccessControlPolicy>`)
+
+	var server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Write(xmlVal)
+	}))
+
+	sess := unit.Session
+	sess.Config.Endpoint = &server.URL
+	sess.Config.S3ForcePathStyle = aws.Bool(true)
+	svc := s3.New(sess)
+
+	out, err := svc.GetBucketAcl(&s3.GetBucketAclInput{
+		Bucket: aws.String("foo"),
+	})
+
+	assert.NoError(t, err)
+
+	expected := &s3.GetBucketAclOutput{
+		Grants: []*s3.Grant{
+			{
+				Grantee: &s3.Grantee{
+					DisplayName: aws.String("user"),
+					ID:          aws.String("foo-id"),
+					Type:        aws.String("type"),
+				},
+				Permission: aws.String("FULL_CONTROL"),
+			},
+		},
+
+		Owner: &s3.Owner{
+			DisplayName: aws.String("user"),
+			ID:          aws.String("foo-id"),
+		},
+	}
+	assert.Equal(t, expected, out)
+}