TrueCloudLab/coredns
16
0
Fork 2
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity Actions

Dep ensure -update (#1912)

Browse source 
* dep ensure -update

Signed-off-by: Miek Gieben <miek@miek.nl>

* Add new files

Signed-off-by: Miek Gieben <miek@miek.nl>
This commit is contained in:
Miek Gieben 2018-06-30 17:07:33 +01:00 • committed by Yong Tang
parent 6fe27d99be
commit 9d555ab8d2
1505 changed files with 179032 additions and 208137 deletions
Download patch file Download diff file Expand all files Collapse all files

57
vendor/github.com/aws/aws-sdk-go/private/model/api/api.go generated vendored
View file

@ -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,30 +420,62 @@ 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{
"ServiceNameConstValue": ServiceName,
"ServiceNameValue": func(a *API) string {
if a.NoConstServiceNames {
return fmt.Sprintf("%q", a.Metadata.EndpointPrefix)
if !a.NoConstServiceNames {
return "ServiceName"
}
return "ServiceName"
return fmt.Sprintf("%q", ServiceName(a))
},
"EndpointsIDConstValue": func(a *API) string {
if a.NoConstServiceNames {
return fmt.Sprintf("%q", a.Metadata.EndpointPrefix)
return fmt.Sprintf("%q", a.Metadata.EndpointsID)
}
if a.Metadata.EndpointPrefix == a.Metadata.EndpointsID {
if a.Metadata.EndpointsID == ServiceName(a) {
return "ServiceName"
}
return fmt.Sprintf("%q", a.Metadata.EndpointsID)
},
"EndpointsIDValue": func(a *API) string {
if a.NoConstServiceNames {
return fmt.Sprintf("%q", a.Metadata.EndpointPrefix)
return fmt.Sprintf("%q", a.Metadata.EndpointsID)
}
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
@ -462,8 +498,9 @@ var initRequest func(*request.Request)
{{ if not .NoConstServiceNames -}}
// Service information constants
const (
ServiceName = "{{ .Metadata.EndpointPrefix }}" // Service endpoint prefix API calls made to.
EndpointsID = {{ EndpointsIDConstValue . }} // Service ID for Regions and Endpoints metadata.
ServiceName = "{{ ServiceNameConstValue . }}" // Name of service.
EndpointsID = {{ EndpointsIDConstValue . }} // ID to lookup a service endpoint with.
ServiceID = "{{ ServiceID . }}" // ServiceID is a unique identifer of a specific service.
)
{{- end }}
@ -504,6 +541,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 +566,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 {

533
vendor/github.com/aws/aws-sdk-go/private/model/api/eventstream.go generated vendored
View file

@ -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(`
`))

79
vendor/github.com/aws/aws-sdk-go/private/model/api/eventstream_test.go generated vendored
View file

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

2
vendor/github.com/aws/aws-sdk-go/private/model/api/load.go generated vendored
View file

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

26
vendor/github.com/aws/aws-sdk-go/private/model/api/operation.go generated vendored
View file

@ -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,17 @@ 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.Send.Swap(client.LogHTTPResponseHandler.Name, client.LogHTTPResponseHeaderHandler)
req.Handlers.Unmarshal.Swap({{ .API.ProtocolPackage }}.UnmarshalHandler.Name, rest.UnmarshalHandler)
req.Handlers.Unmarshal.PushBack(output.runEventStreamLoop)
{{ end -}}
return
}
@ -214,6 +223,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 +250,13 @@ 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/aws/client"] = true
o.API.imports["github.com/aws/aws-sdk-go/private/protocol/rest"] = true
}
err := tplOperation.Execute(&buf, o)
if err != nil {
panic(err)

9
vendor/github.com/aws/aws-sdk-go/private/model/api/pagination.go generated vendored
View file

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

1
vendor/github.com/aws/aws-sdk-go/private/model/api/passes.go generated vendored
View file

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

159
vendor/github.com/aws/aws-sdk-go/private/model/api/service_name.go generated vendored Normal file
View file

@ -0,0 +1,159 @@
// +build codegen
package api
// ServiceName returns the SDK's naming of the service. Has
// backwards compatability built in for services that were
// incorrectly named with the service's endpoint prefix.
func ServiceName(a *API) string {
if oldName, ok := oldServiceNames[a.PackageName()]; ok {
return oldName
}
return ServiceID(a)
}
var oldServiceNames = map[string]string{
"migrationhub": "mgh",
"acmpca": "acm-pca",
"acm": "acm",
"alexaforbusiness": "a4b",
"apigateway": "apigateway",
"applicationautoscaling": "autoscaling",
"appstream": "appstream2",
"appsync": "appsync",
"athena": "athena",
"autoscalingplans": "autoscaling",
"autoscaling": "autoscaling",
"batch": "batch",
"budgets": "budgets",
"costexplorer": "ce",
"cloud9": "cloud9",
"clouddirectory": "clouddirectory",
"cloudformation": "cloudformation",
"cloudfront": "cloudfront",
"cloudhsm": "cloudhsm",
"cloudhsmv2": "cloudhsmv2",
"cloudsearch": "cloudsearch",
"cloudsearchdomain": "cloudsearchdomain",
"cloudtrail": "cloudtrail",
"codebuild": "codebuild",
"codecommit": "codecommit",
"codedeploy": "codedeploy",
"codepipeline": "codepipeline",
"codestar": "codestar",
"cognitoidentity": "cognito-identity",
"cognitoidentityprovider": "cognito-idp",
"cognitosync": "cognito-sync",
"comprehend": "comprehend",
"configservice": "config",
"connect": "connect",
"costandusagereportservice": "cur",
"datapipeline": "datapipeline",
"dax": "dax",
"devicefarm": "devicefarm",
"directconnect": "directconnect",
"applicationdiscoveryservice": "discovery",
"databasemigrationservice": "dms",
"directoryservice": "ds",
"dynamodb": "dynamodb",
"ec2": "ec2",
"ecr": "ecr",
"ecs": "ecs",
"eks": "eks",
"elasticache": "elasticache",
"elasticbeanstalk": "elasticbeanstalk",
"efs": "elasticfilesystem",
"elb": "elasticloadbalancing",
"elbv2": "elasticloadbalancing",
"emr": "elasticmapreduce",
"elastictranscoder": "elastictranscoder",
"ses": "email",
"marketplaceentitlementservice": "entitlement.marketplace",
"elasticsearchservice": "es",
"cloudwatchevents": "events",
"firehose": "firehose",
"fms": "fms",
"gamelift": "gamelift",
"glacier": "glacier",
"glue": "glue",
"greengrass": "greengrass",
"guardduty": "guardduty",
"health": "health",
"iam": "iam",
"inspector": "inspector",
"iotdataplane": "data.iot",
"iotjobsdataplane": "data.jobs.iot",
"iot": "iot",
"iot1clickdevicesservice": "devices.iot1click",
"iot1clickprojects": "projects.iot1click",
"iotanalytics": "iotanalytics",
"kinesisvideoarchivedmedia": "kinesisvideo",
"kinesisvideomedia": "kinesisvideo",
"kinesis": "kinesis",
"kinesisanalytics": "kinesisanalytics",
"kinesisvideo": "kinesisvideo",
"kms": "kms",
"lambda": "lambda",
"lexmodelbuildingservice": "models.lex",
"lightsail": "lightsail",
"cloudwatchlogs": "logs",
"machinelearning": "machinelearning",
"marketplacecommerceanalytics": "marketplacecommerceanalytics",
"mediaconvert": "mediaconvert",
"medialive": "medialive",
"mediapackage": "mediapackage",
"mediastoredata": "data.mediastore",
"mediastore": "mediastore",
"mediatailor": "api.mediatailor",
"marketplacemetering": "metering.marketplace",
"mobile": "mobile",
"mobileanalytics": "mobileanalytics",
"cloudwatch": "monitoring",
"mq": "mq",
"mturk": "mturk-requester",
"neptune": "rds",
"opsworks": "opsworks",
"opsworkscm": "opsworks-cm",
"organizations": "organizations",
"pi": "pi",
"pinpoint": "pinpoint",
"polly": "polly",
"pricing": "api.pricing",
"rds": "rds",
"redshift": "redshift",
"rekognition": "rekognition",
"resourcegroups": "resource-groups",
"resourcegroupstaggingapi": "tagging",
"route53": "route53",
"route53domains": "route53domains",
"lexruntimeservice": "runtime.lex",
"sagemakerruntime": "runtime.sagemaker",
"s3": "s3",
"sagemaker": "sagemaker",
"simpledb": "sdb",
"secretsmanager": "secretsmanager",
"serverlessapplicationrepository": "serverlessrepo",
"servicecatalog": "servicecatalog",
"servicediscovery": "servicediscovery",
"shield": "shield",
"sms": "sms",
"snowball": "snowball",
"sns": "sns",
"sqs": "sqs",
"ssm": "ssm",
"sfn": "states",
"storagegateway": "storagegateway",
"dynamodbstreams": "streams.dynamodb",
"sts": "sts",
"support": "support",
"swf": "swf",
"transcribeservice": "transcribe",
"translate": "translate",
"wafregional": "waf-regional",
"waf": "waf",
"workdocs": "workdocs",
"workmail": "workmail",
"workspaces": "workspaces",
"xray": "xray",
}

171
vendor/github.com/aws/aws-sdk-go/private/model/api/shape.go generated vendored
View file

@ -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

30
vendor/github.com/aws/aws-sdk-go/private/protocol/ec2query/build_test.go generated vendored
View file

@ -75,7 +75,8 @@ func newInputService1ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice1protocoltest",
ServiceName: "InputService1ProtocolTest",
ServiceID: "InputService1ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -228,7 +229,8 @@ func newInputService2ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice2protocoltest",
ServiceName: "InputService2ProtocolTest",
ServiceID: "InputService2ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -389,7 +391,8 @@ func newInputService3ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice3protocoltest",
ServiceName: "InputService3ProtocolTest",
ServiceID: "InputService3ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -546,7 +549,8 @@ func newInputService4ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice4protocoltest",
ServiceName: "InputService4ProtocolTest",
ServiceID: "InputService4ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -715,7 +719,8 @@ func newInputService5ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice5protocoltest",
ServiceName: "InputService5ProtocolTest",
ServiceID: "InputService5ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -860,7 +865,8 @@ func newInputService6ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice6protocoltest",
ServiceName: "InputService6ProtocolTest",
ServiceID: "InputService6ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1005,7 +1011,8 @@ func newInputService7ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice7protocoltest",
ServiceName: "InputService7ProtocolTest",
ServiceID: "InputService7ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1151,7 +1158,8 @@ func newInputService8ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice8protocoltest",
ServiceName: "InputService8ProtocolTest",
ServiceID: "InputService8ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1296,7 +1304,8 @@ func newInputService9ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice9protocoltest",
ServiceName: "InputService9ProtocolTest",
ServiceID: "InputService9ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1515,7 +1524,8 @@ func newInputService10ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice10protocoltest",
ServiceName: "InputService10ProtocolTest",
ServiceID: "InputService10ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,

30
vendor/github.com/aws/aws-sdk-go/private/protocol/ec2query/unmarshal_test.go generated vendored
View file

@ -75,7 +75,8 @@ func newOutputService1ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice1protocoltest",
ServiceName: "OutputService1ProtocolTest",
ServiceID: "OutputService1ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -274,7 +275,8 @@ func newOutputService2ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice2protocoltest",
ServiceName: "OutputService2ProtocolTest",
ServiceID: "OutputService2ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -418,7 +420,8 @@ func newOutputService3ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice3protocoltest",
ServiceName: "OutputService3ProtocolTest",
ServiceID: "OutputService3ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -561,7 +564,8 @@ func newOutputService4ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice4protocoltest",
ServiceName: "OutputService4ProtocolTest",
ServiceID: "OutputService4ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -704,7 +708,8 @@ func newOutputService5ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice5protocoltest",
ServiceName: "OutputService5ProtocolTest",
ServiceID: "OutputService5ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -847,7 +852,8 @@ func newOutputService6ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice6protocoltest",
ServiceName: "OutputService6ProtocolTest",
ServiceID: "OutputService6ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1002,7 +1008,8 @@ func newOutputService7ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice7protocoltest",
ServiceName: "OutputService7ProtocolTest",
ServiceID: "OutputService7ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1145,7 +1152,8 @@ func newOutputService8ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice8protocoltest",
ServiceName: "OutputService8ProtocolTest",
ServiceID: "OutputService8ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1288,7 +1296,8 @@ func newOutputService9ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice9protocoltest",
ServiceName: "OutputService9ProtocolTest",
ServiceID: "OutputService9ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1431,7 +1440,8 @@ func newOutputService10ProtocolTestClient(cfg aws.Config, handlers request.Handl
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice10protocoltest",
ServiceName: "OutputService10ProtocolTest",
ServiceID: "OutputService10ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,

144
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/debug.go generated vendored Normal file
View file

@ -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))
}
}

