vendor: update all dependencies

vendor/github.com/aws/aws-sdk-go/private/model/api/api.go

@@ -10,6 +10,7 @@ import (
 	"io/ioutil"
 	"path"
 	"path/filepath"
+	"regexp"
 	"sort"
 	"strings"
 	"text/template"
@@ -54,6 +55,8 @@ type API struct {
 	path        string
 
 	BaseCrosslinkURL string
+
+	HasEventStream bool `json:"-"`
 }
 
 // A Metadata is the metadata about an API's definition.
@@ -69,6 +72,7 @@ type Metadata struct {
 	Protocol            string
 	UID                 string
 	EndpointsID         string
+	ServiceID           string
 
 	NoResolveEndpoint bool
 }
@@ -416,6 +420,28 @@ var tplServiceDoc = template.Must(template.New("service docs").Funcs(template.Fu
 // https://docs.aws.amazon.com/sdk-for-go/api/service/{{ .PackageName }}/#New
 `))
 
+var serviceIDRegex = regexp.MustCompile("[^a-zA-Z0-9 ]+")
+var prefixDigitRegex = regexp.MustCompile("^[0-9]+")
+
+// ServiceID will return a unique identifier specific to a service.
+func ServiceID(a *API) string {
+	if len(a.Metadata.ServiceID) > 0 {
+		return a.Metadata.ServiceID
+	}
+
+	name := a.Metadata.ServiceAbbreviation
+	if len(name) == 0 {
+		name = a.Metadata.ServiceFullName
+	}
+
+	name = strings.Replace(name, "Amazon", "", -1)
+	name = strings.Replace(name, "AWS", "", -1)
+	name = serviceIDRegex.ReplaceAllString(name, "")
+	name = prefixDigitRegex.ReplaceAllString(name, "")
+	name = strings.TrimSpace(name)
+	return name
+}
+
 // A tplService defines the template for the service generated code.
 var tplService = template.Must(template.New("service").Funcs(template.FuncMap{
 	"ServiceNameValue": func(a *API) string {
@@ -440,6 +466,14 @@ var tplService = template.Must(template.New("service").Funcs(template.FuncMap{
 
 		return "EndpointsID"
 	},
+	"ServiceIDVar": func(a *API) string {
+		if a.NoConstServiceNames {
+			return fmt.Sprintf("%q", ServiceID(a))
+		}
+
+		return "ServiceID"
+	},
+	"ServiceID": ServiceID,
 }).Parse(`
 // {{ .StructName }} provides the API operation methods for making requests to
 // {{ .Metadata.ServiceFullName }}. See this package's package overview docs
@@ -464,6 +498,7 @@ var initRequest func(*request.Request)
 const (
 	ServiceName = "{{ .Metadata.EndpointPrefix }}" // Service endpoint prefix API calls made to.
 	EndpointsID = {{ EndpointsIDConstValue . }} // Service ID for Regions and Endpoints metadata.
+	ServiceID = "{{ ServiceID . }}" // ServiceID is a unique identifer of a specific service
 )
 {{- end }}
 
@@ -504,6 +539,7 @@ func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegio
     		cfg,
     		metadata.ClientInfo{
 			ServiceName: {{ ServiceNameValue . }},
+			ServiceID : {{ ServiceIDVar . }},
 			SigningName: signingName,
 			SigningRegion: signingRegion,
 			Endpoint:     endpoint,
@@ -528,6 +564,9 @@ func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegio
 	svc.Handlers.Unmarshal.PushBackNamed({{ .ProtocolPackage }}.UnmarshalHandler)
 	svc.Handlers.UnmarshalMeta.PushBackNamed({{ .ProtocolPackage }}.UnmarshalMetaHandler)
 	svc.Handlers.UnmarshalError.PushBackNamed({{ .ProtocolPackage }}.UnmarshalErrorHandler)
+	{{ if .HasEventStream }}
+	svc.Handlers.UnmarshalStream.PushBackNamed({{ .ProtocolPackage }}.UnmarshalHandler)
+	{{ end }}
 
 	{{ if .UseInitMethods }}// Run custom client initialization if present
 	if initClient != nil {

vendor/github.com/aws/aws-sdk-go/private/model/api/eventstream.go

@@ -2,27 +2,536 @@
 
 package api
 
-func (a *API) suppressEventStreams() {
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"text/template"
+)
+
+// EventStreamAPI provides details about the event stream async API and
+// associated EventStream shapes.
+type EventStreamAPI struct {
+	Name      string
+	Operation *Operation
+	Shape     *Shape
+	Inbound   *EventStream
+	Outbound  *EventStream
+}
+
+// EventStream represents a single eventstream group (input/output) and the
+// modeled events that are known for the stream.
+type EventStream struct {
+	Name   string
+	Shape  *Shape
+	Events []*Event
+}
+
+// Event is a single EventStream event that can be sent or received in an
+// EventStream.
+type Event struct {
+	Name  string
+	Shape *Shape
+	For   *EventStream
+}
+
+// ShapeDoc returns the docstring for the EventStream API.
+func (esAPI *EventStreamAPI) ShapeDoc() string {
+	tmpl := template.Must(template.New("eventStreamShapeDoc").Parse(`
+{{- $.Name }} provides handling of EventStreams for
+the {{ $.Operation.ExportedName }} API. 
+{{- if $.Inbound }}
+
+Use this type to receive {{ $.Inbound.Name }} events. The events
+can be read from the Events channel member.
+
+The events that can be received are:
+{{ range $_, $event := $.Inbound.Events }}
+    * {{ $event.Shape.ShapeName }}
+{{- end }}
+
+{{- end }}
+
+{{- if $.Outbound }}
+
+Use this type to send {{ $.Outbound.Name }} events. The events 
+can be sent with the Send method.
+
+The events that can be sent are:
+{{ range $_, $event := $.Outbound.Events -}}
+    * {{ $event.Shape.ShapeName }}
+{{- end }}
+
+{{- end }}`))
+
+	var w bytes.Buffer
+	if err := tmpl.Execute(&w, esAPI); err != nil {
+		panic(fmt.Sprintf("failed to generate eventstream shape template for %v, %v", esAPI.Name, err))
+	}
+
+	return commentify(w.String())
+}
+
+func eventStreamAPIShapeRefDoc(refName string) string {
+	return commentify(fmt.Sprintf("Use %s to use the API's stream.", refName))
+}
+
+func (a *API) setupEventStreams() {
 	const eventStreamMemberName = "EventStream"
 
-	for name, op := range a.Operations {
-		outbound := hasEventStream(op.InputRef.Shape)
-		inbound := hasEventStream(op.OutputRef.Shape)
+	for _, op := range a.Operations {
+		outbound := setupEventStream(op.InputRef.Shape)
+		inbound := setupEventStream(op.OutputRef.Shape)
 
-		if !(outbound || inbound) {
+		if outbound == nil && inbound == nil {
 			continue
 		}
 
-		a.removeOperation(name)
+		if outbound != nil {
+			panic(fmt.Sprintf("Outbound stream support not implemented, %s, %s",
+				outbound.Name, outbound.Shape.ShapeName))
+		}
+
+		switch a.Metadata.Protocol {
+		case `rest-json`, `rest-xml`, `json`:
+		default:
+			panic(fmt.Sprintf("EventStream not supported for protocol %v",
+				a.Metadata.Protocol))
+		}
+
+		eventStreamAPI := &EventStreamAPI{
+			Name:      op.ExportedName + eventStreamMemberName,
+			Operation: op,
+			Outbound:  outbound,
+			Inbound:   inbound,
+		}
+
+		streamShape := &Shape{
+			API:            a,
+			ShapeName:      eventStreamAPI.Name,
+			Documentation:  eventStreamAPI.ShapeDoc(),
+			Type:           "structure",
+			EventStreamAPI: eventStreamAPI,
+		}
+		streamShapeRef := &ShapeRef{
+			API:           a,
+			ShapeName:     streamShape.ShapeName,
+			Shape:         streamShape,
+			Documentation: eventStreamAPIShapeRefDoc(eventStreamMemberName),
+		}
+		streamShape.refs = []*ShapeRef{streamShapeRef}
+		eventStreamAPI.Shape = streamShape
+
+		if _, ok := op.OutputRef.Shape.MemberRefs[eventStreamMemberName]; ok {
+			panic(fmt.Sprintf("shape ref already exists, %s.%s",
+				op.OutputRef.Shape.ShapeName, eventStreamMemberName))
+		}
+		op.OutputRef.Shape.MemberRefs[eventStreamMemberName] = streamShapeRef
+		op.OutputRef.Shape.EventStreamsMemberName = eventStreamMemberName
+		if _, ok := a.Shapes[streamShape.ShapeName]; ok {
+			panic("shape already exists, " + streamShape.ShapeName)
+		}
+		a.Shapes[streamShape.ShapeName] = streamShape
+
+		a.HasEventStream = true
 	}
 }
 
-func hasEventStream(topShape *Shape) bool {
-	for _, ref := range topShape.MemberRefs {
-		if ref.Shape.IsEventStream {
-			return true
+func setupEventStream(topShape *Shape) *EventStream {
+	var eventStream *EventStream
+	for refName, ref := range topShape.MemberRefs {
+		if !ref.Shape.IsEventStream {
+			continue
+		}
+		if eventStream != nil {
+			panic(fmt.Sprintf("multiple shape ref eventstreams, %s, prev: %s",
+				refName, eventStream.Name))
+		}
+
+		eventStream = &EventStream{
+			Name:  ref.Shape.ShapeName,
+			Shape: ref.Shape,
+		}
+		for _, eventRefName := range ref.Shape.MemberNames() {
+			eventRef := ref.Shape.MemberRefs[eventRefName]
+			if !eventRef.Shape.IsEvent {
+				panic(fmt.Sprintf("unexpected non-event member reference %s.%s",
+					ref.Shape.ShapeName, eventRefName))
+			}
+
+			updateEventPayloadRef(eventRef.Shape)
+
+			eventRef.Shape.EventFor = append(eventRef.Shape.EventFor, eventStream)
+			eventStream.Events = append(eventStream.Events, &Event{
+				Name:  eventRefName,
+				Shape: eventRef.Shape,
+				For:   eventStream,
+			})
+		}
+
+		// Remove the eventstream references as they will be added elsewhere.
+		ref.Shape.removeRef(ref)
+		delete(topShape.MemberRefs, refName)
+		delete(topShape.API.Shapes, ref.Shape.ShapeName)
+	}
+
+	return eventStream
+}
+
+func updateEventPayloadRef(parent *Shape) {
+	refName := parent.PayloadRefName()
+	if len(refName) == 0 {
+		return
+	}
+
+	payloadRef := parent.MemberRefs[refName]
+
+	if payloadRef.Shape.Type == "blob" {
+		return
+	}
+
+	if len(payloadRef.LocationName) != 0 {
+		return
+	}
+
+	payloadRef.LocationName = refName
+}
+
+func renderEventStreamAPIShape(w io.Writer, s *Shape) error {
+	// Imports needed by the EventStream APIs.
+	s.API.imports["bytes"] = true
+	s.API.imports["io"] = true
+	s.API.imports["sync"] = true
+	s.API.imports["sync/atomic"] = true
+	s.API.imports["github.com/aws/aws-sdk-go/private/protocol/eventstream"] = true
+	s.API.imports["github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi"] = true
+
+	return eventStreamAPIShapeTmpl.Execute(w, s)
+}
+
+// EventStreamReaderInterfaceName returns the interface name for the
+// EventStream's reader interface.
+func EventStreamReaderInterfaceName(s *Shape) string {
+	return s.ShapeName + "Reader"
+}
+
+// Template for an EventStream API Shape that will provide read/writing events
+// across the EventStream. This is a special shape that's only public members
+// are the Events channel and a Close and Err method.
+//
+// Executed in the context of a Shape.
+var eventStreamAPIShapeTmpl = func() *template.Template {
+	t := template.Must(
+		template.New("eventStreamAPIShapeTmpl").
+			Funcs(template.FuncMap{}).
+			Parse(eventStreamAPITmplDef),
+	)
+
+	template.Must(
+		t.AddParseTree(
+			"eventStreamAPIReaderTmpl", eventStreamAPIReaderTmpl.Tree),
+	)
+
+	return t
+}()
+
+const eventStreamAPITmplDef = `
+{{ $.Documentation }}
+type {{ $.ShapeName }} struct {
+	{{- if $.EventStreamAPI.Inbound }}
+		// Reader is the EventStream reader for the {{ $.EventStreamAPI.Inbound.Name }}
+		// events. This value is automatically set by the SDK when the API call is made
+		// Use this member when unit testing your code with the SDK to mock out the
+		// EventStream Reader.
+		//
+		// Must not be nil.
+		Reader {{ $.ShapeName }}Reader
+
+	{{ end -}}
+
+	{{- if $.EventStreamAPI.Outbound }}
+		// Writer is the EventStream reader for the {{ $.EventStreamAPI.Inbound.Name }}
+		// events. This value is automatically set by the SDK when the API call is made
+		// Use this member when unit testing your code with the SDK to mock out the
+		// EventStream Writer.
+		//
+		// Must not be nil.
+		Writer *{{ $.ShapeName }}Writer
+
+	{{ end -}}
+
+	// StreamCloser is the io.Closer for the EventStream connection. For HTTP
+	// EventStream this is the response Body. The stream will be closed when
+	// the Close method of the EventStream is called.
+	StreamCloser io.Closer
+}
+
+// Close closes the EventStream. This will also cause the Events channel to be
+// closed. You can use the closing of the Events channel to terminate your
+// application's read from the API's EventStream.
+{{- if $.EventStreamAPI.Inbound }}
+//
+// Will close the underlying EventStream reader. For EventStream over HTTP
+// connection this will also close the HTTP connection.
+{{ end -}}
+//
+// Close must be called when done using the EventStream API. Not calling Close
+// may result in resource leaks.
+func (es *{{ $.ShapeName }}) Close() (err error) { 
+	{{- if $.EventStreamAPI.Inbound }}
+		es.Reader.Close()
+	{{ end -}}
+	{{- if $.EventStreamAPI.Outbound }}
+		es.Writer.Close()
+	{{ end -}}
+
+	return es.Err()
+}
+
+// Err returns any error that occurred while reading EventStream Events from
+// the service API's response. Returns nil if there were no errors.
+func (es *{{ $.ShapeName }}) Err() error { 
+	{{- if $.EventStreamAPI.Outbound }}
+		if err := es.Writer.Err(); err != nil {
+			return err
+		}
+	{{ end -}}
+
+	{{- if $.EventStreamAPI.Inbound }}
+		if err := es.Reader.Err(); err != nil {
+			return err
+		}
+	{{ end -}}
+
+	es.StreamCloser.Close()
+
+	return nil
+}
+
+{{ if $.EventStreamAPI.Inbound }}
+	// Events returns a channel to read EventStream Events from the 
+	// {{ $.EventStreamAPI.Operation.ExportedName }} API.
+	//
+	// These events are:
+	// {{ range $_, $event := $.EventStreamAPI.Inbound.Events }}
+	//     * {{ $event.Shape.ShapeName }}
+	{{- end }}
+	func (es *{{ $.ShapeName }}) Events() <-chan {{ $.EventStreamAPI.Inbound.Name }}Event {
+		return es.Reader.Events()
+	}
+
+	{{ template "eventStreamAPIReaderTmpl" $ }}
+{{ end }}
+
+{{ if $.EventStreamAPI.Outbound }}
+	// TODO writer helper method.
+{{ end }}
+
+`
+
+var eventStreamAPIReaderTmpl = template.Must(template.New("eventStreamAPIReaderTmpl").
+	Funcs(template.FuncMap{}).
+	Parse(`
+// {{ $.EventStreamAPI.Inbound.Name }}Event groups together all EventStream
+// events read from the {{ $.EventStreamAPI.Operation.ExportedName }} API.
+//
+// These events are:
+// {{ range $_, $event := $.EventStreamAPI.Inbound.Events }}
+//     * {{ $event.Shape.ShapeName }}
+{{- end }}
+type {{ $.EventStreamAPI.Inbound.Name }}Event interface {
+	event{{ $.EventStreamAPI.Name }}()
+}
+
+// {{ $.ShapeName }}Reader provides the interface for reading EventStream
+// Events from the {{ $.EventStreamAPI.Operation.ExportedName }} API. The
+// default implementation for this interface will be {{ $.ShapeName }}.
+//
+// The reader's Close method must allow multiple concurrent calls.
+//
+// These events are:
+// {{ range $_, $event := $.EventStreamAPI.Inbound.Events }}
+//     * {{ $event.Shape.ShapeName }}
+{{- end }}
+type {{ $.ShapeName }}Reader interface {
+	// Returns a channel of events as they are read from the event stream.
+	Events() <-chan {{ $.EventStreamAPI.Inbound.Name }}Event
+
+	// Close will close the underlying event stream reader. For event stream over
+	// HTTP this will also close the HTTP connection.
+	Close() error
+
+	// Returns any error that has occured while reading from the event stream.
+	Err() error
+}
+
+type read{{ $.ShapeName }} struct {
+	eventReader *eventstreamapi.EventReader
+	stream chan {{ $.EventStreamAPI.Inbound.Name }}Event
+	errVal atomic.Value
+
+	done      chan struct{}
+	closeOnce sync.Once
+}
+
+func newRead{{ $.ShapeName }}(
+	reader io.ReadCloser,
+	unmarshalers request.HandlerList,
+	logger aws.Logger,
+	logLevel aws.LogLevelType,
+) *read{{ $.ShapeName }} {
+	r := &read{{ $.ShapeName }}{
+		stream: make(chan {{ $.EventStreamAPI.Inbound.Name }}Event),
+		done: make(chan struct{}),
+	}
+
+	r.eventReader = eventstreamapi.NewEventReader(
+		reader,
+		protocol.HandlerPayloadUnmarshal{
+			Unmarshalers: unmarshalers,
+		},
+		r.unmarshalerForEventType,
+	)
+	r.eventReader.UseLogger(logger, logLevel)
+
+	return r
+}
+
+// Close will close the underlying event stream reader. For EventStream over
+// HTTP this will also close the HTTP connection.
+func (r *read{{ $.ShapeName }}) Close() error {
+	r.closeOnce.Do(r.safeClose)
+
+	return r.Err()
+}
+
+func (r *read{{ $.ShapeName }}) safeClose() {
+	close(r.done)
+	err := r.eventReader.Close()
+	if err != nil {
+		r.errVal.Store(err)
+	}
+}
+
+func (r *read{{ $.ShapeName }}) Err() error {
+	if v := r.errVal.Load(); v != nil {
+		return v.(error)
+	}
+
+	return nil
+}
+
+func (r *read{{ $.ShapeName }}) Events() <-chan {{ $.EventStreamAPI.Inbound.Name }}Event {
+	return r.stream
+}
+
+func (r *read{{ $.ShapeName }}) readEventStream() {
+	defer close(r.stream)
+
+	for {
+		event, err := r.eventReader.ReadEvent()
+		if err != nil {
+			if err == io.EOF {
+				return
+			}
+			select {
+			case <-r.done:
+				// If closed already ignore the error
+				return
+			default:
+			}
+			r.errVal.Store(err)
+			return
+		}
+
+		select {
+		case r.stream <- event.({{ $.EventStreamAPI.Inbound.Name }}Event):
+		case <-r.done:
+			return
 		}
 	}
-
-	return false
 }
+
+func (r *read{{ $.ShapeName }}) unmarshalerForEventType(
+	eventType string,
+) (eventstreamapi.Unmarshaler, error) {
+	switch eventType {
+		{{- range $_, $event := $.EventStreamAPI.Inbound.Events }}
+			case {{ printf "%q" $event.Name }}:
+				return &{{ $event.Shape.ShapeName }}{}, nil
+		{{ end -}}
+	default:
+		return nil, fmt.Errorf(
+			"unknown event type name, %s, for {{ $.ShapeName }}", eventType)
+	}
+}
+`))
+
+// Template for the EventStream API Output shape that contains the EventStream
+// member.
+//
+// Executed in the context of a Shape.
+var eventStreamAPILoopMethodTmpl = template.Must(
+	template.New("eventStreamAPILoopMethodTmpl").Parse(`
+func (s *{{ $.ShapeName }}) runEventStreamLoop(r *request.Request) {
+	if r.Error != nil {
+		return
+	}
+
+	{{- $esMemberRef := index $.MemberRefs $.EventStreamsMemberName }}
+	{{- if $esMemberRef.Shape.EventStreamAPI.Inbound }}
+		reader := newRead{{ $esMemberRef.ShapeName }}(
+			r.HTTPResponse.Body,
+			r.Handlers.UnmarshalStream,
+			r.Config.Logger,
+			r.Config.LogLevel.Value(),
+		)
+		go reader.readEventStream()
+
+		eventStream := &{{ $esMemberRef.ShapeName }} {
+			StreamCloser: r.HTTPResponse.Body,
+			Reader: reader,
+		}
+	{{ end -}}
+
+	s.{{ $.EventStreamsMemberName }} = eventStream
+}
+`))
+
+// Template for an EventStream Event shape. This is a normal API shape that is
+// decorated as an EventStream Event.
+//
+// Executed in the context of a Shape.
+var eventStreamEventShapeTmpl = template.Must(template.New("eventStreamEventShapeTmpl").Parse(`
+{{ range $_, $eventstream := $.EventFor }}
+	// The {{ $.ShapeName }} is and event in the {{ $eventstream.Name }} group of events.
+	func (s *{{ $.ShapeName }}) event{{ $eventstream.Name }}() {}
+{{ end }}
+
+// UnmarshalEvent unmarshals the EventStream Message into the {{ $.ShapeName }} value.
+// This method is only used internally within the SDK's EventStream handling.
+func (s *{{ $.ShapeName }}) UnmarshalEvent(
+	payloadUnmarshaler protocol.PayloadUnmarshaler,
+	msg eventstream.Message,
+) error {
+	{{- range $fieldIdx, $fieldName := $.MemberNames }}
+		{{- $fieldRef := index $.MemberRefs $fieldName -}}
+		{{ if $fieldRef.IsEventHeader }}
+			// TODO handle event header, {{ $fieldName }}
+		{{- else if (and ($fieldRef.IsEventPayload) (eq $fieldRef.Shape.Type "blob")) }}
+			s.{{ $fieldName }} = make([]byte, len(msg.Payload))
+			copy(s.{{ $fieldName }}, msg.Payload)
+		{{- else }}
+			if err := payloadUnmarshaler.UnmarshalPayload(
+				bytes.NewReader(msg.Payload), s,
+			); err != nil {
+				return fmt.Errorf("failed to unmarshal payload, %v", err)
+			}
+		{{- end }}
+	{{- end }}
+	return nil
+}
+`))
+
+var eventStreamTestTmpl = template.Must(template.New("eventStreamTestTmpl").Parse(`
+`))

vendor/github.com/aws/aws-sdk-go/private/model/api/eventstream_test.go

@@ -1,79 +0,0 @@
-// +build go1.6,codegen
-
-package api
-
-import (
-	"testing"
-)
-
-func TestSuppressEventStream(t *testing.T) {
-	cases := []struct {
-		API    *API
-		Ops    []string
-		Shapes []string
-	}{
-		{
-			API: &API{
-				Operations: map[string]*Operation{
-					"abc": {
-						InputRef: ShapeRef{
-							ShapeName: "abcRequest",
-						},
-						OutputRef: ShapeRef{
-							ShapeName: "abcResponse",
-						},
-					},
-					"eventStreamOp": {
-						InputRef: ShapeRef{
-							ShapeName: "eventStreamOpRequest",
-						},
-						OutputRef: ShapeRef{
-							ShapeName: "eventStreamOpResponse",
-						},
-					},
-				},
-				Shapes: map[string]*Shape{
-					"abcRequest":           {},
-					"abcResponse":          {},
-					"eventStreamOpRequest": {},
-					"eventStreamOpResponse": {
-						MemberRefs: map[string]*ShapeRef{
-							"eventStreamShape": {
-								ShapeName: "eventStreamShape",
-							},
-						},
-					},
-					"eventStreamShape": {
-						IsEventStream: true,
-					},
-				},
-			},
-			Ops:    []string{"Abc"},
-			Shapes: []string{"AbcInput", "AbcOutput"},
-		},
-	}
-
-	for _, c := range cases {
-		c.API.Setup()
-		if e, a := c.Ops, c.API.OperationNames(); !stringsEqual(e, a) {
-			t.Errorf("expect %v ops, got %v", e, a)
-		}
-
-		if e, a := c.Shapes, c.API.ShapeNames(); !stringsEqual(e, a) {
-			t.Errorf("expect %v ops, got %v", e, a)
-		}
-	}
-}
-
-func stringsEqual(a, b []string) bool {
-	if len(a) != len(b) {
-		return false
-	}
-
-	for i := 0; i < len(a); i++ {
-		if a[i] != b[i] {
-			return false
-		}
-	}
-	return true
-}

vendor/github.com/aws/aws-sdk-go/private/model/api/load.go

@@ -47,7 +47,7 @@ func (a *API) Setup() {
 	a.renameCollidingFields()
 	a.updateTopLevelShapeReferences()
 	a.createInputOutputShapes()
-	a.suppressEventStreams()
+	a.setupEventStreams()
 	a.customizationPasses()
 
 	if !a.NoRemoveUnusedShapes {

vendor/github.com/aws/aws-sdk-go/private/model/api/operation.go

@@ -44,6 +44,7 @@ func (o *Operation) HasOutput() bool {
 	return o.OutputRef.ShapeName != ""
 }
 
+// GetSigner returns the signer that should be used for a API request.
 func (o *Operation) GetSigner() string {
 	if o.AuthType == "v4-unsigned-body" {
 		o.API.imports["github.com/aws/aws-sdk-go/aws/signer/v4"] = true
@@ -66,7 +67,8 @@ func (o *Operation) GetSigner() string {
 
 // tplOperation defines a template for rendering an API Operation
 var tplOperation = template.Must(template.New("operation").Funcs(template.FuncMap{
-	"GetCrosslinkURL": GetCrosslinkURL,
+	"GetCrosslinkURL":       GetCrosslinkURL,
+	"EnableStopOnSameToken": enableStopOnSameToken,
 }).Parse(`
 const op{{ .ExportedName }} = "{{ .Name }}"
 
@@ -120,10 +122,16 @@ func (c *{{ .API.StructName }}) {{ .ExportedName }}Request(` +
 	}
 
 	output = &{{ .OutputRef.GoTypeElem }}{}
-	req = c.newRequest(op, input, output){{ if eq .OutputRef.Shape.Placeholder true }}
-	req.Handlers.Unmarshal.Remove({{ .API.ProtocolPackage }}.UnmarshalHandler)
-	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler){{ end }}
+	req = c.newRequest(op, input, output)
+	{{ if eq .OutputRef.Shape.Placeholder true -}}
+		req.Handlers.Unmarshal.Remove({{ .API.ProtocolPackage }}.UnmarshalHandler)
+		req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
+	{{ end -}}
 	{{ if ne .AuthType "" }}{{ .GetSigner }}{{ end -}}
+	{{ if .OutputRef.Shape.EventStreamsMemberName -}}
+		req.Handlers.Unmarshal.Swap({{ .API.ProtocolPackage }}.UnmarshalHandler.Name, rest.UnmarshalHandler)
+		req.Handlers.Unmarshal.PushBack(output.runEventStreamLoop)
+	{{ end -}}
 	return
 }
 
@@ -214,6 +222,8 @@ func (c *{{ .API.StructName }}) {{ .ExportedName }}PagesWithContext(` +
 	`fn func({{ .OutputRef.GoType }}, bool) bool, ` +
 	`opts ...request.Option) error {
 	p := request.Pagination {
+		{{ if EnableStopOnSameToken .API.PackageName -}}EndPageOnSameToken: true,
+		{{ end -}}
 		NewRequest: func() (*request.Request, error) {
 			var inCpy {{ .InputRef.GoType }}
 			if input != nil  {
@@ -239,6 +249,12 @@ func (c *{{ .API.StructName }}) {{ .ExportedName }}PagesWithContext(` +
 // GoCode returns a string of rendered GoCode for this Operation
 func (o *Operation) GoCode() string {
 	var buf bytes.Buffer
+
+	if len(o.OutputRef.Shape.EventStreamsMemberName) != 0 {
+		// TODO need better was of updating protocol unmarshalers
+		o.API.imports["github.com/aws/aws-sdk-go/private/protocol/rest"] = true
+	}
+
 	err := tplOperation.Execute(&buf, o)
 	if err != nil {
 		panic(err)

vendor/github.com/aws/aws-sdk-go/private/model/api/pagination.go

@@ -89,3 +89,12 @@ func (p *paginationDefinitions) setup() {
 		}
 	}
 }
+
+func enableStopOnSameToken(service string) bool {
+	switch service {
+	case "cloudwatchlogs":
+		return true
+	default:
+		return false
+	}
+}

vendor/github.com/aws/aws-sdk-go/private/model/api/passes.go

@@ -59,6 +59,7 @@ func (a *API) resolveReferences() {
 		for i := range o.ErrorRefs {
 			resolver.resolveReference(&o.ErrorRefs[i])
 			o.ErrorRefs[i].Shape.IsError = true
+			o.ErrorRefs[i].Shape.ErrorInfo.Type = o.ErrorRefs[i].Shape.ShapeName
 		}
 	}
 }

vendor/github.com/aws/aws-sdk-go/private/model/api/shape.go

@@ -12,6 +12,19 @@ import (
 	"text/template"
 )
 
+// ErrorInfo represents the error block of a shape's structure
+type ErrorInfo struct {
+	Type           string
+	Code           string
+	HTTPStatusCode int
+}
+
+// A XMLInfo defines URL and prefix for Shapes when rendered as XML
+type XMLInfo struct {
+	Prefix string
+	URI    string
+}
+
 // A ShapeRef defines the usage of a shape within the API.
 type ShapeRef struct {
 	API           *API   `json:"-"`
@@ -35,18 +48,9 @@ type ShapeRef struct {
 	OrigShapeName string `json:"-"`
 
 	GenerateGetter bool
-}
 
-// ErrorInfo represents the error block of a shape's structure
-type ErrorInfo struct {
-	Code           string
-	HTTPStatusCode int
-}
-
-// A XMLInfo defines URL and prefix for Shapes when rendered as XML
-type XMLInfo struct {
-	Prefix string
-	URI    string
+	IsEventPayload bool `json:"eventpayload"`
+	IsEventHeader  bool `json:"eventheader"`
 }
 
 // A Shape defines the definition of a shape type
@@ -73,7 +77,12 @@ type Shape struct {
 	Min              float64 // optional Minimum length (string, list) or value (number)
 	Max              float64 // optional Maximum length (string, list) or value (number)
 
+	EventStreamsMemberName string          `json:"-"`
+	EventStreamAPI         *EventStreamAPI `json:"-"`
+	EventFor               []*EventStream  `json:"-"`
+
 	IsEventStream bool `json:"eventstream"`
+	IsEvent       bool `json:"event"`
 
 	refs       []*ShapeRef // References to this shape
 	resolvePkg string      // use this package in the goType() if present
@@ -101,7 +110,7 @@ func (s *Shape) ErrorCodeName() string {
 // ErrorName will return the shape's name or error code if available based
 // on the API's protocol. This is the error code string returned by the service.
 func (s *Shape) ErrorName() string {
-	name := s.ShapeName
+	name := s.ErrorInfo.Type
 	switch s.API.Metadata.Protocol {
 	case "query", "ec2query", "rest-xml":
 		if len(s.ErrorInfo.Code) > 0 {
@@ -112,6 +121,23 @@ func (s *Shape) ErrorName() string {
 	return name
 }
 
+// PayloadRefName returns the payload member of the shape if there is one
+// modeled. If no payload is modeled, empty string will be returned.
+func (s *Shape) PayloadRefName() string {
+	if name := s.Payload; len(name) != 0 {
+		// Root shape
+		return name
+	}
+
+	for name, ref := range s.MemberRefs {
+		if ref.IsEventPayload {
+			return name
+		}
+	}
+
+	return ""
+}
+
 // GoTags returns the struct tags for a shape.
 func (s *Shape) GoTags(root, required bool) string {
 	ref := &ShapeRef{ShapeName: s.ShapeName, API: s.API, Shape: s}
@@ -149,6 +175,8 @@ func (s *Shape) GoTypeWithPkgName() string {
 	return goType(s, true)
 }
 
+// GoTypeWithPkgNameElem returns the shapes type as a string with the "*"
+// removed if there was one preset.
 func (s *Shape) GoTypeWithPkgNameElem() string {
 	t := goType(s, true)
 	if strings.HasPrefix(t, "*") {
@@ -157,7 +185,7 @@ func (s *Shape) GoTypeWithPkgNameElem() string {
 	return t
 }
 
-// GenAccessors returns if the shape's reference should have setters generated.
+// UseIndirection returns if the shape's reference should use indirection or not.
 func (s *ShapeRef) UseIndirection() bool {
 	switch s.Shape.Type {
 	case "map", "list", "blob", "structure", "jsonvalue":
@@ -401,8 +429,8 @@ func (ref *ShapeRef) GoTags(toplevel bool, isRequired bool) string {
 	}
 
 	if toplevel {
-		if ref.Shape.Payload != "" {
-			tags = append(tags, ShapeTag{"payload", ref.Shape.Payload})
+		if name := ref.Shape.PayloadRefName(); len(name) > 0 {
+			tags = append(tags, ShapeTag{"payload", name})
 		}
 	}
 
@@ -514,9 +542,29 @@ func (s *Shape) NestedShape() *Shape {
 	return nestedShape
 }
 
-var structShapeTmpl = template.Must(template.New("StructShape").Funcs(template.FuncMap{
-	"GetCrosslinkURL": GetCrosslinkURL,
-}).Parse(`
+var structShapeTmpl = func() *template.Template {
+	shapeTmpl := template.Must(
+		template.New("structShapeTmpl").
+			Funcs(template.FuncMap{
+				"GetCrosslinkURL": GetCrosslinkURL,
+			}).
+			Parse(structShapeTmplDef),
+	)
+
+	template.Must(
+		shapeTmpl.AddParseTree(
+			"eventStreamAPILoopMethodTmpl", eventStreamAPILoopMethodTmpl.Tree),
+	)
+
+	template.Must(
+		shapeTmpl.AddParseTree(
+			"eventStreamEventShapeTmpl", eventStreamEventShapeTmpl.Tree),
+	)
+
+	return shapeTmpl
+}()
+
+const structShapeTmplDef = `
 {{ .Docstring }}
 {{ $context := . -}}
 type {{ .ShapeName }} struct {
@@ -557,38 +605,43 @@ type {{ .ShapeName }} struct {
 {{ end }}
 
 {{ if not .API.NoGenStructFieldAccessors }}
+	{{ $builderShapeName := print .ShapeName -}}
+	{{ range $_, $name := $context.MemberNames -}}
+		{{ $elem := index $context.MemberRefs $name -}}
 
-{{ $builderShapeName := print .ShapeName -}}
-
-{{ range $_, $name := $context.MemberNames -}}
-	{{ $elem := index $context.MemberRefs $name -}}
-
-// Set{{ $name }} sets the {{ $name }} field's value.
-func (s *{{ $builderShapeName }}) Set{{ $name }}(v {{ $context.GoStructValueType $name $elem }}) *{{ $builderShapeName }} {
-	{{ if $elem.UseIndirection -}}
-	s.{{ $name }} = &v
-	{{ else -}}
-	s.{{ $name }} = v
-	{{ end -}}
-	return s
-}
-
-{{ if $elem.GenerateGetter -}}
-func (s *{{ $builderShapeName }}) get{{ $name }}() (v {{ $context.GoStructValueType $name $elem }}) {
-	{{ if $elem.UseIndirection -}}
-		if s.{{ $name }} == nil {
-			return v
+		// Set{{ $name }} sets the {{ $name }} field's value.
+		func (s *{{ $builderShapeName }}) Set{{ $name }}(v {{ $context.GoStructValueType $name $elem }}) *{{ $builderShapeName }} {
+			{{ if $elem.UseIndirection -}}
+				s.{{ $name }} = &v
+			{{ else -}}
+				s.{{ $name }} = v
+			{{ end -}}
+			return s
 		}
-		return *s.{{ $name }}
-	{{ else -}}
-		return s.{{ $name }}
-	{{ end -}}
-}
-{{- end }}
 
+		{{ if $elem.GenerateGetter -}}
+			func (s *{{ $builderShapeName }}) get{{ $name }}() (v {{ $context.GoStructValueType $name $elem }}) {
+				{{ if $elem.UseIndirection -}}
+					if s.{{ $name }} == nil {
+						return v
+					}
+					return *s.{{ $name }}
+				{{ else -}}
+					return s.{{ $name }}
+				{{ end -}}
+			}
+		{{- end }}
+	{{ end }}
 {{ end }}
+
+{{ if $.EventStreamsMemberName }}
+	{{ template "eventStreamAPILoopMethodTmpl" $ }}
 {{ end }}
-`))
+
+{{ if $.IsEvent }}
+	{{ template "eventStreamEventShapeTmpl" $ }}
+{{ end }}
+`
 
 var enumShapeTmpl = template.Must(template.New("EnumShape").Parse(`
 {{ .Docstring }}
@@ -605,22 +658,38 @@ const (
 
 // GoCode returns the rendered Go code for the Shape.
 func (s *Shape) GoCode() string {
-	b := &bytes.Buffer{}
+	w := &bytes.Buffer{}
 
 	switch {
+	case s.EventStreamAPI != nil:
+		if err := renderEventStreamAPIShape(w, s); err != nil {
+			panic(
+				fmt.Sprintf(
+					"failed to generate eventstream API shape, %s, %v",
+					s.ShapeName, err),
+			)
+		}
 	case s.Type == "structure":
-		if err := structShapeTmpl.Execute(b, s); err != nil {
-			panic(fmt.Sprintf("Failed to generate struct shape %s, %v\n", s.ShapeName, err))
+		if err := structShapeTmpl.Execute(w, s); err != nil {
+			panic(
+				fmt.Sprintf(
+					"Failed to generate struct shape %s, %v",
+					s.ShapeName, err),
+			)
 		}
 	case s.IsEnum():
-		if err := enumShapeTmpl.Execute(b, s); err != nil {
-			panic(fmt.Sprintf("Failed to generate enum shape %s, %v\n", s.ShapeName, err))
+		if err := enumShapeTmpl.Execute(w, s); err != nil {
+			panic(
+				fmt.Sprintf(
+					"Failed to generate enum shape %s, %v",
+					s.ShapeName, err),
+			)
 		}
 	default:
 		panic(fmt.Sprintln("Cannot generate toplevel shape for", s.Type))
 	}
 
-	return b.String()
+	return w.String()
 }
 
 // IsEnum returns whether this shape is an enum list

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

@@ -76,6 +76,7 @@ func newInputService1ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice1protocoltest",
+				ServiceID:     "InputService1ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -229,6 +230,7 @@ func newInputService2ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice2protocoltest",
+				ServiceID:     "InputService2ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -390,6 +392,7 @@ func newInputService3ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice3protocoltest",
+				ServiceID:     "InputService3ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -547,6 +550,7 @@ func newInputService4ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice4protocoltest",
+				ServiceID:     "InputService4ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -716,6 +720,7 @@ func newInputService5ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice5protocoltest",
+				ServiceID:     "InputService5ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -861,6 +866,7 @@ func newInputService6ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice6protocoltest",
+				ServiceID:     "InputService6ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1006,6 +1012,7 @@ func newInputService7ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice7protocoltest",
+				ServiceID:     "InputService7ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1152,6 +1159,7 @@ func newInputService8ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice8protocoltest",
+				ServiceID:     "InputService8ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1297,6 +1305,7 @@ func newInputService9ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice9protocoltest",
+				ServiceID:     "InputService9ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1516,6 +1525,7 @@ func newInputService10ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice10protocoltest",
+				ServiceID:     "InputService10ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,

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

@@ -76,6 +76,7 @@ func newOutputService1ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice1protocoltest",
+				ServiceID:     "OutputService1ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -275,6 +276,7 @@ func newOutputService2ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice2protocoltest",
+				ServiceID:     "OutputService2ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -419,6 +421,7 @@ func newOutputService3ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice3protocoltest",
+				ServiceID:     "OutputService3ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -562,6 +565,7 @@ func newOutputService4ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice4protocoltest",
+				ServiceID:     "OutputService4ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -705,6 +709,7 @@ func newOutputService5ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice5protocoltest",
+				ServiceID:     "OutputService5ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -848,6 +853,7 @@ func newOutputService6ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice6protocoltest",
+				ServiceID:     "OutputService6ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1003,6 +1009,7 @@ func newOutputService7ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice7protocoltest",
+				ServiceID:     "OutputService7ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1146,6 +1153,7 @@ func newOutputService8ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice8protocoltest",
+				ServiceID:     "OutputService8ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1289,6 +1297,7 @@ func newOutputService9ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice9protocoltest",
+				ServiceID:     "OutputService9ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1432,6 +1441,7 @@ func newOutputService10ProtocolTestClient(cfg aws.Config, handlers request.Handl
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice10protocoltest",
+				ServiceID:     "OutputService10ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/debug.go

@@ -0,0 +1,144 @@
+package eventstream
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"strconv"
+)
+
+type decodedMessage struct {
+	rawMessage
+	Headers decodedHeaders `json:"headers"`
+}
+type jsonMessage struct {
+	Length     json.Number    `json:"total_length"`
+	HeadersLen json.Number    `json:"headers_length"`
+	PreludeCRC json.Number    `json:"prelude_crc"`
+	Headers    decodedHeaders `json:"headers"`
+	Payload    []byte         `json:"payload"`
+	CRC        json.Number    `json:"message_crc"`
+}
+
+func (d *decodedMessage) UnmarshalJSON(b []byte) (err error) {
+	var jsonMsg jsonMessage
+	if err = json.Unmarshal(b, &jsonMsg); err != nil {
+		return err
+	}
+
+	d.Length, err = numAsUint32(jsonMsg.Length)
+	if err != nil {
+		return err
+	}
+	d.HeadersLen, err = numAsUint32(jsonMsg.HeadersLen)
+	if err != nil {
+		return err
+	}
+	d.PreludeCRC, err = numAsUint32(jsonMsg.PreludeCRC)
+	if err != nil {
+		return err
+	}
+	d.Headers = jsonMsg.Headers
+	d.Payload = jsonMsg.Payload
+	d.CRC, err = numAsUint32(jsonMsg.CRC)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (d *decodedMessage) MarshalJSON() ([]byte, error) {
+	jsonMsg := jsonMessage{
+		Length:     json.Number(strconv.Itoa(int(d.Length))),
+		HeadersLen: json.Number(strconv.Itoa(int(d.HeadersLen))),
+		PreludeCRC: json.Number(strconv.Itoa(int(d.PreludeCRC))),
+		Headers:    d.Headers,
+		Payload:    d.Payload,
+		CRC:        json.Number(strconv.Itoa(int(d.CRC))),
+	}
+
+	return json.Marshal(jsonMsg)
+}
+
+func numAsUint32(n json.Number) (uint32, error) {
+	v, err := n.Int64()
+	if err != nil {
+		return 0, fmt.Errorf("failed to get int64 json number, %v", err)
+	}
+
+	return uint32(v), nil
+}
+
+func (d decodedMessage) Message() Message {
+	return Message{
+		Headers: Headers(d.Headers),
+		Payload: d.Payload,
+	}
+}
+
+type decodedHeaders Headers
+
+func (hs *decodedHeaders) UnmarshalJSON(b []byte) error {
+	var jsonHeaders []struct {
+		Name  string      `json:"name"`
+		Type  valueType   `json:"type"`
+		Value interface{} `json:"value"`
+	}
+
+	decoder := json.NewDecoder(bytes.NewReader(b))
+	decoder.UseNumber()
+	if err := decoder.Decode(&jsonHeaders); err != nil {
+		return err
+	}
+
+	var headers Headers
+	for _, h := range jsonHeaders {
+		value, err := valueFromType(h.Type, h.Value)
+		if err != nil {
+			return err
+		}
+		headers.Set(h.Name, value)
+	}
+	(*hs) = decodedHeaders(headers)
+
+	return nil
+}
+
+func valueFromType(typ valueType, val interface{}) (Value, error) {
+	switch typ {
+	case trueValueType:
+		return BoolValue(true), nil
+	case falseValueType:
+		return BoolValue(false), nil
+	case int8ValueType:
+		v, err := val.(json.Number).Int64()
+		return Int8Value(int8(v)), err
+	case int16ValueType:
+		v, err := val.(json.Number).Int64()
+		return Int16Value(int16(v)), err
+	case int32ValueType:
+		v, err := val.(json.Number).Int64()
+		return Int32Value(int32(v)), err
+	case int64ValueType:
+		v, err := val.(json.Number).Int64()
+		return Int64Value(v), err
+	case bytesValueType:
+		v, err := base64.StdEncoding.DecodeString(val.(string))
+		return BytesValue(v), err
+	case stringValueType:
+		v, err := base64.StdEncoding.DecodeString(val.(string))
+		return StringValue(string(v)), err
+	case timestampValueType:
+		v, err := val.(json.Number).Int64()
+		return TimestampValue(timeFromEpochMilli(v)), err
+	case uuidValueType:
+		v, err := base64.StdEncoding.DecodeString(val.(string))
+		var tv UUIDValue
+		copy(tv[:], v)
+		return tv, err
+	default:
+		panic(fmt.Sprintf("unknown type, %s, %T", typ.String(), val))
+	}
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/decode.go

@@ -0,0 +1,199 @@
+package eventstream
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"hash"
+	"hash/crc32"
+	"io"
+
+	"github.com/aws/aws-sdk-go/aws"
+)
+
+// Decoder provides decoding of an Event Stream messages.
+type Decoder struct {
+	r      io.Reader
+	logger aws.Logger
+}
+
+// NewDecoder initializes and returns a Decoder for decoding event
+// stream messages from the reader provided.
+func NewDecoder(r io.Reader) *Decoder {
+	return &Decoder{
+		r: r,
+	}
+}
+
+// Decode attempts to decode a single message from the event stream reader.
+// Will return the event stream message, or error if Decode fails to read
+// the message from the stream.
+func (d *Decoder) Decode(payloadBuf []byte) (m Message, err error) {
+	reader := d.r
+	if d.logger != nil {
+		debugMsgBuf := bytes.NewBuffer(nil)
+		reader = io.TeeReader(reader, debugMsgBuf)
+		defer func() {
+			logMessageDecode(d.logger, debugMsgBuf, m, err)
+		}()
+	}
+
+	crc := crc32.New(crc32IEEETable)
+	hashReader := io.TeeReader(reader, crc)
+
+	prelude, err := decodePrelude(hashReader, crc)
+	if err != nil {
+		return Message{}, err
+	}
+
+	if prelude.HeadersLen > 0 {
+		lr := io.LimitReader(hashReader, int64(prelude.HeadersLen))
+		m.Headers, err = decodeHeaders(lr)
+		if err != nil {
+			return Message{}, err
+		}
+	}
+
+	if payloadLen := prelude.PayloadLen(); payloadLen > 0 {
+		buf, err := decodePayload(payloadBuf, io.LimitReader(hashReader, int64(payloadLen)))
+		if err != nil {
+			return Message{}, err
+		}
+		m.Payload = buf
+	}
+
+	msgCRC := crc.Sum32()
+	if err := validateCRC(reader, msgCRC); err != nil {
+		return Message{}, err
+	}
+
+	return m, nil
+}
+
+// UseLogger specifies the Logger that that the decoder should use to log the
+// message decode to.
+func (d *Decoder) UseLogger(logger aws.Logger) {
+	d.logger = logger
+}
+
+func logMessageDecode(logger aws.Logger, msgBuf *bytes.Buffer, msg Message, decodeErr error) {
+	w := bytes.NewBuffer(nil)
+	defer func() { logger.Log(w.String()) }()
+
+	fmt.Fprintf(w, "Raw message:\n%s\n",
+		hex.Dump(msgBuf.Bytes()))
+
+	if decodeErr != nil {
+		fmt.Fprintf(w, "Decode error: %v\n", decodeErr)
+		return
+	}
+
+	rawMsg, err := msg.rawMessage()
+	if err != nil {
+		fmt.Fprintf(w, "failed to create raw message, %v\n", err)
+		return
+	}
+
+	decodedMsg := decodedMessage{
+		rawMessage: rawMsg,
+		Headers:    decodedHeaders(msg.Headers),
+	}
+
+	fmt.Fprintf(w, "Decoded message:\n")
+	encoder := json.NewEncoder(w)
+	if err := encoder.Encode(decodedMsg); err != nil {
+		fmt.Fprintf(w, "failed to generate decoded message, %v\n", err)
+	}
+}
+
+func decodePrelude(r io.Reader, crc hash.Hash32) (messagePrelude, error) {
+	var p messagePrelude
+
+	var err error
+	p.Length, err = decodeUint32(r)
+	if err != nil {
+		return messagePrelude{}, err
+	}
+
+	p.HeadersLen, err = decodeUint32(r)
+	if err != nil {
+		return messagePrelude{}, err
+	}
+
+	if err := p.ValidateLens(); err != nil {
+		return messagePrelude{}, err
+	}
+
+	preludeCRC := crc.Sum32()
+	if err := validateCRC(r, preludeCRC); err != nil {
+		return messagePrelude{}, err
+	}
+
+	p.PreludeCRC = preludeCRC
+
+	return p, nil
+}
+
+func decodePayload(buf []byte, r io.Reader) ([]byte, error) {
+	w := bytes.NewBuffer(buf[0:0])
+
+	_, err := io.Copy(w, r)
+	return w.Bytes(), err
+}
+
+func decodeUint8(r io.Reader) (uint8, error) {
+	type byteReader interface {
+		ReadByte() (byte, error)
+	}
+
+	if br, ok := r.(byteReader); ok {
+		v, err := br.ReadByte()
+		return uint8(v), err
+	}
+
+	var b [1]byte
+	_, err := io.ReadFull(r, b[:])
+	return uint8(b[0]), err
+}
+func decodeUint16(r io.Reader) (uint16, error) {
+	var b [2]byte
+	bs := b[:]
+	_, err := io.ReadFull(r, bs)
+	if err != nil {
+		return 0, err
+	}
+	return binary.BigEndian.Uint16(bs), nil
+}
+func decodeUint32(r io.Reader) (uint32, error) {
+	var b [4]byte
+	bs := b[:]
+	_, err := io.ReadFull(r, bs)
+	if err != nil {
+		return 0, err
+	}
+	return binary.BigEndian.Uint32(bs), nil
+}
+func decodeUint64(r io.Reader) (uint64, error) {
+	var b [8]byte
+	bs := b[:]
+	_, err := io.ReadFull(r, bs)
+	if err != nil {
+		return 0, err
+	}
+	return binary.BigEndian.Uint64(bs), nil
+}
+
+func validateCRC(r io.Reader, expect uint32) error {
+	msgCRC, err := decodeUint32(r)
+	if err != nil {
+		return err
+	}
+
+	if msgCRC != expect {
+		return ChecksumError{}
+	}
+
+	return nil
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/decode_test.go

@@ -0,0 +1,168 @@
+package eventstream
+
+import (
+	"bytes"
+	"encoding/hex"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+)
+
+func TestWriteEncodedFromDecoded(t *testing.T) {
+	cases, err := readPositiveTests("testdata")
+	if err != nil {
+		t.Fatalf("failed to load positive tests, %v", err)
+	}
+
+	for _, c := range cases {
+		f, err := os.Create(filepath.Join("testdata", "encoded", "positive", c.Name))
+		if err != nil {
+			t.Fatalf("failed to open %q, %v", c.Name, err)
+		}
+		defer f.Close()
+
+		encoder := NewEncoder(f)
+
+		msg := c.Decoded.Message()
+		if err := encoder.Encode(msg); err != nil {
+			t.Errorf("failed to encode %q, %v", c.Name, err)
+		}
+	}
+}
+
+func TestDecoder_Decode(t *testing.T) {
+	cases, err := readPositiveTests("testdata")
+	if err != nil {
+		t.Fatalf("failed to load positive tests, %v", err)
+	}
+
+	for _, c := range cases {
+		decoder := NewDecoder(bytes.NewBuffer(c.Encoded))
+
+		msg, err := decoder.Decode(nil)
+		if err != nil {
+			t.Fatalf("%s, expect no decode error, got %v", c.Name, err)
+		}
+
+		raw, err := msg.rawMessage() // rawMessage will fail if payload read CRC fails
+		if err != nil {
+			t.Fatalf("%s, failed to get raw decoded message %v", c.Name, err)
+		}
+
+		if e, a := c.Decoded.Length, raw.Length; e != a {
+			t.Errorf("%s, expect %v length, got %v", c.Name, e, a)
+		}
+		if e, a := c.Decoded.HeadersLen, raw.HeadersLen; e != a {
+			t.Errorf("%s, expect %v HeadersLen, got %v", c.Name, e, a)
+		}
+		if e, a := c.Decoded.PreludeCRC, raw.PreludeCRC; e != a {
+			t.Errorf("%s, expect %v PreludeCRC, got %v", c.Name, e, a)
+		}
+		if e, a := Headers(c.Decoded.Headers), msg.Headers; !reflect.DeepEqual(e, a) {
+			t.Errorf("%s, expect %v headers, got %v", c.Name, e, a)
+		}
+		if e, a := c.Decoded.Payload, raw.Payload; !bytes.Equal(e, a) {
+			t.Errorf("%s, expect %v payload, got %v", c.Name, e, a)
+		}
+		if e, a := c.Decoded.CRC, raw.CRC; e != a {
+			t.Errorf("%s, expect %v CRC, got %v", c.Name, e, a)
+		}
+	}
+}
+
+func TestDecoder_Decode_Negative(t *testing.T) {
+	cases, err := readNegativeTests("testdata")
+	if err != nil {
+		t.Fatalf("failed to load negative tests, %v", err)
+	}
+
+	for _, c := range cases {
+		decoder := NewDecoder(bytes.NewBuffer(c.Encoded))
+
+		msg, err := decoder.Decode(nil)
+		if err == nil {
+			rawMsg, rawMsgErr := msg.rawMessage()
+			t.Fatalf("%s, expect error, got none, %s,\n%s\n%#v, %v\n", c.Name,
+				c.Err, hex.Dump(c.Encoded), rawMsg, rawMsgErr)
+		}
+	}
+}
+
+var testEncodedMsg = []byte{0, 0, 0, 61, 0, 0, 0, 32, 7, 253, 131, 150, 12, 99, 111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 7, 0, 16, 97, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 47, 106, 115, 111, 110, 123, 39, 102, 111, 111, 39, 58, 39, 98, 97, 114, 39, 125, 141, 156, 8, 177}
+
+func TestDecoder_DecodeMultipleMessages(t *testing.T) {
+	const (
+		expectMsgCount   = 10
+		expectPayloadLen = 13
+	)
+
+	r := bytes.NewBuffer(nil)
+	for i := 0; i < expectMsgCount; i++ {
+		r.Write(testEncodedMsg)
+	}
+
+	decoder := NewDecoder(r)
+
+	var err error
+	var msg Message
+	var count int
+	for {
+		msg, err = decoder.Decode(nil)
+		if err != nil {
+			break
+		}
+		count++
+
+		if e, a := expectPayloadLen, len(msg.Payload); e != a {
+			t.Errorf("expect %v payload len, got %v", e, a)
+		}
+
+		if e, a := []byte(`{'foo':'bar'}`), msg.Payload; !bytes.Equal(e, a) {
+			t.Errorf("expect %v payload, got %v", e, a)
+		}
+	}
+
+	type causer interface {
+		Cause() error
+	}
+	if err != nil && count != expectMsgCount {
+		t.Fatalf("expect, no error, got %v", err)
+	}
+
+	if e, a := expectMsgCount, count; e != a {
+		t.Errorf("expect %v messages read, got %v", e, a)
+	}
+}
+
+func BenchmarkDecode(b *testing.B) {
+	r := bytes.NewReader(testEncodedMsg)
+	decoder := NewDecoder(r)
+	payloadBuf := make([]byte, 0, 5*1024)
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		msg, err := decoder.Decode(payloadBuf)
+		if err != nil {
+			b.Fatal(err)
+		}
+
+		// Release the payload buffer
+		payloadBuf = msg.Payload[0:0]
+		r.Seek(0, 0)
+	}
+}
+
+func BenchmarkDecode_NoPayloadBuf(b *testing.B) {
+	r := bytes.NewReader(testEncodedMsg)
+	decoder := NewDecoder(r)
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		_, err := decoder.Decode(nil)
+		if err != nil {
+			b.Fatal(err)
+		}
+		r.Seek(0, 0)
+	}
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/encode.go

@@ -0,0 +1,114 @@
+package eventstream
+
+import (
+	"bytes"
+	"encoding/binary"
+	"hash"
+	"hash/crc32"
+	"io"
+)
+
+// Encoder provides EventStream message encoding.
+type Encoder struct {
+	w io.Writer
+
+	headersBuf *bytes.Buffer
+}
+
+// NewEncoder initializes and returns an Encoder to encode Event Stream
+// messages to an io.Writer.
+func NewEncoder(w io.Writer) *Encoder {
+	return &Encoder{
+		w:          w,
+		headersBuf: bytes.NewBuffer(nil),
+	}
+}
+
+// Encode encodes a single EventStream message to the io.Writer the Encoder
+// was created with. An error is returned if writing the message fails.
+func (e *Encoder) Encode(msg Message) error {
+	e.headersBuf.Reset()
+
+	err := encodeHeaders(e.headersBuf, msg.Headers)
+	if err != nil {
+		return err
+	}
+
+	crc := crc32.New(crc32IEEETable)
+	hashWriter := io.MultiWriter(e.w, crc)
+
+	headersLen := uint32(e.headersBuf.Len())
+	payloadLen := uint32(len(msg.Payload))
+
+	if err := encodePrelude(hashWriter, crc, headersLen, payloadLen); err != nil {
+		return err
+	}
+
+	if headersLen > 0 {
+		if _, err := io.Copy(hashWriter, e.headersBuf); err != nil {
+			return err
+		}
+	}
+
+	if payloadLen > 0 {
+		if _, err := hashWriter.Write(msg.Payload); err != nil {
+			return err
+		}
+	}
+
+	msgCRC := crc.Sum32()
+	return binary.Write(e.w, binary.BigEndian, msgCRC)
+}
+
+func encodePrelude(w io.Writer, crc hash.Hash32, headersLen, payloadLen uint32) error {
+	p := messagePrelude{
+		Length:     minMsgLen + headersLen + payloadLen,
+		HeadersLen: headersLen,
+	}
+	if err := p.ValidateLens(); err != nil {
+		return err
+	}
+
+	err := binaryWriteFields(w, binary.BigEndian,
+		p.Length,
+		p.HeadersLen,
+	)
+	if err != nil {
+		return err
+	}
+
+	p.PreludeCRC = crc.Sum32()
+	err = binary.Write(w, binary.BigEndian, p.PreludeCRC)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func encodeHeaders(w io.Writer, headers Headers) error {
+	for _, h := range headers {
+		hn := headerName{
+			Len: uint8(len(h.Name)),
+		}
+		copy(hn.Name[:hn.Len], h.Name)
+		if err := hn.encode(w); err != nil {
+			return err
+		}
+
+		if err := h.Value.encode(w); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func binaryWriteFields(w io.Writer, order binary.ByteOrder, vs ...interface{}) error {
+	for _, v := range vs {
+		if err := binary.Write(w, order, v); err != nil {
+			return err
+		}
+	}
+	return nil
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/encode_test.go

@@ -0,0 +1,50 @@
+package eventstream
+
+import (
+	"bytes"
+	"encoding/hex"
+	"reflect"
+	"testing"
+)
+
+func TestEncoder_Encode(t *testing.T) {
+	cases, err := readPositiveTests("testdata")
+	if err != nil {
+		t.Fatalf("failed to load positive tests, %v", err)
+	}
+
+	for _, c := range cases {
+		var w bytes.Buffer
+		encoder := NewEncoder(&w)
+
+		err = encoder.Encode(c.Decoded.Message())
+		if err != nil {
+			t.Fatalf("%s, failed to encode message, %v", c.Name, err)
+		}
+
+		if e, a := c.Encoded, w.Bytes(); !reflect.DeepEqual(e, a) {
+			t.Errorf("%s, expect:\n%v\nactual:\n%v\n", c.Name,
+				hex.Dump(e), hex.Dump(a))
+		}
+	}
+}
+
+func BenchmarkEncode(b *testing.B) {
+	var w bytes.Buffer
+	encoder := NewEncoder(&w)
+	msg := Message{
+		Headers: Headers{
+			{Name: "event-id", Value: Int16Value(123)},
+		},
+		Payload: []byte(`{"abc":123}`),
+	}
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		err := encoder.Encode(msg)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/error.go

@@ -0,0 +1,23 @@
+package eventstream
+
+import "fmt"
+
+// LengthError provides the error for items being larger than a maximum length.
+type LengthError struct {
+	Part  string
+	Want  int
+	Have  int
+	Value interface{}
+}
+
+func (e LengthError) Error() string {
+	return fmt.Sprintf("%s length invalid, %d/%d, %v",
+		e.Part, e.Want, e.Have, e.Value)
+}
+
+// ChecksumError provides the error for message checksum invalidation errors.
+type ChecksumError struct{}
+
+func (e ChecksumError) Error() string {
+	return "message checksum mismatch"
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/api.go

@@ -0,0 +1,160 @@
+package eventstreamapi
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/private/protocol"
+	"github.com/aws/aws-sdk-go/private/protocol/eventstream"
+)
+
+// Unmarshaler provides the interface for unmarshaling a EventStream
+// message into a SDK type.
+type Unmarshaler interface {
+	UnmarshalEvent(protocol.PayloadUnmarshaler, eventstream.Message) error
+}
+
+// EventStream headers with specific meaning to async API functionality.
+const (
+	MessageTypeHeader    = `:message-type` // Identifies type of message.
+	EventMessageType     = `event`
+	ErrorMessageType     = `error`
+	ExceptionMessageType = `exception`
+
+	// Message Events
+	EventTypeHeader = `:event-type` // Identifies message event type e.g. "Stats".
+
+	// Message Error
+	ErrorCodeHeader    = `:error-code`
+	ErrorMessageHeader = `:error-message`
+
+	// Message Exception
+	ExceptionTypeHeader = `:exception-type`
+)
+
+// EventReader provides reading from the EventStream of an reader.
+type EventReader struct {
+	reader  io.ReadCloser
+	decoder *eventstream.Decoder
+
+	unmarshalerForEventType func(string) (Unmarshaler, error)
+	payloadUnmarshaler      protocol.PayloadUnmarshaler
+
+	payloadBuf []byte
+}
+
+// NewEventReader returns a EventReader built from the reader and unmarshaler
+// provided.  Use ReadStream method to start reading from the EventStream.
+func NewEventReader(
+	reader io.ReadCloser,
+	payloadUnmarshaler protocol.PayloadUnmarshaler,
+	unmarshalerForEventType func(string) (Unmarshaler, error),
+) *EventReader {
+	return &EventReader{
+		reader:                  reader,
+		decoder:                 eventstream.NewDecoder(reader),
+		payloadUnmarshaler:      payloadUnmarshaler,
+		unmarshalerForEventType: unmarshalerForEventType,
+		payloadBuf:              make([]byte, 10*1024),
+	}
+}
+
+// UseLogger instructs the EventReader to use the logger and log level
+// specified.
+func (r *EventReader) UseLogger(logger aws.Logger, logLevel aws.LogLevelType) {
+	if logger != nil && logLevel.Matches(aws.LogDebugWithEventStreamBody) {
+		r.decoder.UseLogger(logger)
+	}
+}
+
+// ReadEvent attempts to read a message from the EventStream and return the
+// unmarshaled event value that the message is for.
+//
+// For EventStream API errors check if the returned error satisfies the
+// awserr.Error interface to get the error's Code and Message components.
+//
+// EventUnmarshalers called with EventStream messages must take copies of the
+// message's Payload. The payload will is reused between events read.
+func (r *EventReader) ReadEvent() (event interface{}, err error) {
+	msg, err := r.decoder.Decode(r.payloadBuf)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		// Reclaim payload buffer for next message read.
+		r.payloadBuf = msg.Payload[0:0]
+	}()
+
+	typ, err := GetHeaderString(msg, MessageTypeHeader)
+	if err != nil {
+		return nil, err
+	}
+
+	switch typ {
+	case EventMessageType:
+		return r.unmarshalEventMessage(msg)
+	case ErrorMessageType:
+		return nil, r.unmarshalErrorMessage(msg)
+	default:
+		return nil, fmt.Errorf("unknown eventstream message type, %v", typ)
+	}
+}
+
+func (r *EventReader) unmarshalEventMessage(
+	msg eventstream.Message,
+) (event interface{}, err error) {
+	eventType, err := GetHeaderString(msg, EventTypeHeader)
+	if err != nil {
+		return nil, err
+	}
+
+	ev, err := r.unmarshalerForEventType(eventType)
+	if err != nil {
+		return nil, err
+	}
+
+	err = ev.UnmarshalEvent(r.payloadUnmarshaler, msg)
+	if err != nil {
+		return nil, err
+	}
+
+	return ev, nil
+}
+
+func (r *EventReader) unmarshalErrorMessage(msg eventstream.Message) (err error) {
+	var msgErr messageError
+
+	msgErr.code, err = GetHeaderString(msg, ErrorCodeHeader)
+	if err != nil {
+		return err
+	}
+
+	msgErr.msg, err = GetHeaderString(msg, ErrorMessageHeader)
+	if err != nil {
+		return err
+	}
+
+	return msgErr
+}
+
+// Close closes the EventReader's EventStream reader.
+func (r *EventReader) Close() error {
+	return r.reader.Close()
+}
+
+// GetHeaderString returns the value of the header as a string. If the header
+// is not set or the value is not a string an error will be returned.
+func GetHeaderString(msg eventstream.Message, headerName string) (string, error) {
+	headerVal := msg.Headers.Get(headerName)
+	if headerVal == nil {
+		return "", fmt.Errorf("error header %s not present", headerName)
+	}
+
+	v, ok := headerVal.Get().(string)
+	if !ok {
+		return "", fmt.Errorf("error header value is not a string, %T", headerVal)
+	}
+
+	return v, nil
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/api_test.go

@@ -0,0 +1,197 @@
+package eventstreamapi
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws/awserr"
+	"github.com/aws/aws-sdk-go/aws/request"
+	"github.com/aws/aws-sdk-go/private/protocol"
+	"github.com/aws/aws-sdk-go/private/protocol/eventstream"
+	"github.com/aws/aws-sdk-go/private/protocol/restjson"
+)
+
+var eventMessageTypeHeader = eventstream.Header{
+	Name:  MessageTypeHeader,
+	Value: eventstream.StringValue(EventMessageType),
+}
+
+func TestEventReader(t *testing.T) {
+	stream := createStream(
+		eventstream.Message{
+			Headers: eventstream.Headers{
+				eventMessageTypeHeader,
+				eventstream.Header{
+					Name:  EventTypeHeader,
+					Value: eventstream.StringValue("eventABC"),
+				},
+			},
+		},
+		eventstream.Message{
+			Headers: eventstream.Headers{
+				eventMessageTypeHeader,
+				eventstream.Header{
+					Name:  EventTypeHeader,
+					Value: eventstream.StringValue("eventEFG"),
+				},
+			},
+		},
+	)
+
+	var unmarshalers request.HandlerList
+	unmarshalers.PushBackNamed(restjson.UnmarshalHandler)
+
+	eventReader := NewEventReader(stream,
+		protocol.HandlerPayloadUnmarshal{
+			Unmarshalers: unmarshalers,
+		},
+		unmarshalerForEventType,
+	)
+
+	event, err := eventReader.ReadEvent()
+	if err != nil {
+		t.Fatalf("expect no error, got %v", err)
+	}
+
+	if event == nil {
+		t.Fatalf("expect event got none")
+	}
+
+	event, err = eventReader.ReadEvent()
+	if err == nil {
+		t.Fatalf("expect error for unknown event, got none")
+	}
+
+	if event != nil {
+		t.Fatalf("expect no event, got %T, %v", event, event)
+	}
+}
+
+func TestEventReader_Error(t *testing.T) {
+	stream := createStream(
+		eventstream.Message{
+			Headers: eventstream.Headers{
+				eventstream.Header{
+					Name:  MessageTypeHeader,
+					Value: eventstream.StringValue(ErrorMessageType),
+				},
+				eventstream.Header{
+					Name:  ErrorCodeHeader,
+					Value: eventstream.StringValue("errorCode"),
+				},
+				eventstream.Header{
+					Name:  ErrorMessageHeader,
+					Value: eventstream.StringValue("error message occur"),
+				},
+			},
+		},
+	)
+
+	var unmarshalers request.HandlerList
+	unmarshalers.PushBackNamed(restjson.UnmarshalHandler)
+
+	eventReader := NewEventReader(stream,
+		protocol.HandlerPayloadUnmarshal{
+			Unmarshalers: unmarshalers,
+		},
+		unmarshalerForEventType,
+	)
+
+	event, err := eventReader.ReadEvent()
+	if err == nil {
+		t.Fatalf("expect error got none")
+	}
+
+	if event != nil {
+		t.Fatalf("expect no event, got %v", event)
+	}
+
+	aerr := err.(awserr.Error)
+	if e, a := "errorCode", aerr.Code(); e != a {
+		t.Errorf("expect %v code, got %v", e, a)
+	}
+	if e, a := "error message occur", aerr.Message(); e != a {
+		t.Errorf("expect %v message, got %v", e, a)
+	}
+}
+
+func BenchmarkEventReader(b *testing.B) {
+	var buf bytes.Buffer
+	encoder := eventstream.NewEncoder(&buf)
+	msg := eventstream.Message{
+		Headers: eventstream.Headers{
+			eventMessageTypeHeader,
+			eventstream.Header{
+				Name:  EventTypeHeader,
+				Value: eventstream.StringValue("eventABC"),
+			},
+		},
+	}
+	if err := encoder.Encode(msg); err != nil {
+		b.Fatalf("failed to encode message, %v", err)
+	}
+	stream := bytes.NewReader(buf.Bytes())
+
+	var unmarshalers request.HandlerList
+	unmarshalers.PushBackNamed(restjson.UnmarshalHandler)
+
+	eventReader := NewEventReader(ioutil.NopCloser(stream),
+		protocol.HandlerPayloadUnmarshal{
+			Unmarshalers: unmarshalers,
+		},
+		unmarshalerForEventType,
+	)
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		stream.Seek(0, 0)
+
+		event, err := eventReader.ReadEvent()
+		if err != nil {
+			b.Fatalf("expect no error, got %v", err)
+		}
+		if event == nil {
+			b.Fatalf("expect event got none")
+		}
+	}
+}
+
+func unmarshalerForEventType(eventType string) (Unmarshaler, error) {
+	switch eventType {
+	case "eventABC":
+		return &eventABC{}, nil
+	default:
+		return nil, fmt.Errorf("unknown event type, %v", eventType)
+	}
+}
+
+type eventABC struct {
+	_ struct{}
+
+	HeaderField string
+	Payload     []byte
+}
+
+func (e *eventABC) UnmarshalEvent(
+	unmarshaler protocol.PayloadUnmarshaler,
+	msg eventstream.Message,
+) error {
+	return nil
+}
+
+func createStream(msgs ...eventstream.Message) io.ReadCloser {
+	w := bytes.NewBuffer(nil)
+
+	encoder := eventstream.NewEncoder(w)
+
+	for _, msg := range msgs {
+		if err := encoder.Encode(msg); err != nil {
+			panic("createStream failed, " + err.Error())
+		}
+	}
+
+	return ioutil.NopCloser(w)
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/error.go

@@ -0,0 +1,24 @@
+package eventstreamapi
+
+import "fmt"
+
+type messageError struct {
+	code string
+	msg  string
+}
+
+func (e messageError) Code() string {
+	return e.code
+}
+
+func (e messageError) Message() string {
+	return e.msg
+}
+
+func (e messageError) Error() string {
+	return fmt.Sprintf("%s: %s", e.code, e.msg)
+}
+
+func (e messageError) OrigErr() error {
+	return nil
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamtest/testing.go

@@ -0,0 +1,116 @@
+package eventstreamtest
+
+import (
+	"bytes"
+	"crypto/tls"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/session"
+	"github.com/aws/aws-sdk-go/awstesting/unit"
+	"github.com/aws/aws-sdk-go/private/protocol"
+	"github.com/aws/aws-sdk-go/private/protocol/eventstream"
+	"github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi"
+	"golang.org/x/net/http2"
+)
+
+// ServeEventStream provides serving EventStream messages from a HTTP server to
+// the client. The events are sent sequentially to the client without delay.
+type ServeEventStream struct {
+	T      *testing.T
+	Events []eventstream.Message
+}
+
+func (s ServeEventStream) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	w.WriteHeader(http.StatusOK)
+	encoder := eventstream.NewEncoder(flushWriter{w})
+
+	for _, event := range s.Events {
+		encoder.Encode(event)
+	}
+}
+
+// SetupEventStreamSession creates a HTTP server SDK session for communicating
+// with that server to be used for EventStream APIs. If HTTP/2 is enabled the
+// server/client will only attempt to use HTTP/2.
+func SetupEventStreamSession(
+	t *testing.T, handler http.Handler, h2 bool,
+) (sess *session.Session, cleanupFn func(), err error) {
+	server := httptest.NewUnstartedServer(handler)
+	server.Config.TLSConfig = &tls.Config{
+		InsecureSkipVerify: true,
+	}
+
+	clientTrans := &http.Transport{
+		TLSClientConfig: &tls.Config{
+			InsecureSkipVerify: true,
+		},
+	}
+
+	if h2 {
+		http2.ConfigureServer(server.Config, nil)
+		http2.ConfigureTransport(clientTrans)
+		server.Config.TLSConfig.NextProtos = []string{http2.NextProtoTLS}
+		clientTrans.TLSClientConfig.NextProtos = []string{http2.NextProtoTLS}
+	}
+	server.TLS = server.Config.TLSConfig
+
+	server.StartTLS()
+	cleanupFn = func() {
+		server.Close()
+	}
+
+	client := &http.Client{
+		Transport: clientTrans,
+	}
+
+	sess, err = session.NewSession(unit.Session.Config, &aws.Config{
+		Endpoint:               &server.URL,
+		DisableParamValidation: aws.Bool(true),
+		HTTPClient:             client,
+		//		LogLevel:               aws.LogLevel(aws.LogDebugWithEventStreamBody),
+	})
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return sess, cleanupFn, nil
+}
+
+type flushWriter struct {
+	w io.Writer
+}
+
+func (fw flushWriter) Write(p []byte) (n int, err error) {
+	n, err = fw.w.Write(p)
+	if f, ok := fw.w.(http.Flusher); ok {
+		f.Flush()
+	}
+	return
+}
+
+// MarshalEventPayload marshals a SDK API shape into its associated wire
+// protocol payload.
+func MarshalEventPayload(
+	payloadMarshaler protocol.PayloadMarshaler,
+	v interface{},
+) []byte {
+	var w bytes.Buffer
+	err := payloadMarshaler.MarshalPayload(&w, v)
+	if err != nil {
+		panic(fmt.Sprintf("failed to marshal event %T, %v", v, v))
+	}
+
+	return w.Bytes()
+}
+
+// EventMessageTypeHeader is a event message type header for marking an
+// message as being the event type.
+var EventMessageTypeHeader = eventstream.Header{
+	Name:  eventstreamapi.MessageTypeHeader,
+	Value: eventstream.StringValue(eventstreamapi.EventMessageType),
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/header.go

@@ -0,0 +1,166 @@
+package eventstream
+
+import (
+	"encoding/binary"
+	"fmt"
+	"io"
+)
+
+// Headers are a collection of EventStream header values.
+type Headers []Header
+
+// Header is a single EventStream Key Value header pair.
+type Header struct {
+	Name  string
+	Value Value
+}
+
+// Set associates the name with a value. If the header name already exists in
+// the Headers the value will be replaced with the new one.
+func (hs *Headers) Set(name string, value Value) {
+	var i int
+	for ; i < len(*hs); i++ {
+		if (*hs)[i].Name == name {
+			(*hs)[i].Value = value
+			return
+		}
+	}
+
+	*hs = append(*hs, Header{
+		Name: name, Value: value,
+	})
+}
+
+// Get returns the Value associated with the header. Nil is returned if the
+// value does not exist.
+func (hs Headers) Get(name string) Value {
+	for i := 0; i < len(hs); i++ {
+		if h := hs[i]; h.Name == name {
+			return h.Value
+		}
+	}
+	return nil
+}
+
+// Del deletes the value in the Headers if it exists.
+func (hs *Headers) Del(name string) {
+	for i := 0; i < len(*hs); i++ {
+		if (*hs)[i].Name == name {
+			copy((*hs)[i:], (*hs)[i+1:])
+			(*hs) = (*hs)[:len(*hs)-1]
+		}
+	}
+}
+
+func decodeHeaders(r io.Reader) (Headers, error) {
+	hs := Headers{}
+
+	for {
+		name, err := decodeHeaderName(r)
+		if err != nil {
+			if err == io.EOF {
+				// EOF while getting header name means no more headers
+				break
+			}
+			return nil, err
+		}
+
+		value, err := decodeHeaderValue(r)
+		if err != nil {
+			return nil, err
+		}
+
+		hs.Set(name, value)
+	}
+
+	return hs, nil
+}
+
+func decodeHeaderName(r io.Reader) (string, error) {
+	var n headerName
+
+	var err error
+	n.Len, err = decodeUint8(r)
+	if err != nil {
+		return "", err
+	}
+
+	name := n.Name[:n.Len]
+	if _, err := io.ReadFull(r, name); err != nil {
+		return "", err
+	}
+
+	return string(name), nil
+}
+
+func decodeHeaderValue(r io.Reader) (Value, error) {
+	var raw rawValue
+
+	typ, err := decodeUint8(r)
+	if err != nil {
+		return nil, err
+	}
+	raw.Type = valueType(typ)
+
+	var v Value
+
+	switch raw.Type {
+	case trueValueType:
+		v = BoolValue(true)
+	case falseValueType:
+		v = BoolValue(false)
+	case int8ValueType:
+		var tv Int8Value
+		err = tv.decode(r)
+		v = tv
+	case int16ValueType:
+		var tv Int16Value
+		err = tv.decode(r)
+		v = tv
+	case int32ValueType:
+		var tv Int32Value
+		err = tv.decode(r)
+		v = tv
+	case int64ValueType:
+		var tv Int64Value
+		err = tv.decode(r)
+		v = tv
+	case bytesValueType:
+		var tv BytesValue
+		err = tv.decode(r)
+		v = tv
+	case stringValueType:
+		var tv StringValue
+		err = tv.decode(r)
+		v = tv
+	case timestampValueType:
+		var tv TimestampValue
+		err = tv.decode(r)
+		v = tv
+	case uuidValueType:
+		var tv UUIDValue
+		err = tv.decode(r)
+		v = tv
+	default:
+		panic(fmt.Sprintf("unknown value type %d", raw.Type))
+	}
+
+	// Error could be EOF, let caller deal with it
+	return v, err
+}
+
+const maxHeaderNameLen = 255
+
+type headerName struct {
+	Len  uint8
+	Name [maxHeaderNameLen]byte
+}
+
+func (v headerName) encode(w io.Writer) error {
+	if err := binary.Write(w, binary.BigEndian, v.Len); err != nil {
+		return err
+	}
+
+	_, err := w.Write(v.Name[:v.Len])
+	return err
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/header_test.go

@@ -0,0 +1,66 @@
+package eventstream
+
+import (
+	"reflect"
+	"testing"
+	"time"
+)
+
+func TestHeaders_Set(t *testing.T) {
+	expect := Headers{
+		{Name: "ABC", Value: StringValue("123")},
+		{Name: "EFG", Value: TimestampValue(time.Time{})},
+	}
+
+	var actual Headers
+	actual.Set("ABC", Int32Value(123))
+	actual.Set("ABC", StringValue("123")) // replase case
+	actual.Set("EFG", TimestampValue(time.Time{}))
+
+	if e, a := expect, actual; !reflect.DeepEqual(e, a) {
+		t.Errorf("expect %v headers, got %v", e, a)
+	}
+}
+
+func TestHeaders_Get(t *testing.T) {
+	headers := Headers{
+		{Name: "ABC", Value: StringValue("123")},
+		{Name: "EFG", Value: TimestampValue(time.Time{})},
+	}
+
+	cases := []struct {
+		Name  string
+		Value Value
+	}{
+		{Name: "ABC", Value: StringValue("123")},
+		{Name: "EFG", Value: TimestampValue(time.Time{})},
+		{Name: "NotFound"},
+	}
+
+	for i, c := range cases {
+		actual := headers.Get(c.Name)
+		if e, a := c.Value, actual; !reflect.DeepEqual(e, a) {
+			t.Errorf("%d, expect %v value, got %v", i, e, a)
+		}
+	}
+}
+
+func TestHeaders_Del(t *testing.T) {
+	headers := Headers{
+		{Name: "ABC", Value: StringValue("123")},
+		{Name: "EFG", Value: TimestampValue(time.Time{})},
+		{Name: "HIJ", Value: StringValue("123")},
+		{Name: "KML", Value: TimestampValue(time.Time{})},
+	}
+	expectAfterDel := Headers{
+		{Name: "EFG", Value: TimestampValue(time.Time{})},
+	}
+
+	headers.Del("HIJ")
+	headers.Del("ABC")
+	headers.Del("KML")
+
+	if e, a := expectAfterDel, headers; !reflect.DeepEqual(e, a) {
+		t.Errorf("expect %v headers, got %v", e, a)
+	}
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/header_value.go

@@ -0,0 +1,501 @@
+package eventstream
+
+import (
+	"encoding/base64"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"strconv"
+	"time"
+)
+
+const maxHeaderValueLen = 1<<15 - 1 // 2^15-1 or 32KB - 1
+
+// valueType is the EventStream header value type.
+type valueType uint8
+
+// Header value types
+const (
+	trueValueType valueType = iota
+	falseValueType
+	int8ValueType  // Byte
+	int16ValueType // Short
+	int32ValueType // Integer
+	int64ValueType // Long
+	bytesValueType
+	stringValueType
+	timestampValueType
+	uuidValueType
+)
+
+func (t valueType) String() string {
+	switch t {
+	case trueValueType:
+		return "bool"
+	case falseValueType:
+		return "bool"
+	case int8ValueType:
+		return "int8"
+	case int16ValueType:
+		return "int16"
+	case int32ValueType:
+		return "int32"
+	case int64ValueType:
+		return "int64"
+	case bytesValueType:
+		return "byte_array"
+	case stringValueType:
+		return "string"
+	case timestampValueType:
+		return "timestamp"
+	case uuidValueType:
+		return "uuid"
+	default:
+		return fmt.Sprintf("unknown value type %d", uint8(t))
+	}
+}
+
+type rawValue struct {
+	Type  valueType
+	Len   uint16 // Only set for variable length slices
+	Value []byte // byte representation of value, BigEndian encoding.
+}
+
+func (r rawValue) encodeScalar(w io.Writer, v interface{}) error {
+	return binaryWriteFields(w, binary.BigEndian,
+		r.Type,
+		v,
+	)
+}
+
+func (r rawValue) encodeFixedSlice(w io.Writer, v []byte) error {
+	binary.Write(w, binary.BigEndian, r.Type)
+
+	_, err := w.Write(v)
+	return err
+}
+
+func (r rawValue) encodeBytes(w io.Writer, v []byte) error {
+	if len(v) > maxHeaderValueLen {
+		return LengthError{
+			Part: "header value",
+			Want: maxHeaderValueLen, Have: len(v),
+			Value: v,
+		}
+	}
+	r.Len = uint16(len(v))
+
+	err := binaryWriteFields(w, binary.BigEndian,
+		r.Type,
+		r.Len,
+	)
+	if err != nil {
+		return err
+	}
+
+	_, err = w.Write(v)
+	return err
+}
+
+func (r rawValue) encodeString(w io.Writer, v string) error {
+	if len(v) > maxHeaderValueLen {
+		return LengthError{
+			Part: "header value",
+			Want: maxHeaderValueLen, Have: len(v),
+			Value: v,
+		}
+	}
+	r.Len = uint16(len(v))
+
+	type stringWriter interface {
+		WriteString(string) (int, error)
+	}
+
+	err := binaryWriteFields(w, binary.BigEndian,
+		r.Type,
+		r.Len,
+	)
+	if err != nil {
+		return err
+	}
+
+	if sw, ok := w.(stringWriter); ok {
+		_, err = sw.WriteString(v)
+	} else {
+		_, err = w.Write([]byte(v))
+	}
+
+	return err
+}
+
+func decodeFixedBytesValue(r io.Reader, buf []byte) error {
+	_, err := io.ReadFull(r, buf)
+	return err
+}
+
+func decodeBytesValue(r io.Reader) ([]byte, error) {
+	var raw rawValue
+	var err error
+	raw.Len, err = decodeUint16(r)
+	if err != nil {
+		return nil, err
+	}
+
+	buf := make([]byte, raw.Len)
+	_, err = io.ReadFull(r, buf)
+	if err != nil {
+		return nil, err
+	}
+
+	return buf, nil
+}
+
+func decodeStringValue(r io.Reader) (string, error) {
+	v, err := decodeBytesValue(r)
+	return string(v), err
+}
+
+// Value represents the abstract header value.
+type Value interface {
+	Get() interface{}
+	String() string
+	valueType() valueType
+	encode(io.Writer) error
+}
+
+// An BoolValue provides eventstream encoding, and representation
+// of a Go bool value.
+type BoolValue bool
+
+// Get returns the underlying type
+func (v BoolValue) Get() interface{} {
+	return bool(v)
+}
+
+// valueType returns the EventStream header value type value.
+func (v BoolValue) valueType() valueType {
+	if v {
+		return trueValueType
+	}
+	return falseValueType
+}
+
+func (v BoolValue) String() string {
+	return strconv.FormatBool(bool(v))
+}
+
+// encode encodes the BoolValue into an eventstream binary value
+// representation.
+func (v BoolValue) encode(w io.Writer) error {
+	return binary.Write(w, binary.BigEndian, v.valueType())
+}
+
+// An Int8Value provides eventstream encoding, and representation of a Go
+// int8 value.
+type Int8Value int8
+
+// Get returns the underlying value.
+func (v Int8Value) Get() interface{} {
+	return int8(v)
+}
+
+// valueType returns the EventStream header value type value.
+func (Int8Value) valueType() valueType {
+	return int8ValueType
+}
+
+func (v Int8Value) String() string {
+	return fmt.Sprintf("0x%02x", int8(v))
+}
+
+// encode encodes the Int8Value into an eventstream binary value
+// representation.
+func (v Int8Value) encode(w io.Writer) error {
+	raw := rawValue{
+		Type: v.valueType(),
+	}
+
+	return raw.encodeScalar(w, v)
+}
+
+func (v *Int8Value) decode(r io.Reader) error {
+	n, err := decodeUint8(r)
+	if err != nil {
+		return err
+	}
+
+	*v = Int8Value(n)
+	return nil
+}
+
+// An Int16Value provides eventstream encoding, and representation of a Go
+// int16 value.
+type Int16Value int16
+
+// Get returns the underlying value.
+func (v Int16Value) Get() interface{} {
+	return int16(v)
+}
+
+// valueType returns the EventStream header value type value.
+func (Int16Value) valueType() valueType {
+	return int16ValueType
+}
+
+func (v Int16Value) String() string {
+	return fmt.Sprintf("0x%04x", int16(v))
+}
+
+// encode encodes the Int16Value into an eventstream binary value
+// representation.
+func (v Int16Value) encode(w io.Writer) error {
+	raw := rawValue{
+		Type: v.valueType(),
+	}
+	return raw.encodeScalar(w, v)
+}
+
+func (v *Int16Value) decode(r io.Reader) error {
+	n, err := decodeUint16(r)
+	if err != nil {
+		return err
+	}
+
+	*v = Int16Value(n)
+	return nil
+}
+
+// An Int32Value provides eventstream encoding, and representation of a Go
+// int32 value.
+type Int32Value int32
+
+// Get returns the underlying value.
+func (v Int32Value) Get() interface{} {
+	return int32(v)
+}
+
+// valueType returns the EventStream header value type value.
+func (Int32Value) valueType() valueType {
+	return int32ValueType
+}
+
+func (v Int32Value) String() string {
+	return fmt.Sprintf("0x%08x", int32(v))
+}
+
+// encode encodes the Int32Value into an eventstream binary value
+// representation.
+func (v Int32Value) encode(w io.Writer) error {
+	raw := rawValue{
+		Type: v.valueType(),
+	}
+	return raw.encodeScalar(w, v)
+}
+
+func (v *Int32Value) decode(r io.Reader) error {
+	n, err := decodeUint32(r)
+	if err != nil {
+		return err
+	}
+
+	*v = Int32Value(n)
+	return nil
+}
+
+// An Int64Value provides eventstream encoding, and representation of a Go
+// int64 value.
+type Int64Value int64
+
+// Get returns the underlying value.
+func (v Int64Value) Get() interface{} {
+	return int64(v)
+}
+
+// valueType returns the EventStream header value type value.
+func (Int64Value) valueType() valueType {
+	return int64ValueType
+}
+
+func (v Int64Value) String() string {
+	return fmt.Sprintf("0x%016x", int64(v))
+}
+
+// encode encodes the Int64Value into an eventstream binary value
+// representation.
+func (v Int64Value) encode(w io.Writer) error {
+	raw := rawValue{
+		Type: v.valueType(),
+	}
+	return raw.encodeScalar(w, v)
+}
+
+func (v *Int64Value) decode(r io.Reader) error {
+	n, err := decodeUint64(r)
+	if err != nil {
+		return err
+	}
+
+	*v = Int64Value(n)
+	return nil
+}
+
+// An BytesValue provides eventstream encoding, and representation of a Go
+// byte slice.
+type BytesValue []byte
+
+// Get returns the underlying value.
+func (v BytesValue) Get() interface{} {
+	return []byte(v)
+}
+
+// valueType returns the EventStream header value type value.
+func (BytesValue) valueType() valueType {
+	return bytesValueType
+}
+
+func (v BytesValue) String() string {
+	return base64.StdEncoding.EncodeToString([]byte(v))
+}
+
+// encode encodes the BytesValue into an eventstream binary value
+// representation.
+func (v BytesValue) encode(w io.Writer) error {
+	raw := rawValue{
+		Type: v.valueType(),
+	}
+
+	return raw.encodeBytes(w, []byte(v))
+}
+
+func (v *BytesValue) decode(r io.Reader) error {
+	buf, err := decodeBytesValue(r)
+	if err != nil {
+		return err
+	}
+
+	*v = BytesValue(buf)
+	return nil
+}
+
+// An StringValue provides eventstream encoding, and representation of a Go
+// string.
+type StringValue string
+
+// Get returns the underlying value.
+func (v StringValue) Get() interface{} {
+	return string(v)
+}
+
+// valueType returns the EventStream header value type value.
+func (StringValue) valueType() valueType {
+	return stringValueType
+}
+
+func (v StringValue) String() string {
+	return string(v)
+}
+
+// encode encodes the StringValue into an eventstream binary value
+// representation.
+func (v StringValue) encode(w io.Writer) error {
+	raw := rawValue{
+		Type: v.valueType(),
+	}
+
+	return raw.encodeString(w, string(v))
+}
+
+func (v *StringValue) decode(r io.Reader) error {
+	s, err := decodeStringValue(r)
+	if err != nil {
+		return err
+	}
+
+	*v = StringValue(s)
+	return nil
+}
+
+// An TimestampValue provides eventstream encoding, and representation of a Go
+// timestamp.
+type TimestampValue time.Time
+
+// Get returns the underlying value.
+func (v TimestampValue) Get() interface{} {
+	return time.Time(v)
+}
+
+// valueType returns the EventStream header value type value.
+func (TimestampValue) valueType() valueType {
+	return timestampValueType
+}
+
+func (v TimestampValue) epochMilli() int64 {
+	nano := time.Time(v).UnixNano()
+	msec := nano / int64(time.Millisecond)
+	return msec
+}
+
+func (v TimestampValue) String() string {
+	msec := v.epochMilli()
+	return strconv.FormatInt(msec, 10)
+}
+
+// encode encodes the TimestampValue into an eventstream binary value
+// representation.
+func (v TimestampValue) encode(w io.Writer) error {
+	raw := rawValue{
+		Type: v.valueType(),
+	}
+
+	msec := v.epochMilli()
+	return raw.encodeScalar(w, msec)
+}
+
+func (v *TimestampValue) decode(r io.Reader) error {
+	n, err := decodeUint64(r)
+	if err != nil {
+		return err
+	}
+
+	*v = TimestampValue(timeFromEpochMilli(int64(n)))
+	return nil
+}
+
+func timeFromEpochMilli(t int64) time.Time {
+	secs := t / 1e3
+	msec := t % 1e3
+	return time.Unix(secs, msec*int64(time.Millisecond))
+}
+
+// An UUIDValue provides eventstream encoding, and representation of a UUID
+// value.
+type UUIDValue [16]byte
+
+// Get returns the underlying value.
+func (v UUIDValue) Get() interface{} {
+	return v[:]
+}
+
+// valueType returns the EventStream header value type value.
+func (UUIDValue) valueType() valueType {
+	return uuidValueType
+}
+
+func (v UUIDValue) String() string {
+	return fmt.Sprintf(`%X-%X-%X-%X-%X`, v[0:4], v[4:6], v[6:8], v[8:10], v[10:])
+}
+
+// encode encodes the UUIDValue into an eventstream binary value
+// representation.
+func (v UUIDValue) encode(w io.Writer) error {
+	raw := rawValue{
+		Type: v.valueType(),
+	}
+
+	return raw.encodeFixedSlice(w, v[:])
+}
+
+func (v *UUIDValue) decode(r io.Reader) error {
+	tv := (*v)[:]
+	return decodeFixedBytesValue(r, tv)
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/header_value_test.go

@@ -0,0 +1,203 @@
+package eventstream
+
+import (
+	"bytes"
+	"encoding/binary"
+	"io"
+	"reflect"
+	"testing"
+	"time"
+)
+
+func binWrite(v interface{}) []byte {
+	var w bytes.Buffer
+	binary.Write(&w, binary.BigEndian, v)
+	return w.Bytes()
+}
+
+var testValueEncodingCases = []struct {
+	Val    Value
+	Expect []byte
+	Decode func(io.Reader) (Value, error)
+}{
+	{
+		BoolValue(true),
+		[]byte{byte(trueValueType)},
+		nil,
+	},
+	{
+		BoolValue(false),
+		[]byte{byte(falseValueType)},
+		nil,
+	},
+	{
+		Int8Value(0x0f),
+		[]byte{byte(int8ValueType), 0x0f},
+		func(r io.Reader) (Value, error) {
+			var v Int8Value
+			err := v.decode(r)
+			return v, err
+		},
+	},
+	{
+		Int16Value(0x0f),
+		append([]byte{byte(int16ValueType)}, binWrite(int16(0x0f))...),
+		func(r io.Reader) (Value, error) {
+			var v Int16Value
+			err := v.decode(r)
+			return v, err
+		},
+	},
+	{
+		Int32Value(0x0f),
+		append([]byte{byte(int32ValueType)}, binWrite(int32(0x0f))...),
+		func(r io.Reader) (Value, error) {
+			var v Int32Value
+			err := v.decode(r)
+			return v, err
+		},
+	},
+	{
+		Int64Value(0x0f),
+		append([]byte{byte(int64ValueType)}, binWrite(int64(0x0f))...),
+		func(r io.Reader) (Value, error) {
+			var v Int64Value
+			err := v.decode(r)
+			return v, err
+		},
+	},
+	{
+		BytesValue([]byte{0, 1, 2, 3}),
+		[]byte{byte(bytesValueType), 0x00, 0x04, 0, 1, 2, 3},
+		func(r io.Reader) (Value, error) {
+			var v BytesValue
+			err := v.decode(r)
+			return v, err
+		},
+	},
+	{
+		StringValue("abc123"),
+		append([]byte{byte(stringValueType), 0, 6}, []byte("abc123")...),
+		func(r io.Reader) (Value, error) {
+			var v StringValue
+			err := v.decode(r)
+			return v, err
+		},
+	},
+	{
+		TimestampValue(
+			time.Date(2014, 04, 04, 0, 1, 0, 0, time.FixedZone("PDT", -7)),
+		),
+		append([]byte{byte(timestampValueType)}, binWrite(int64(1396569667000))...),
+		func(r io.Reader) (Value, error) {
+			var v TimestampValue
+			err := v.decode(r)
+			return v, err
+		},
+	},
+	{
+		UUIDValue(
+			[16]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf},
+		),
+		[]byte{byte(uuidValueType), 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf},
+		func(r io.Reader) (Value, error) {
+			var v UUIDValue
+			err := v.decode(r)
+			return v, err
+		},
+	},
+}
+
+func TestValue_MarshalValue(t *testing.T) {
+	for i, c := range testValueEncodingCases {
+		var w bytes.Buffer
+
+		if err := c.Val.encode(&w); err != nil {
+			t.Fatalf("%d, expect no error, got %v", i, err)
+		}
+
+		if e, a := c.Expect, w.Bytes(); !reflect.DeepEqual(e, a) {
+			t.Errorf("%d, expect %v, got %v", i, e, a)
+		}
+	}
+}
+
+func TestHeader_DecodeValues(t *testing.T) {
+	for i, c := range testValueEncodingCases {
+		r := bytes.NewBuffer(c.Expect)
+		v, err := decodeHeaderValue(r)
+		if err != nil {
+			t.Fatalf("%d, expect no error, got %v", i, err)
+		}
+
+		switch tv := v.(type) {
+		case TimestampValue:
+			exp := time.Time(c.Val.(TimestampValue))
+			if e, a := exp, time.Time(tv); !e.Equal(a) {
+				t.Errorf("%d, expect %v, got %v", i, e, a)
+			}
+		default:
+			if e, a := c.Val, v; !reflect.DeepEqual(e, a) {
+				t.Errorf("%d, expect %v, got %v", i, e, a)
+			}
+		}
+	}
+}
+
+func TestValue_Decode(t *testing.T) {
+	for i, c := range testValueEncodingCases {
+		if c.Decode == nil {
+			continue
+		}
+
+		r := bytes.NewBuffer(c.Expect)
+		r.ReadByte() // strip off Type field
+
+		v, err := c.Decode(r)
+		if err != nil {
+			t.Fatalf("%d, expect no error, got %v", i, err)
+		}
+
+		switch tv := v.(type) {
+		case TimestampValue:
+			exp := time.Time(c.Val.(TimestampValue))
+			if e, a := exp, time.Time(tv); !e.Equal(a) {
+				t.Errorf("%d, expect %v, got %v", i, e, a)
+			}
+		default:
+			if e, a := c.Val, v; !reflect.DeepEqual(e, a) {
+				t.Errorf("%d, expect %v, got %v", i, e, a)
+			}
+		}
+	}
+}
+
+func TestValue_String(t *testing.T) {
+	cases := []struct {
+		Val    Value
+		Expect string
+	}{
+		{BoolValue(true), "true"},
+		{BoolValue(false), "false"},
+		{Int8Value(0x0f), "0x0f"},
+		{Int16Value(0x0f), "0x000f"},
+		{Int32Value(0x0f), "0x0000000f"},
+		{Int64Value(0x0f), "0x000000000000000f"},
+		{BytesValue([]byte{0, 1, 2, 3}), "AAECAw=="},
+		{StringValue("abc123"), "abc123"},
+		{TimestampValue(
+			time.Date(2014, 04, 04, 0, 1, 0, 0, time.FixedZone("PDT", -7)),
+		),
+			"1396569667000",
+		},
+		{UUIDValue([16]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf}),
+			"00010203-0405-0607-0809-0A0B0C0D0E0F",
+		},
+	}
+
+	for i, c := range cases {
+		if e, a := c.Expect, c.Val.String(); e != a {
+			t.Errorf("%d, expect %v, got %v", i, e, a)
+		}
+	}
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/message.go

@@ -0,0 +1,103 @@
+package eventstream
+
+import (
+	"bytes"
+	"encoding/binary"
+	"hash/crc32"
+)
+
+const preludeLen = 8
+const preludeCRCLen = 4
+const msgCRCLen = 4
+const minMsgLen = preludeLen + preludeCRCLen + msgCRCLen
+const maxPayloadLen = 1024 * 1024 * 16 // 16MB
+const maxHeadersLen = 1024 * 128       // 128KB
+const maxMsgLen = minMsgLen + maxHeadersLen + maxPayloadLen
+
+var crc32IEEETable = crc32.MakeTable(crc32.IEEE)
+
+// A Message provides the eventstream message representation.
+type Message struct {
+	Headers Headers
+	Payload []byte
+}
+
+func (m *Message) rawMessage() (rawMessage, error) {
+	var raw rawMessage
+
+	if len(m.Headers) > 0 {
+		var headers bytes.Buffer
+		if err := encodeHeaders(&headers, m.Headers); err != nil {
+			return rawMessage{}, err
+		}
+		raw.Headers = headers.Bytes()
+		raw.HeadersLen = uint32(len(raw.Headers))
+	}
+
+	raw.Length = raw.HeadersLen + uint32(len(m.Payload)) + minMsgLen
+
+	hash := crc32.New(crc32IEEETable)
+	binaryWriteFields(hash, binary.BigEndian, raw.Length, raw.HeadersLen)
+	raw.PreludeCRC = hash.Sum32()
+
+	binaryWriteFields(hash, binary.BigEndian, raw.PreludeCRC)
+
+	if raw.HeadersLen > 0 {
+		hash.Write(raw.Headers)
+	}
+
+	// Read payload bytes and update hash for it as well.
+	if len(m.Payload) > 0 {
+		raw.Payload = m.Payload
+		hash.Write(raw.Payload)
+	}
+
+	raw.CRC = hash.Sum32()
+
+	return raw, nil
+}
+
+type messagePrelude struct {
+	Length     uint32
+	HeadersLen uint32
+	PreludeCRC uint32
+}
+
+func (p messagePrelude) PayloadLen() uint32 {
+	return p.Length - p.HeadersLen - minMsgLen
+}
+
+func (p messagePrelude) ValidateLens() error {
+	if p.Length == 0 || p.Length > maxMsgLen {
+		return LengthError{
+			Part: "message prelude",
+			Want: maxMsgLen,
+			Have: int(p.Length),
+		}
+	}
+	if p.HeadersLen > maxHeadersLen {
+		return LengthError{
+			Part: "message headers",
+			Want: maxHeadersLen,
+			Have: int(p.HeadersLen),
+		}
+	}
+	if payloadLen := p.PayloadLen(); payloadLen > maxPayloadLen {
+		return LengthError{
+			Part: "message payload",
+			Want: maxPayloadLen,
+			Have: int(payloadLen),
+		}
+	}
+
+	return nil
+}
+
+type rawMessage struct {
+	messagePrelude
+
+	Headers []byte
+	Payload []byte
+
+	CRC uint32
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/shared_test.go

@@ -0,0 +1,152 @@
+package eventstream
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"path/filepath"
+	"testing"
+)
+
+type testCase struct {
+	Name    string
+	Encoded []byte
+	Decoded decodedMessage
+}
+
+type testErrorCase struct {
+	Name    string
+	Encoded []byte
+	Err     string
+}
+
+type rawTestCase struct {
+	Name             string
+	Encoded, Decoded []byte
+}
+
+func readRawTestCases(root, class string) (map[string]rawTestCase, error) {
+	encoded, err := readTests(filepath.Join(root, "encoded", class))
+	if err != nil {
+		return nil, err
+	}
+
+	decoded, err := readTests(filepath.Join(root, "decoded", class))
+	if err != nil {
+		return nil, err
+	}
+
+	if len(encoded) == 0 {
+		return nil, fmt.Errorf("expect encoded cases, found none")
+	}
+
+	if len(encoded) != len(decoded) {
+		return nil, fmt.Errorf("encoded and decoded sets different")
+	}
+
+	rawCases := map[string]rawTestCase{}
+	for name, encData := range encoded {
+		decData, ok := decoded[name]
+		if !ok {
+			return nil, fmt.Errorf("encoded %q case not found in decoded set", name)
+		}
+
+		rawCases[name] = rawTestCase{
+			Name:    name,
+			Encoded: encData,
+			Decoded: decData,
+		}
+	}
+
+	return rawCases, nil
+}
+
+func readNegativeTests(root string) ([]testErrorCase, error) {
+	rawCases, err := readRawTestCases(root, "negative")
+	if err != nil {
+		return nil, err
+	}
+
+	cases := make([]testErrorCase, 0, len(rawCases))
+	for name, rawCase := range rawCases {
+		cases = append(cases, testErrorCase{
+			Name:    name,
+			Encoded: rawCase.Encoded,
+			Err:     string(rawCase.Decoded),
+		})
+	}
+
+	return cases, nil
+}
+
+func readPositiveTests(root string) ([]testCase, error) {
+	rawCases, err := readRawTestCases(root, "positive")
+	if err != nil {
+		return nil, err
+	}
+
+	cases := make([]testCase, 0, len(rawCases))
+	for name, rawCase := range rawCases {
+
+		var dec decodedMessage
+		if err := json.Unmarshal(rawCase.Decoded, &dec); err != nil {
+			return nil, fmt.Errorf("failed to decode %q, %v", name, err)
+		}
+
+		cases = append(cases, testCase{
+			Name:    name,
+			Encoded: rawCase.Encoded,
+			Decoded: dec,
+		})
+	}
+
+	return cases, nil
+}
+
+func readTests(root string) (map[string][]byte, error) {
+	items, err := ioutil.ReadDir(root)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read test suite %q dirs, %v", root, err)
+	}
+
+	cases := map[string][]byte{}
+	for _, item := range items {
+		if item.IsDir() {
+			continue
+		}
+
+		filename := filepath.Join(root, item.Name())
+		data, err := ioutil.ReadFile(filename)
+		if err != nil {
+			return nil, fmt.Errorf("failed to read test_data file %q, %v", filename, err)
+		}
+
+		cases[item.Name()] = data
+	}
+
+	return cases, nil
+}
+
+func compareLines(t *testing.T, a, b []byte) bool {
+	as := bufio.NewScanner(bytes.NewBuffer(a))
+	bs := bufio.NewScanner(bytes.NewBuffer(b))
+
+	var failed bool
+	for {
+		if ab, bb := as.Scan(), bs.Scan(); ab != bb {
+			t.Errorf("expect a & b to have same number of lines")
+			return false
+		} else if !ab {
+			break
+		}
+
+		if v1, v2 := as.Text(), bs.Text(); v1 != v2 {
+			t.Errorf("expect %q to be %q", v1, v2)
+			failed = true
+		}
+	}
+
+	return !failed
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/decoded/negative/corrupted_header_len

@@ -0,0 +1 @@
+Prelude checksum mismatch

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/decoded/negative/corrupted_headers

@@ -0,0 +1 @@
+Message checksum mismatch

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/decoded/negative/corrupted_length

@@ -0,0 +1 @@
+Prelude checksum mismatch

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/decoded/negative/corrupted_payload

@@ -0,0 +1 @@
+Message checksum mismatch

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/decoded/positive/all_headers

@@ -0,0 +1,58 @@
+{
+  "total_length": 204,
+  "headers_length": 175,
+  "prelude_crc": 263087306,
+  "headers": [    {
+      "name": "event-type",
+      "type": 4,
+      "value": 40972
+    },
+    {
+      "name": "content-type",
+      "type": 7,
+      "value": "YXBwbGljYXRpb24vanNvbg=="
+    },
+    {
+      "name": "bool false",
+      "type": 1,
+      "value": false
+    },
+    {
+      "name": "bool true",
+      "type": 0,
+      "value": true
+    },
+    {
+      "name": "byte",
+      "type": 2,
+      "value": -49
+    },
+    {
+      "name": "byte buf",
+      "type": 6,
+      "value": "SSdtIGEgbGl0dGxlIHRlYXBvdCE="
+    },
+    {
+      "name": "timestamp",
+      "type": 8,
+      "value": 8675309
+    },
+    {
+      "name": "int16",
+      "type": 3,
+      "value": 42
+    },
+    {
+      "name": "int64",
+      "type": 5,
+      "value": 42424242
+    },
+    {
+      "name": "uuid",
+      "type": 9,
+      "value": "AQIDBAUGBwgJCgsMDQ4PEA=="
+    }
+  ],
+  "payload": "eydmb28nOidiYXInfQ==",
+  "message_crc": -1415188212
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/decoded/positive/empty_message

@@ -0,0 +1,8 @@
+{
+  "total_length": 16,
+  "headers_length": 0,
+  "prelude_crc": 96618731,
+  "headers": [  ],
+  "payload": "",
+  "message_crc": 2107164927
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/decoded/positive/int32_header

@@ -0,0 +1,13 @@
+{
+  "total_length": 45,
+  "headers_length": 16,
+  "prelude_crc": 1103373496,
+  "headers": [    {
+      "name": "event-type",
+      "type": 4,
+      "value": 40972
+    }
+  ],
+  "payload": "eydmb28nOidiYXInfQ==",
+  "message_crc": 921993376
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/decoded/positive/payload_no_headers

@@ -0,0 +1,8 @@
+{
+  "total_length": 29,
+  "headers_length": 0,
+  "prelude_crc": -44921766,
+  "headers": [  ],
+  "payload": "eydmb28nOidiYXInfQ==",
+  "message_crc": -1016776394
+}

vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/decoded/positive/payload_one_str_header

@@ -0,0 +1,13 @@
+{
+  "total_length": 61,
+  "headers_length": 32,
+  "prelude_crc": 134054806,
+  "headers": [    {
+      "name": "content-type",
+      "type": 7,
+      "value": "YXBwbGljYXRpb24vanNvbg=="
+    }
+  ],
+  "payload": "eydmb28nOidiYXInfQ==",
+  "message_crc": -1919153999
+}

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

@@ -76,6 +76,7 @@ func newInputService1ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice1protocoltest",
+				ServiceID:     "InputService1ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -224,6 +225,7 @@ func newInputService2ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice2protocoltest",
+				ServiceID:     "InputService2ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -371,6 +373,7 @@ func newInputService3ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice3protocoltest",
+				ServiceID:     "InputService3ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -601,6 +604,7 @@ func newInputService4ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice4protocoltest",
+				ServiceID:     "InputService4ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -749,6 +753,7 @@ func newInputService5ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice5protocoltest",
+				ServiceID:     "InputService5ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1302,6 +1307,7 @@ func newInputService6ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice6protocoltest",
+				ServiceID:     "InputService6ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1450,6 +1456,7 @@ func newInputService7ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice7protocoltest",
+				ServiceID:     "InputService7ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1671,6 +1678,7 @@ func newInputService8ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice8protocoltest",
+				ServiceID:     "InputService8ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,

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

@@ -76,6 +76,7 @@ func newOutputService1ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice1protocoltest",
+				ServiceID:     "OutputService1ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -275,6 +276,7 @@ func newOutputService2ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice2protocoltest",
+				ServiceID:     "OutputService2ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -440,6 +442,7 @@ func newOutputService3ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice3protocoltest",
+				ServiceID:     "OutputService3ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -603,6 +606,7 @@ func newOutputService4ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice4protocoltest",
+				ServiceID:     "OutputService4ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -838,6 +842,7 @@ func newOutputService5ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice5protocoltest",
+				ServiceID:     "OutputService5ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -981,6 +986,7 @@ func newOutputService6ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice6protocoltest",
+				ServiceID:     "OutputService6ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1124,6 +1130,7 @@ func newOutputService7ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice7protocoltest",
+				ServiceID:     "OutputService7ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1351,10 +1358,10 @@ func TestOutputService3ProtocolTestTimestampMembersCase1(t *testing.T) {
 	if out == nil {
 		t.Errorf("expect not to be nil")
 	}
-	if e, a := time.Unix(1.398796238e+09, 0).UTC().String(), out.StructMember.Foo.String(); e != a {
+	if e, a := time.Unix(1.398796238e+09, 0).UTC().String(), out.StructMember.Foo.UTC().String(); e != a {
 		t.Errorf("expect %v, got %v", e, a)
 	}
-	if e, a := time.Unix(1.398796238e+09, 0).UTC().String(), out.TimeMember.String(); e != a {
+	if e, a := time.Unix(1.398796238e+09, 0).UTC().String(), out.TimeMember.UTC().String(); e != a {
 		t.Errorf("expect %v, got %v", e, a)
 	}
 

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

@@ -0,0 +1,81 @@
+package protocol
+
+import (
+	"io"
+	"io/ioutil"
+	"net/http"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/client/metadata"
+	"github.com/aws/aws-sdk-go/aws/request"
+)
+
+// PayloadUnmarshaler provides the interface for unmarshaling a payload's
+// reader into a SDK shape.
+type PayloadUnmarshaler interface {
+	UnmarshalPayload(io.Reader, interface{}) error
+}
+
+// HandlerPayloadUnmarshal implements the PayloadUnmarshaler from a
+// HandlerList. This provides the support for unmarshaling a payload reader to
+// a shape without needing a SDK request first.
+type HandlerPayloadUnmarshal struct {
+	Unmarshalers request.HandlerList
+}
+
+// UnmarshalPayload unmarshals the io.Reader payload into the SDK shape using
+// the Unmarshalers HandlerList provided. Returns an error if unable
+// unmarshaling fails.
+func (h HandlerPayloadUnmarshal) UnmarshalPayload(r io.Reader, v interface{}) error {
+	req := &request.Request{
+		HTTPRequest: &http.Request{},
+		HTTPResponse: &http.Response{
+			StatusCode: 200,
+			Header:     http.Header{},
+			Body:       ioutil.NopCloser(r),
+		},
+		Data: v,
+	}
+
+	h.Unmarshalers.Run(req)
+
+	return req.Error
+}
+
+// PayloadMarshaler provides the interface for marshaling a SDK shape into and
+// io.Writer.
+type PayloadMarshaler interface {
+	MarshalPayload(io.Writer, interface{}) error
+}
+
+// HandlerPayloadMarshal implements the PayloadMarshaler from a HandlerList.
+// This provides support for marshaling a SDK shape into an io.Writer without
+// needing a SDK request first.
+type HandlerPayloadMarshal struct {
+	Marshalers request.HandlerList
+}
+
+// MarshalPayload marshals the SDK shape into the io.Writer using the
+// Marshalers HandlerList provided. Returns an error if unable if marshal
+// fails.
+func (h HandlerPayloadMarshal) MarshalPayload(w io.Writer, v interface{}) error {
+	req := request.New(
+		aws.Config{},
+		metadata.ClientInfo{},
+		request.Handlers{},
+		nil,
+		&request.Operation{HTTPMethod: "GET"},
+		v,
+		nil,
+	)
+
+	h.Marshalers.Run(req)
+
+	if req.Error != nil {
+		return req.Error
+	}
+
+	io.Copy(w, req.GetBody())
+
+	return nil
+}

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

@@ -76,6 +76,7 @@ func newInputService1ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice1protocoltest",
+				ServiceID:     "InputService1ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -385,6 +386,7 @@ func newInputService2ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice2protocoltest",
+				ServiceID:     "InputService2ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -542,6 +544,7 @@ func newInputService3ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice3protocoltest",
+				ServiceID:     "InputService3ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -761,6 +764,7 @@ func newInputService4ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice4protocoltest",
+				ServiceID:     "InputService4ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -996,6 +1000,7 @@ func newInputService5ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice5protocoltest",
+				ServiceID:     "InputService5ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1141,6 +1146,7 @@ func newInputService6ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice6protocoltest",
+				ServiceID:     "InputService6ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1286,6 +1292,7 @@ func newInputService7ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice7protocoltest",
+				ServiceID:     "InputService7ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1439,6 +1446,7 @@ func newInputService8ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice8protocoltest",
+				ServiceID:     "InputService8ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1584,6 +1592,7 @@ func newInputService9ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice9protocoltest",
+				ServiceID:     "InputService9ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1729,6 +1738,7 @@ func newInputService10ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice10protocoltest",
+				ServiceID:     "InputService10ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1875,6 +1885,7 @@ func newInputService11ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice11protocoltest",
+				ServiceID:     "InputService11ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -2020,6 +2031,7 @@ func newInputService12ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice12protocoltest",
+				ServiceID:     "InputService12ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -2165,6 +2177,7 @@ func newInputService13ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice13protocoltest",
+				ServiceID:     "InputService13ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -2716,6 +2729,7 @@ func newInputService14ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice14protocoltest",
+				ServiceID:     "InputService14ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -2937,6 +2951,7 @@ func newInputService15ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice15protocoltest",
+				ServiceID:     "InputService15ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,

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

@@ -76,6 +76,7 @@ func newOutputService1ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice1protocoltest",
+				ServiceID:     "OutputService1ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -283,6 +284,7 @@ func newOutputService2ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice2protocoltest",
+				ServiceID:     "OutputService2ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -434,6 +436,7 @@ func newOutputService3ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice3protocoltest",
+				ServiceID:     "OutputService3ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -578,6 +581,7 @@ func newOutputService4ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice4protocoltest",
+				ServiceID:     "OutputService4ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -721,6 +725,7 @@ func newOutputService5ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice5protocoltest",
+				ServiceID:     "OutputService5ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -864,6 +869,7 @@ func newOutputService6ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice6protocoltest",
+				ServiceID:     "OutputService6ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1007,6 +1013,7 @@ func newOutputService7ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice7protocoltest",
+				ServiceID:     "OutputService7ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1150,6 +1157,7 @@ func newOutputService8ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice8protocoltest",
+				ServiceID:     "OutputService8ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1321,6 +1329,7 @@ func newOutputService9ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice9protocoltest",
+				ServiceID:     "OutputService9ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1492,6 +1501,7 @@ func newOutputService10ProtocolTestClient(cfg aws.Config, handlers request.Handl
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice10protocoltest",
+				ServiceID:     "OutputService10ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1635,6 +1645,7 @@ func newOutputService11ProtocolTestClient(cfg aws.Config, handlers request.Handl
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice11protocoltest",
+				ServiceID:     "OutputService11ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1790,6 +1801,7 @@ func newOutputService12ProtocolTestClient(cfg aws.Config, handlers request.Handl
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice12protocoltest",
+				ServiceID:     "OutputService12ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1933,6 +1945,7 @@ func newOutputService13ProtocolTestClient(cfg aws.Config, handlers request.Handl
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice13protocoltest",
+				ServiceID:     "OutputService13ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -2076,6 +2089,7 @@ func newOutputService14ProtocolTestClient(cfg aws.Config, handlers request.Handl
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice14protocoltest",
+				ServiceID:     "OutputService14ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -2219,6 +2233,7 @@ func newOutputService15ProtocolTestClient(cfg aws.Config, handlers request.Handl
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice15protocoltest",
+				ServiceID:     "OutputService15ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -2362,6 +2377,7 @@ func newOutputService16ProtocolTestClient(cfg aws.Config, handlers request.Handl
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice16protocoltest",
+				ServiceID:     "OutputService16ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -2534,7 +2550,7 @@ func TestOutputService1ProtocolTestScalarMembersCase1(t *testing.T) {
 	if e, a := "myname", *out.Str; e != a {
 		t.Errorf("expect %v, got %v", e, a)
 	}
-	if e, a := time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamp.String(); e != a {
+	if e, a := time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamp.UTC().String(); e != a {
 		t.Errorf("expect %v, got %v", e, a)
 	}
 	if e, a := true, *out.TrueBool; e != a {

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

@@ -20,8 +20,10 @@ import (
 	"github.com/aws/aws-sdk-go/private/protocol"
 )
 
-// RFC822 returns an RFC822 formatted timestamp for AWS protocols
-const RFC822 = "Mon, 2 Jan 2006 15:04:05 GMT"
+// RFC1123GMT is a RFC1123 (RFC822) formated timestame. This format is not
+// using the standard library's time.RFC1123 due to the desire to always use
+// GMT as the timezone.
+const RFC1123GMT = "Mon, 2 Jan 2006 15:04:05 GMT"
 
 // Whether the byte value can be sent without escaping in AWS URLs
 var noEscape [256]bool
@@ -270,7 +272,7 @@ func convertType(v reflect.Value, tag reflect.StructTag) (str string, err error)
 	case float64:
 		str = strconv.FormatFloat(value, 'f', -1, 64)
 	case time.Time:
-		str = value.UTC().Format(RFC822)
+		str = value.UTC().Format(RFC1123GMT)
 	case aws.JSONValue:
 		if len(value) == 0 {
 			return "", errValueNotSet

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

@@ -198,7 +198,7 @@ func unmarshalHeader(v reflect.Value, header string, tag reflect.StructTag) erro
 		}
 		v.Set(reflect.ValueOf(&f))
 	case *time.Time:
-		t, err := time.Parse(RFC822, header)
+		t, err := time.Parse(time.RFC1123, header)
 		if err != nil {
 			return err
 		}

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

@@ -76,6 +76,7 @@ func newInputService1ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice1protocoltest",
+				ServiceID:     "InputService1ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -214,6 +215,7 @@ func newInputService2ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice2protocoltest",
+				ServiceID:     "InputService2ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -360,6 +362,7 @@ func newInputService3ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice3protocoltest",
+				ServiceID:     "InputService3ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -506,6 +509,7 @@ func newInputService4ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice4protocoltest",
+				ServiceID:     "InputService4ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -652,6 +656,7 @@ func newInputService5ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice5protocoltest",
+				ServiceID:     "InputService5ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -806,6 +811,7 @@ func newInputService6ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice6protocoltest",
+				ServiceID:     "InputService6ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -960,6 +966,7 @@ func newInputService7ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice7protocoltest",
+				ServiceID:     "InputService7ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1181,6 +1188,7 @@ func newInputService8ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice8protocoltest",
+				ServiceID:     "InputService8ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1343,6 +1351,7 @@ func newInputService9ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice9protocoltest",
+				ServiceID:     "InputService9ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1533,6 +1542,7 @@ func newInputService10ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice10protocoltest",
+				ServiceID:     "InputService10ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1731,6 +1741,7 @@ func newInputService11ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice11protocoltest",
+				ServiceID:     "InputService11ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1907,6 +1918,7 @@ func newInputService12ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice12protocoltest",
+				ServiceID:     "InputService12ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -2076,6 +2088,7 @@ func newInputService13ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice13protocoltest",
+				ServiceID:     "InputService13ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -2297,6 +2310,7 @@ func newInputService14ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice14protocoltest",
+				ServiceID:     "InputService14ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -2530,6 +2544,7 @@ func newInputService15ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice15protocoltest",
+				ServiceID:     "InputService15ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -2751,6 +2766,7 @@ func newInputService16ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice16protocoltest",
+				ServiceID:     "InputService16ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -3308,6 +3324,7 @@ func newInputService17ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice17protocoltest",
+				ServiceID:     "InputService17ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -3537,6 +3554,7 @@ func newInputService18ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice18protocoltest",
+				ServiceID:     "InputService18ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -3683,6 +3701,7 @@ func newInputService19ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice19protocoltest",
+				ServiceID:     "InputService19ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -3829,6 +3848,7 @@ func newInputService20ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice20protocoltest",
+				ServiceID:     "InputService20ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -4050,6 +4070,7 @@ func newInputService21ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice21protocoltest",
+				ServiceID:     "InputService21ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -4382,6 +4403,7 @@ func newInputService22ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice22protocoltest",
+				ServiceID:     "InputService22ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,

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

@@ -76,6 +76,7 @@ func newOutputService1ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice1protocoltest",
+				ServiceID:     "OutputService1ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -299,6 +300,7 @@ func newOutputService2ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice2protocoltest",
+				ServiceID:     "OutputService2ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -464,6 +466,7 @@ func newOutputService3ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice3protocoltest",
+				ServiceID:     "OutputService3ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -627,6 +630,7 @@ func newOutputService4ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice4protocoltest",
+				ServiceID:     "OutputService4ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -770,6 +774,7 @@ func newOutputService5ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice5protocoltest",
+				ServiceID:     "OutputService5ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -925,6 +930,7 @@ func newOutputService6ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice6protocoltest",
+				ServiceID:     "OutputService6ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1068,6 +1074,7 @@ func newOutputService7ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice7protocoltest",
+				ServiceID:     "OutputService7ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1211,6 +1218,7 @@ func newOutputService8ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice8protocoltest",
+				ServiceID:     "OutputService8ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1354,6 +1362,7 @@ func newOutputService9ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice9protocoltest",
+				ServiceID:     "OutputService9ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1505,6 +1514,7 @@ func newOutputService10ProtocolTestClient(cfg aws.Config, handlers request.Handl
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice10protocoltest",
+				ServiceID:     "OutputService10ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1668,6 +1678,7 @@ func newOutputService11ProtocolTestClient(cfg aws.Config, handlers request.Handl
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice11protocoltest",
+				ServiceID:     "OutputService11ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1811,6 +1822,7 @@ func newOutputService12ProtocolTestClient(cfg aws.Config, handlers request.Handl
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice12protocoltest",
+				ServiceID:     "OutputService12ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -2114,6 +2126,7 @@ func newOutputService13ProtocolTestClient(cfg aws.Config, handlers request.Handl
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice13protocoltest",
+				ServiceID:     "OutputService13ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -2442,10 +2455,10 @@ func TestOutputService3ProtocolTestTimestampMembersCase1(t *testing.T) {
 	if out == nil {
 		t.Errorf("expect not to be nil")
 	}
-	if e, a := time.Unix(1.398796238e+09, 0).UTC().String(), out.StructMember.Foo.String(); e != a {
+	if e, a := time.Unix(1.398796238e+09, 0).UTC().String(), out.StructMember.Foo.UTC().String(); e != a {
 		t.Errorf("expect %v, got %v", e, a)
 	}
-	if e, a := time.Unix(1.398796238e+09, 0).UTC().String(), out.TimeMember.String(); e != a {
+	if e, a := time.Unix(1.398796238e+09, 0).UTC().String(), out.TimeMember.UTC().String(); e != a {
 		t.Errorf("expect %v, got %v", e, a)
 	}
 
@@ -2564,10 +2577,10 @@ func TestOutputService7ProtocolTestComplexMapValuesCase1(t *testing.T) {
 	if out == nil {
 		t.Errorf("expect not to be nil")
 	}
-	if e, a := time.Unix(1.398796238e+09, 0).UTC().String(), out.MapMember["a"].String(); e != a {
+	if e, a := time.Unix(1.398796238e+09, 0).UTC().String(), out.MapMember["a"].UTC().String(); e != a {
 		t.Errorf("expect %v, got %v", e, a)
 	}
-	if e, a := time.Unix(1.398796238e+09, 0).UTC().String(), out.MapMember["b"].String(); e != a {
+	if e, a := time.Unix(1.398796238e+09, 0).UTC().String(), out.MapMember["b"].UTC().String(); e != a {
 		t.Errorf("expect %v, got %v", e, a)
 	}
 

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

@@ -76,6 +76,7 @@ func newInputService1ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice1protocoltest",
+				ServiceID:     "InputService1ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -384,6 +385,7 @@ func newInputService2ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice2protocoltest",
+				ServiceID:     "InputService2ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -554,6 +556,7 @@ func newInputService3ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice3protocoltest",
+				ServiceID:     "InputService3ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -803,6 +806,7 @@ func newInputService4ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice4protocoltest",
+				ServiceID:     "InputService4ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -977,6 +981,7 @@ func newInputService5ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice5protocoltest",
+				ServiceID:     "InputService5ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1123,6 +1128,7 @@ func newInputService6ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice6protocoltest",
+				ServiceID:     "InputService6ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1269,6 +1275,7 @@ func newInputService7ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice7protocoltest",
+				ServiceID:     "InputService7ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1415,6 +1422,7 @@ func newInputService8ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice8protocoltest",
+				ServiceID:     "InputService8ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1561,6 +1569,7 @@ func newInputService9ProtocolTestClient(cfg aws.Config, handlers request.Handler
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice9protocoltest",
+				ServiceID:     "InputService9ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1719,6 +1728,7 @@ func newInputService10ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice10protocoltest",
+				ServiceID:     "InputService10ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1886,6 +1896,7 @@ func newInputService11ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice11protocoltest",
+				ServiceID:     "InputService11ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -2032,6 +2043,7 @@ func newInputService12ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice12protocoltest",
+				ServiceID:     "InputService12ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -2178,6 +2190,7 @@ func newInputService13ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice13protocoltest",
+				ServiceID:     "InputService13ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -2332,6 +2345,7 @@ func newInputService14ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice14protocoltest",
+				ServiceID:     "InputService14ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -2486,6 +2500,7 @@ func newInputService15ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice15protocoltest",
+				ServiceID:     "InputService15ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -2707,6 +2722,7 @@ func newInputService16ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice16protocoltest",
+				ServiceID:     "InputService16ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -2853,6 +2869,7 @@ func newInputService17ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice17protocoltest",
+				ServiceID:     "InputService17ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -3074,6 +3091,7 @@ func newInputService18ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice18protocoltest",
+				ServiceID:     "InputService18ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -3457,6 +3475,7 @@ func newInputService19ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice19protocoltest",
+				ServiceID:     "InputService19ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -3635,6 +3654,7 @@ func newInputService20ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice20protocoltest",
+				ServiceID:     "InputService20ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -3789,6 +3809,7 @@ func newInputService21ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice21protocoltest",
+				ServiceID:     "InputService21ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -4010,6 +4031,7 @@ func newInputService22ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice22protocoltest",
+				ServiceID:     "InputService22ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -4567,6 +4589,7 @@ func newInputService23ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice23protocoltest",
+				ServiceID:     "InputService23ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -4713,6 +4736,7 @@ func newInputService24ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice24protocoltest",
+				ServiceID:     "InputService24ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -4934,6 +4958,7 @@ func newInputService25ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "inputservice25protocoltest",
+				ServiceID:     "InputService25ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,

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

@@ -76,6 +76,7 @@ func newOutputService1ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice1protocoltest",
+				ServiceID:     "OutputService1ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -459,6 +460,7 @@ func newOutputService2ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice2protocoltest",
+				ServiceID:     "OutputService2ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -603,6 +605,7 @@ func newOutputService3ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice3protocoltest",
+				ServiceID:     "OutputService3ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -746,6 +749,7 @@ func newOutputService4ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice4protocoltest",
+				ServiceID:     "OutputService4ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -889,6 +893,7 @@ func newOutputService5ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice5protocoltest",
+				ServiceID:     "OutputService5ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1032,6 +1037,7 @@ func newOutputService6ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice6protocoltest",
+				ServiceID:     "OutputService6ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1187,6 +1193,7 @@ func newOutputService7ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice7protocoltest",
+				ServiceID:     "OutputService7ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1330,6 +1337,7 @@ func newOutputService8ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice8protocoltest",
+				ServiceID:     "OutputService8ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1473,6 +1481,7 @@ func newOutputService9ProtocolTestClient(cfg aws.Config, handlers request.Handle
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice9protocoltest",
+				ServiceID:     "OutputService9ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1636,6 +1645,7 @@ func newOutputService10ProtocolTestClient(cfg aws.Config, handlers request.Handl
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice10protocoltest",
+				ServiceID:     "OutputService10ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1779,6 +1789,7 @@ func newOutputService11ProtocolTestClient(cfg aws.Config, handlers request.Handl
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice11protocoltest",
+				ServiceID:     "OutputService11ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -1986,6 +1997,7 @@ func newOutputService12ProtocolTestClient(cfg aws.Config, handlers request.Handl
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice12protocoltest",
+				ServiceID:     "OutputService12ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -2129,6 +2141,7 @@ func newOutputService13ProtocolTestClient(cfg aws.Config, handlers request.Handl
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice13protocoltest",
+				ServiceID:     "OutputService13ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -2378,6 +2391,7 @@ func newOutputService14ProtocolTestClient(cfg aws.Config, handlers request.Handl
 			cfg,
 			metadata.ClientInfo{
 				ServiceName:   "outputservice14protocoltest",
+				ServiceID:     "OutputService14ProtocolTest",
 				SigningName:   signingName,
 				SigningRegion: signingRegion,
 				Endpoint:      endpoint,
@@ -2587,7 +2601,7 @@ func TestOutputService1ProtocolTestScalarMembersCase1(t *testing.T) {
 	if e, a := "myname", *out.Str; e != a {
 		t.Errorf("expect %v, got %v", e, a)
 	}
-	if e, a := time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamp.String(); e != a {
+	if e, a := time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamp.UTC().String(); e != a {
 		t.Errorf("expect %v, got %v", e, a)
 	}
 	if e, a := true, *out.TrueBool; e != a {
@@ -2645,7 +2659,7 @@ func TestOutputService1ProtocolTestScalarMembersCase2(t *testing.T) {
 	if e, a := "", *out.Str; e != a {
 		t.Errorf("expect %v, got %v", e, a)
 	}
-	if e, a := time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamp.String(); e != a {
+	if e, a := time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamp.UTC().String(); e != a {
 		t.Errorf("expect %v, got %v", e, a)
 	}
 	if e, a := true, *out.TrueBool; e != a {
@@ -2680,10 +2694,10 @@ func TestOutputService1ProtocolTestScalarMembersCase3(t *testing.T) {
 	if e, a := "value2", string(out.Blobs[1]); e != a {
 		t.Errorf("expect %v, got %v", e, a)
 	}
-	if e, a := time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamps[0].String(); e != a {
+	if e, a := time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamps[0].UTC().String(); e != a {
 		t.Errorf("expect %v, got %v", e, a)
 	}
-	if e, a := time.Unix(1.422172801e+09, 0).UTC().String(), out.Timestamps[1].String(); e != a {
+	if e, a := time.Unix(1.422172801e+09, 0).UTC().String(), out.Timestamps[1].UTC().String(); e != a {
 		t.Errorf("expect %v, got %v", e, a)
 	}
 
@@ -2995,7 +3009,7 @@ func TestOutputService11ProtocolTestScalarMembersInHeadersCase1(t *testing.T) {
 	if e, a := "string", *out.Str; e != a {
 		t.Errorf("expect %v, got %v", e, a)
 	}
-	if e, a := time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamp.String(); e != a {
+	if e, a := time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamp.UTC().String(); e != a {
 		t.Errorf("expect %v, got %v", e, a)
 	}
 	if e, a := true, *out.TrueBool; e != a {