vendor: update all dependencies

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
+}