199
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/decode.go generated vendored Normal file
View file

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

168
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/decode_test.go generated vendored Normal file
View file

@ -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)
}
}

114
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/encode.go generated vendored Normal file
View file

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

50
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/encode_test.go generated vendored Normal file
View file

@ -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)
}
}
}

23
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/error.go generated vendored Normal file
View file

@ -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"
}

160
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/api.go generated vendored Normal file
View file

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

197
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/api_test.go generated vendored Normal file
View file

@ -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)
}

24
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/error.go generated vendored Normal file
View file

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

116
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamtest/testing.go generated vendored Normal file
View file

@ -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),
}

166
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/header.go generated vendored Normal file
View file

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

66
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/header_test.go generated vendored Normal file
View file

@ -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)
}
}

501
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/header_value.go generated vendored Normal file
View file

@ -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)
}

203
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/header_value_test.go generated vendored Normal file
View file

@ -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)
}
}
}

103
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/message.go generated vendored Normal file
View file

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

152
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/shared_test.go generated vendored Normal file
View file

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

1
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/decoded/negative/corrupted_header_len generated vendored Normal file
View file

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

1
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/decoded/negative/corrupted_headers generated vendored Normal file
View file

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

1
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/decoded/negative/corrupted_length generated vendored Normal file
View file

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

1
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/decoded/negative/corrupted_payload generated vendored Normal file
View file

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

58
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/decoded/positive/all_headers generated vendored Normal file
View file

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

8
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/decoded/positive/empty_message generated vendored Normal file
View file

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

13
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/decoded/positive/int32_header generated vendored Normal file
View file

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

8
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/decoded/positive/payload_no_headers generated vendored Normal file
View file

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

13
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/decoded/positive/payload_one_str_header generated vendored Normal file
View file

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

BIN
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/encoded/negative/corrupted_header_len generated vendored Normal file
View file

Binary file not shown.

BIN
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/encoded/negative/corrupted_headers generated vendored Normal file
View file

Binary file not shown.

BIN
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/encoded/negative/corrupted_length generated vendored Normal file
View file

Binary file not shown.

BIN
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/encoded/negative/corrupted_payload generated vendored Normal file
View file

Binary file not shown.

BIN
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/encoded/positive/all_headers generated vendored Normal file
View file

Binary file not shown.

BIN
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/encoded/positive/empty_message generated vendored Normal file
View file

Binary file not shown.

BIN
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/encoded/positive/int32_header generated vendored Normal file
View file

Binary file not shown.

BIN
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/encoded/positive/payload_no_headers generated vendored Normal file
View file

Binary file not shown.

BIN
vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/testdata/encoded/positive/payload_one_str_header generated vendored Normal file
View file

Binary file not shown.

24
vendor/github.com/aws/aws-sdk-go/private/protocol/jsonrpc/build_test.go generated vendored
View file

@ -75,7 +75,8 @@ func newInputService1ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice1protocoltest",
ServiceName: "InputService1ProtocolTest",
ServiceID: "InputService1ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -223,7 +224,8 @@ func newInputService2ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice2protocoltest",
ServiceName: "InputService2ProtocolTest",
ServiceID: "InputService2ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -370,7 +372,8 @@ func newInputService3ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice3protocoltest",
ServiceName: "InputService3ProtocolTest",
ServiceID: "InputService3ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -600,7 +603,8 @@ func newInputService4ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice4protocoltest",
ServiceName: "InputService4ProtocolTest",
ServiceID: "InputService4ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -748,7 +752,8 @@ func newInputService5ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice5protocoltest",
ServiceName: "InputService5ProtocolTest",
ServiceID: "InputService5ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1301,7 +1306,8 @@ func newInputService6ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice6protocoltest",
ServiceName: "InputService6ProtocolTest",
ServiceID: "InputService6ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1449,7 +1455,8 @@ func newInputService7ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice7protocoltest",
ServiceName: "InputService7ProtocolTest",
ServiceID: "InputService7ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1670,7 +1677,8 @@ func newInputService8ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice8protocoltest",
ServiceName: "InputService8ProtocolTest",
ServiceID: "InputService8ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,

25
vendor/github.com/aws/aws-sdk-go/private/protocol/jsonrpc/unmarshal_test.go generated vendored
View file

@ -75,7 +75,8 @@ func newOutputService1ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice1protocoltest",
ServiceName: "OutputService1ProtocolTest",
ServiceID: "OutputService1ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -274,7 +275,8 @@ func newOutputService2ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice2protocoltest",
ServiceName: "OutputService2ProtocolTest",
ServiceID: "OutputService2ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -439,7 +441,8 @@ func newOutputService3ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice3protocoltest",
ServiceName: "OutputService3ProtocolTest",
ServiceID: "OutputService3ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -602,7 +605,8 @@ func newOutputService4ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice4protocoltest",
ServiceName: "OutputService4ProtocolTest",
ServiceID: "OutputService4ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -837,7 +841,8 @@ func newOutputService5ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice5protocoltest",
ServiceName: "OutputService5ProtocolTest",
ServiceID: "OutputService5ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -980,7 +985,8 @@ func newOutputService6ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice6protocoltest",
ServiceName: "OutputService6ProtocolTest",
ServiceID: "OutputService6ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1123,7 +1129,8 @@ func newOutputService7ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice7protocoltest",
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)
}

81
vendor/github.com/aws/aws-sdk-go/private/protocol/payload.go generated vendored Normal file
View file

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

45
vendor/github.com/aws/aws-sdk-go/private/protocol/query/build_test.go generated vendored
View file

@ -75,7 +75,8 @@ func newInputService1ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice1protocoltest",
ServiceName: "InputService1ProtocolTest",
ServiceID: "InputService1ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -384,7 +385,8 @@ func newInputService2ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice2protocoltest",
ServiceName: "InputService2ProtocolTest",
ServiceID: "InputService2ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -541,7 +543,8 @@ func newInputService3ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice3protocoltest",
ServiceName: "InputService3ProtocolTest",
ServiceID: "InputService3ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -760,7 +763,8 @@ func newInputService4ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice4protocoltest",
ServiceName: "InputService4ProtocolTest",
ServiceID: "InputService4ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -995,7 +999,8 @@ func newInputService5ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice5protocoltest",
ServiceName: "InputService5ProtocolTest",
ServiceID: "InputService5ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1140,7 +1145,8 @@ func newInputService6ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice6protocoltest",
ServiceName: "InputService6ProtocolTest",
ServiceID: "InputService6ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1285,7 +1291,8 @@ func newInputService7ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice7protocoltest",
ServiceName: "InputService7ProtocolTest",
ServiceID: "InputService7ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1438,7 +1445,8 @@ func newInputService8ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice8protocoltest",
ServiceName: "InputService8ProtocolTest",
ServiceID: "InputService8ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1583,7 +1591,8 @@ func newInputService9ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice9protocoltest",
ServiceName: "InputService9ProtocolTest",
ServiceID: "InputService9ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1728,7 +1737,8 @@ func newInputService10ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice10protocoltest",
ServiceName: "InputService10ProtocolTest",
ServiceID: "InputService10ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1874,7 +1884,8 @@ func newInputService11ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice11protocoltest",
ServiceName: "InputService11ProtocolTest",
ServiceID: "InputService11ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -2019,7 +2030,8 @@ func newInputService12ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice12protocoltest",
ServiceName: "InputService12ProtocolTest",
ServiceID: "InputService12ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -2164,7 +2176,8 @@ func newInputService13ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice13protocoltest",
ServiceName: "InputService13ProtocolTest",
ServiceID: "InputService13ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -2715,7 +2728,8 @@ func newInputService14ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice14protocoltest",
ServiceName: "InputService14ProtocolTest",
ServiceID: "InputService14ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -2936,7 +2950,8 @@ func newInputService15ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice15protocoltest",
ServiceName: "InputService15ProtocolTest",
ServiceID: "InputService15ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,

50
vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal_test.go generated vendored
View file

@ -75,7 +75,8 @@ func newOutputService1ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice1protocoltest",
ServiceName: "OutputService1ProtocolTest",
ServiceID: "OutputService1ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -282,7 +283,8 @@ func newOutputService2ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice2protocoltest",
ServiceName: "OutputService2ProtocolTest",
ServiceID: "OutputService2ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -433,7 +435,8 @@ func newOutputService3ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice3protocoltest",
ServiceName: "OutputService3ProtocolTest",
ServiceID: "OutputService3ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -577,7 +580,8 @@ func newOutputService4ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice4protocoltest",
ServiceName: "OutputService4ProtocolTest",
ServiceID: "OutputService4ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -720,7 +724,8 @@ func newOutputService5ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice5protocoltest",
ServiceName: "OutputService5ProtocolTest",
ServiceID: "OutputService5ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -863,7 +868,8 @@ func newOutputService6ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice6protocoltest",
ServiceName: "OutputService6ProtocolTest",
ServiceID: "OutputService6ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1006,7 +1012,8 @@ func newOutputService7ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice7protocoltest",
ServiceName: "OutputService7ProtocolTest",
ServiceID: "OutputService7ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1149,7 +1156,8 @@ func newOutputService8ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice8protocoltest",
ServiceName: "OutputService8ProtocolTest",
ServiceID: "OutputService8ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1320,7 +1328,8 @@ func newOutputService9ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice9protocoltest",
ServiceName: "OutputService9ProtocolTest",
ServiceID: "OutputService9ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1491,7 +1500,8 @@ func newOutputService10ProtocolTestClient(cfg aws.Config, handlers request.Handl
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice10protocoltest",
ServiceName: "OutputService10ProtocolTest",
ServiceID: "OutputService10ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1634,7 +1644,8 @@ func newOutputService11ProtocolTestClient(cfg aws.Config, handlers request.Handl
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice11protocoltest",
ServiceName: "OutputService11ProtocolTest",
ServiceID: "OutputService11ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1789,7 +1800,8 @@ func newOutputService12ProtocolTestClient(cfg aws.Config, handlers request.Handl
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice12protocoltest",
ServiceName: "OutputService12ProtocolTest",
ServiceID: "OutputService12ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1932,7 +1944,8 @@ func newOutputService13ProtocolTestClient(cfg aws.Config, handlers request.Handl
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice13protocoltest",
ServiceName: "OutputService13ProtocolTest",
ServiceID: "OutputService13ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -2075,7 +2088,8 @@ func newOutputService14ProtocolTestClient(cfg aws.Config, handlers request.Handl
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice14protocoltest",
ServiceName: "OutputService14ProtocolTest",
ServiceID: "OutputService14ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -2218,7 +2232,8 @@ func newOutputService15ProtocolTestClient(cfg aws.Config, handlers request.Handl
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice15protocoltest",
ServiceName: "OutputService15ProtocolTest",
ServiceID: "OutputService15ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -2361,7 +2376,8 @@ func newOutputService16ProtocolTestClient(cfg aws.Config, handlers request.Handl
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice16protocoltest",
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 {

8
vendor/github.com/aws/aws-sdk-go/private/protocol/rest/build.go generated vendored
View file

@ -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

2
vendor/github.com/aws/aws-sdk-go/private/protocol/rest/unmarshal.go generated vendored
View file

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

66
vendor/github.com/aws/aws-sdk-go/private/protocol/restjson/build_test.go generated vendored
View file

@ -75,7 +75,8 @@ func newInputService1ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice1protocoltest",
ServiceName: "InputService1ProtocolTest",
ServiceID: "InputService1ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -213,7 +214,8 @@ func newInputService2ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice2protocoltest",
ServiceName: "InputService2ProtocolTest",
ServiceID: "InputService2ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -359,7 +361,8 @@ func newInputService3ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice3protocoltest",
ServiceName: "InputService3ProtocolTest",
ServiceID: "InputService3ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -505,7 +508,8 @@ func newInputService4ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice4protocoltest",
ServiceName: "InputService4ProtocolTest",
ServiceID: "InputService4ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -651,7 +655,8 @@ func newInputService5ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice5protocoltest",
ServiceName: "InputService5ProtocolTest",
ServiceID: "InputService5ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -805,7 +810,8 @@ func newInputService6ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice6protocoltest",
ServiceName: "InputService6ProtocolTest",
ServiceID: "InputService6ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -959,7 +965,8 @@ func newInputService7ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice7protocoltest",
ServiceName: "InputService7ProtocolTest",
ServiceID: "InputService7ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1180,7 +1187,8 @@ func newInputService8ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice8protocoltest",
ServiceName: "InputService8ProtocolTest",
ServiceID: "InputService8ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1342,7 +1350,8 @@ func newInputService9ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice9protocoltest",
ServiceName: "InputService9ProtocolTest",
ServiceID: "InputService9ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1532,7 +1541,8 @@ func newInputService10ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice10protocoltest",
ServiceName: "InputService10ProtocolTest",
ServiceID: "InputService10ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1730,7 +1740,8 @@ func newInputService11ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice11protocoltest",
ServiceName: "InputService11ProtocolTest",
ServiceID: "InputService11ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1906,7 +1917,8 @@ func newInputService12ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice12protocoltest",
ServiceName: "InputService12ProtocolTest",
ServiceID: "InputService12ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -2075,7 +2087,8 @@ func newInputService13ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice13protocoltest",
ServiceName: "InputService13ProtocolTest",
ServiceID: "InputService13ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -2296,7 +2309,8 @@ func newInputService14ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice14protocoltest",
ServiceName: "InputService14ProtocolTest",
ServiceID: "InputService14ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -2529,7 +2543,8 @@ func newInputService15ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice15protocoltest",
ServiceName: "InputService15ProtocolTest",
ServiceID: "InputService15ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -2750,7 +2765,8 @@ func newInputService16ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice16protocoltest",
ServiceName: "InputService16ProtocolTest",
ServiceID: "InputService16ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -3307,7 +3323,8 @@ func newInputService17ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice17protocoltest",
ServiceName: "InputService17ProtocolTest",
ServiceID: "InputService17ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -3536,7 +3553,8 @@ func newInputService18ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice18protocoltest",
ServiceName: "InputService18ProtocolTest",
ServiceID: "InputService18ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -3682,7 +3700,8 @@ func newInputService19ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice19protocoltest",
ServiceName: "InputService19ProtocolTest",
ServiceID: "InputService19ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -3828,7 +3847,8 @@ func newInputService20ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice20protocoltest",
ServiceName: "InputService20ProtocolTest",
ServiceID: "InputService20ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -4049,7 +4069,8 @@ func newInputService21ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice21protocoltest",
ServiceName: "InputService21ProtocolTest",
ServiceID: "InputService21ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -4381,7 +4402,8 @@ func newInputService22ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice22protocoltest",
ServiceName: "InputService22ProtocolTest",
ServiceID: "InputService22ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,

47
vendor/github.com/aws/aws-sdk-go/private/protocol/restjson/unmarshal_test.go generated vendored
View file

@ -75,7 +75,8 @@ func newOutputService1ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice1protocoltest",
ServiceName: "OutputService1ProtocolTest",
ServiceID: "OutputService1ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -298,7 +299,8 @@ func newOutputService2ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice2protocoltest",
ServiceName: "OutputService2ProtocolTest",
ServiceID: "OutputService2ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -463,7 +465,8 @@ func newOutputService3ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice3protocoltest",
ServiceName: "OutputService3ProtocolTest",
ServiceID: "OutputService3ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -626,7 +629,8 @@ func newOutputService4ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice4protocoltest",
ServiceName: "OutputService4ProtocolTest",
ServiceID: "OutputService4ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -769,7 +773,8 @@ func newOutputService5ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice5protocoltest",
ServiceName: "OutputService5ProtocolTest",
ServiceID: "OutputService5ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -924,7 +929,8 @@ func newOutputService6ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice6protocoltest",
ServiceName: "OutputService6ProtocolTest",
ServiceID: "OutputService6ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1067,7 +1073,8 @@ func newOutputService7ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice7protocoltest",
ServiceName: "OutputService7ProtocolTest",
ServiceID: "OutputService7ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1210,7 +1217,8 @@ func newOutputService8ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice8protocoltest",
ServiceName: "OutputService8ProtocolTest",
ServiceID: "OutputService8ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1353,7 +1361,8 @@ func newOutputService9ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice9protocoltest",
ServiceName: "OutputService9ProtocolTest",
ServiceID: "OutputService9ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1504,7 +1513,8 @@ func newOutputService10ProtocolTestClient(cfg aws.Config, handlers request.Handl
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice10protocoltest",
ServiceName: "OutputService10ProtocolTest",
ServiceID: "OutputService10ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1667,7 +1677,8 @@ func newOutputService11ProtocolTestClient(cfg aws.Config, handlers request.Handl
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice11protocoltest",
ServiceName: "OutputService11ProtocolTest",
ServiceID: "OutputService11ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1810,7 +1821,8 @@ func newOutputService12ProtocolTestClient(cfg aws.Config, handlers request.Handl
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice12protocoltest",
ServiceName: "OutputService12ProtocolTest",
ServiceID: "OutputService12ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -2113,7 +2125,8 @@ func newOutputService13ProtocolTestClient(cfg aws.Config, handlers request.Handl
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice13protocoltest",
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)
}

75
vendor/github.com/aws/aws-sdk-go/private/protocol/restxml/build_test.go generated vendored
View file

@ -75,7 +75,8 @@ func newInputService1ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice1protocoltest",
ServiceName: "InputService1ProtocolTest",
ServiceID: "InputService1ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -383,7 +384,8 @@ func newInputService2ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice2protocoltest",
ServiceName: "InputService2ProtocolTest",
ServiceID: "InputService2ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -553,7 +555,8 @@ func newInputService3ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice3protocoltest",
ServiceName: "InputService3ProtocolTest",
ServiceID: "InputService3ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -802,7 +805,8 @@ func newInputService4ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice4protocoltest",
ServiceName: "InputService4ProtocolTest",
ServiceID: "InputService4ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -976,7 +980,8 @@ func newInputService5ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice5protocoltest",
ServiceName: "InputService5ProtocolTest",
ServiceID: "InputService5ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1122,7 +1127,8 @@ func newInputService6ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice6protocoltest",
ServiceName: "InputService6ProtocolTest",
ServiceID: "InputService6ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1268,7 +1274,8 @@ func newInputService7ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice7protocoltest",
ServiceName: "InputService7ProtocolTest",
ServiceID: "InputService7ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1414,7 +1421,8 @@ func newInputService8ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice8protocoltest",
ServiceName: "InputService8ProtocolTest",
ServiceID: "InputService8ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1560,7 +1568,8 @@ func newInputService9ProtocolTestClient(cfg aws.Config, handlers request.Handler
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice9protocoltest",
ServiceName: "InputService9ProtocolTest",
ServiceID: "InputService9ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1718,7 +1727,8 @@ func newInputService10ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice10protocoltest",
ServiceName: "InputService10ProtocolTest",
ServiceID: "InputService10ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1885,7 +1895,8 @@ func newInputService11ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice11protocoltest",
ServiceName: "InputService11ProtocolTest",
ServiceID: "InputService11ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -2031,7 +2042,8 @@ func newInputService12ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice12protocoltest",
ServiceName: "InputService12ProtocolTest",
ServiceID: "InputService12ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -2177,7 +2189,8 @@ func newInputService13ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice13protocoltest",
ServiceName: "InputService13ProtocolTest",
ServiceID: "InputService13ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -2331,7 +2344,8 @@ func newInputService14ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice14protocoltest",
ServiceName: "InputService14ProtocolTest",
ServiceID: "InputService14ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -2485,7 +2499,8 @@ func newInputService15ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice15protocoltest",
ServiceName: "InputService15ProtocolTest",
ServiceID: "InputService15ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -2706,7 +2721,8 @@ func newInputService16ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice16protocoltest",
ServiceName: "InputService16ProtocolTest",
ServiceID: "InputService16ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -2852,7 +2868,8 @@ func newInputService17ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice17protocoltest",
ServiceName: "InputService17ProtocolTest",
ServiceID: "InputService17ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -3073,7 +3090,8 @@ func newInputService18ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice18protocoltest",
ServiceName: "InputService18ProtocolTest",
ServiceID: "InputService18ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -3456,7 +3474,8 @@ func newInputService19ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice19protocoltest",
ServiceName: "InputService19ProtocolTest",
ServiceID: "InputService19ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -3634,7 +3653,8 @@ func newInputService20ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice20protocoltest",
ServiceName: "InputService20ProtocolTest",
ServiceID: "InputService20ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -3788,7 +3808,8 @@ func newInputService21ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice21protocoltest",
ServiceName: "InputService21ProtocolTest",
ServiceID: "InputService21ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -4009,7 +4030,8 @@ func newInputService22ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice22protocoltest",
ServiceName: "InputService22ProtocolTest",
ServiceID: "InputService22ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -4566,7 +4588,8 @@ func newInputService23ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice23protocoltest",
ServiceName: "InputService23ProtocolTest",
ServiceID: "InputService23ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -4712,7 +4735,8 @@ func newInputService24ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice24protocoltest",
ServiceName: "InputService24ProtocolTest",
ServiceID: "InputService24ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -4933,7 +4957,8 @@ func newInputService25ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "inputservice25protocoltest",
ServiceName: "InputService25ProtocolTest",
ServiceID: "InputService25ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,

52
vendor/github.com/aws/aws-sdk-go/private/protocol/restxml/unmarshal_test.go generated vendored
View file

@ -75,7 +75,8 @@ func newOutputService1ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice1protocoltest",
ServiceName: "OutputService1ProtocolTest",
ServiceID: "OutputService1ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -458,7 +459,8 @@ func newOutputService2ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice2protocoltest",
ServiceName: "OutputService2ProtocolTest",
ServiceID: "OutputService2ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -602,7 +604,8 @@ func newOutputService3ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice3protocoltest",
ServiceName: "OutputService3ProtocolTest",
ServiceID: "OutputService3ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -745,7 +748,8 @@ func newOutputService4ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice4protocoltest",
ServiceName: "OutputService4ProtocolTest",
ServiceID: "OutputService4ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -888,7 +892,8 @@ func newOutputService5ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice5protocoltest",
ServiceName: "OutputService5ProtocolTest",
ServiceID: "OutputService5ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1031,7 +1036,8 @@ func newOutputService6ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice6protocoltest",
ServiceName: "OutputService6ProtocolTest",
ServiceID: "OutputService6ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1186,7 +1192,8 @@ func newOutputService7ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice7protocoltest",
ServiceName: "OutputService7ProtocolTest",
ServiceID: "OutputService7ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1329,7 +1336,8 @@ func newOutputService8ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice8protocoltest",
ServiceName: "OutputService8ProtocolTest",
ServiceID: "OutputService8ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1472,7 +1480,8 @@ func newOutputService9ProtocolTestClient(cfg aws.Config, handlers request.Handle
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice9protocoltest",
ServiceName: "OutputService9ProtocolTest",
ServiceID: "OutputService9ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1635,7 +1644,8 @@ func newOutputService10ProtocolTestClient(cfg aws.Config, handlers request.Handl
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice10protocoltest",
ServiceName: "OutputService10ProtocolTest",
ServiceID: "OutputService10ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1778,7 +1788,8 @@ func newOutputService11ProtocolTestClient(cfg aws.Config, handlers request.Handl
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice11protocoltest",
ServiceName: "OutputService11ProtocolTest",
ServiceID: "OutputService11ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -1985,7 +1996,8 @@ func newOutputService12ProtocolTestClient(cfg aws.Config, handlers request.Handl
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice12protocoltest",
ServiceName: "OutputService12ProtocolTest",
ServiceID: "OutputService12ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -2128,7 +2140,8 @@ func newOutputService13ProtocolTestClient(cfg aws.Config, handlers request.Handl
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice13protocoltest",
ServiceName: "OutputService13ProtocolTest",
ServiceID: "OutputService13ProtocolTest",
SigningName: signingName,
SigningRegion: signingRegion,
Endpoint: endpoint,
@ -2377,7 +2390,8 @@ func newOutputService14ProtocolTestClient(cfg aws.Config, handlers request.Handl
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: "outputservice14protocoltest",
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 {