9 files changed, 628 insertions, 56 deletions

diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/json/jsonutil/build.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/json/jsonutil/build.go
new file mode 100644
index 0000000..864fb67
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/json/jsonutil/build.go
@@ -0,0 +1,296 @@
+// Package jsonutil provides JSON serialization of AWS requests and responses.
+package jsonutil
+
+import (
+        "bytes"
+        "encoding/base64"
+        "encoding/json"
+        "fmt"
+        "math"
+        "reflect"
+        "sort"
+        "strconv"
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/private/protocol"
+)
+
+var timeType = reflect.ValueOf(time.Time{}).Type()
+var byteSliceType = reflect.ValueOf([]byte{}).Type()
+
+// BuildJSON builds a JSON string for a given object v.
+func BuildJSON(v interface{}) ([]byte, error) {
+        var buf bytes.Buffer
+
+        err := buildAny(reflect.ValueOf(v), &buf, "")
+        return buf.Bytes(), err
+}
+
+func buildAny(value reflect.Value, buf *bytes.Buffer, tag reflect.StructTag) error {
+        origVal := value
+        value = reflect.Indirect(value)
+        if !value.IsValid() {
+                return nil
+        }
+
+        vtype := value.Type()
+
+        t := tag.Get("type")
+        if t == "" {
+                switch vtype.Kind() {
+                case reflect.Struct:
+                        // also it can't be a time object
+                        if value.Type() != timeType {
+                                t = "structure"
+                        }
+                case reflect.Slice:
+                        // also it can't be a byte slice
+                        if _, ok := value.Interface().([]byte); !ok {
+                                t = "list"
+                        }
+                case reflect.Map:
+                        // cannot be a JSONValue map
+                        if _, ok := value.Interface().(aws.JSONValue); !ok {
+                                t = "map"
+                        }
+                }
+        }
+
+        switch t {
+        case "structure":
+                if field, ok := vtype.FieldByName("_"); ok {
+                        tag = field.Tag
+                }
+                return buildStruct(value, buf, tag)
+        case "list":
+                return buildList(value, buf, tag)
+        case "map":
+                return buildMap(value, buf, tag)
+        default:
+                return buildScalar(origVal, buf, tag)
+        }
+}
+
+func buildStruct(value reflect.Value, buf *bytes.Buffer, tag reflect.StructTag) error {
+        if !value.IsValid() {
+                return nil
+        }
+
+        // unwrap payloads
+        if payload := tag.Get("payload"); payload != "" {
+                field, _ := value.Type().FieldByName(payload)
+                tag = field.Tag
+                value = elemOf(value.FieldByName(payload))
+
+                if !value.IsValid() {
+                        return nil
+                }
+        }
+
+        buf.WriteByte('{')
+
+        t := value.Type()
+        first := true
+        for i := 0; i < t.NumField(); i++ {
+                member := value.Field(i)
+
+                // This allocates the most memory.
+                // Additionally, we cannot skip nil fields due to
+                // idempotency auto filling.
+                field := t.Field(i)
+
+                if field.PkgPath != "" {
+                        continue // ignore unexported fields
+                }
+                if field.Tag.Get("json") == "-" {
+                        continue
+                }
+                if field.Tag.Get("location") != "" {
+                        continue // ignore non-body elements
+                }
+                if field.Tag.Get("ignore") != "" {
+                        continue
+                }
+
+                if protocol.CanSetIdempotencyToken(member, field) {
+                        token := protocol.GetIdempotencyToken()
+                        member = reflect.ValueOf(&token)
+                }
+
+                if (member.Kind() == reflect.Ptr || member.Kind() == reflect.Slice || member.Kind() == reflect.Map) && member.IsNil() {
+                        continue // ignore unset fields
+                }
+
+                if first {
+                        first = false
+                } else {
+                        buf.WriteByte(',')
+                }
+
+                // figure out what this field is called
+                name := field.Name
+                if locName := field.Tag.Get("locationName"); locName != "" {
+                        name = locName
+                }
+
+                writeString(name, buf)
+                buf.WriteString(`:`)
+
+                err := buildAny(member, buf, field.Tag)
+                if err != nil {
+                        return err
+                }
+
+        }
+
+        buf.WriteString("}")
+
+        return nil
+}
+
+func buildList(value reflect.Value, buf *bytes.Buffer, tag reflect.StructTag) error {
+        buf.WriteString("[")
+
+        for i := 0; i < value.Len(); i++ {
+                buildAny(value.Index(i), buf, "")
+
+                if i < value.Len()-1 {
+                        buf.WriteString(",")
+                }
+        }
+
+        buf.WriteString("]")
+
+        return nil
+}
+
+type sortedValues []reflect.Value
+
+func (sv sortedValues) Len() int           { return len(sv) }
+func (sv sortedValues) Swap(i, j int)      { sv[i], sv[j] = sv[j], sv[i] }
+func (sv sortedValues) Less(i, j int) bool { return sv[i].String() < sv[j].String() }
+
+func buildMap(value reflect.Value, buf *bytes.Buffer, tag reflect.StructTag) error {
+        buf.WriteString("{")
+
+        sv := sortedValues(value.MapKeys())
+        sort.Sort(sv)
+
+        for i, k := range sv {
+                if i > 0 {
+                        buf.WriteByte(',')
+                }
+
+                writeString(k.String(), buf)
+                buf.WriteString(`:`)
+
+                buildAny(value.MapIndex(k), buf, "")
+        }
+
+        buf.WriteString("}")
+
+        return nil
+}
+
+func buildScalar(v reflect.Value, buf *bytes.Buffer, tag reflect.StructTag) error {
+        // prevents allocation on the heap.
+        scratch := [64]byte{}
+        switch value := reflect.Indirect(v); value.Kind() {
+        case reflect.String:
+                writeString(value.String(), buf)
+        case reflect.Bool:
+                if value.Bool() {
+                        buf.WriteString("true")
+                } else {
+                        buf.WriteString("false")
+                }
+        case reflect.Int64:
+                buf.Write(strconv.AppendInt(scratch[:0], value.Int(), 10))
+        case reflect.Float64:
+                f := value.Float()
+                if math.IsInf(f, 0) || math.IsNaN(f) {
+                        return &json.UnsupportedValueError{Value: v, Str: strconv.FormatFloat(f, 'f', -1, 64)}
+                }
+                buf.Write(strconv.AppendFloat(scratch[:0], f, 'f', -1, 64))
+        default:
+                switch converted := value.Interface().(type) {
+                case time.Time:
+                        format := tag.Get("timestampFormat")
+                        if len(format) == 0 {
+                                format = protocol.UnixTimeFormatName
+                        }
+
+                        ts := protocol.FormatTime(format, converted)
+                        if format != protocol.UnixTimeFormatName {
+                                ts = `"` + ts + `"`
+                        }
+
+                        buf.WriteString(ts)
+                case []byte:
+                        if !value.IsNil() {
+                                buf.WriteByte('"')
+                                if len(converted) < 1024 {
+                                        // for small buffers, using Encode directly is much faster.
+                                        dst := make([]byte, base64.StdEncoding.EncodedLen(len(converted)))
+                                        base64.StdEncoding.Encode(dst, converted)
+                                        buf.Write(dst)
+                                } else {
+                                        // for large buffers, avoid unnecessary extra temporary
+                                        // buffer space.
+                                        enc := base64.NewEncoder(base64.StdEncoding, buf)
+                                        enc.Write(converted)
+                                        enc.Close()
+                                }
+                                buf.WriteByte('"')
+                        }
+                case aws.JSONValue:
+                        str, err := protocol.EncodeJSONValue(converted, protocol.QuotedEscape)
+                        if err != nil {
+                                return fmt.Errorf("unable to encode JSONValue, %v", err)
+                        }
+                        buf.WriteString(str)
+                default:
+                        return fmt.Errorf("unsupported JSON value %v (%s)", value.Interface(), value.Type())
+                }
+        }
+        return nil
+}
+
+var hex = "0123456789abcdef"
+
+func writeString(s string, buf *bytes.Buffer) {
+        buf.WriteByte('"')
+        for i := 0; i < len(s); i++ {
+                if s[i] == '"' {
+                        buf.WriteString(`\"`)
+                } else if s[i] == '\\' {
+                        buf.WriteString(`\\`)
+                } else if s[i] == '\b' {
+                        buf.WriteString(`\b`)
+                } else if s[i] == '\f' {
+                        buf.WriteString(`\f`)
+                } else if s[i] == '\r' {
+                        buf.WriteString(`\r`)
+                } else if s[i] == '\t' {
+                        buf.WriteString(`\t`)
+                } else if s[i] == '\n' {
+                        buf.WriteString(`\n`)
+                } else if s[i] < 32 {
+                        buf.WriteString("\\u00")
+                        buf.WriteByte(hex[s[i]>>4])
+                        buf.WriteByte(hex[s[i]&0xF])
+                } else {
+                        buf.WriteByte(s[i])
+                }
+        }
+        buf.WriteByte('"')
+}
+
+// Returns the reflection element of a value, if it is a pointer.
+func elemOf(value reflect.Value) reflect.Value {
+        for value.Kind() == reflect.Ptr {
+                value = value.Elem()
+        }
+        return value
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/json/jsonutil/unmarshal.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/json/jsonutil/unmarshal.go
new file mode 100644
index 0000000..ea0da79
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/json/jsonutil/unmarshal.go
@@ -0,0 +1,250 @@
+package jsonutil
+
+import (
+        "bytes"
+        "encoding/base64"
+        "encoding/json"
+        "fmt"
+        "io"
+        "reflect"
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/private/protocol"
+)
+
+// UnmarshalJSONError unmarshal's the reader's JSON document into the passed in
+// type. The value to unmarshal the json document into must be a pointer to the
+// type.
+func UnmarshalJSONError(v interface{}, stream io.Reader) error {
+        var errBuf bytes.Buffer
+        body := io.TeeReader(stream, &errBuf)
+
+        err := json.NewDecoder(body).Decode(v)
+        if err != nil {
+                msg := "failed decoding error message"
+                if err == io.EOF {
+                        msg = "error message missing"
+                        err = nil
+                }
+                return awserr.NewUnmarshalError(err, msg, errBuf.Bytes())
+        }
+
+        return nil
+}
+
+// UnmarshalJSON reads a stream and unmarshals the results in object v.
+func UnmarshalJSON(v interface{}, stream io.Reader) error {
+        var out interface{}
+
+        err := json.NewDecoder(stream).Decode(&out)
+        if err == io.EOF {
+                return nil
+        } else if err != nil {
+                return err
+        }
+
+        return unmarshalAny(reflect.ValueOf(v), out, "")
+}
+
+func unmarshalAny(value reflect.Value, data interface{}, tag reflect.StructTag) error {
+        vtype := value.Type()
+        if vtype.Kind() == reflect.Ptr {
+                vtype = vtype.Elem() // check kind of actual element type
+        }
+
+        t := tag.Get("type")
+        if t == "" {
+                switch vtype.Kind() {
+                case reflect.Struct:
+                        // also it can't be a time object
+                        if _, ok := value.Interface().(*time.Time); !ok {
+                                t = "structure"
+                        }
+                case reflect.Slice:
+                        // also it can't be a byte slice
+                        if _, ok := value.Interface().([]byte); !ok {
+                                t = "list"
+                        }
+                case reflect.Map:
+                        // cannot be a JSONValue map
+                        if _, ok := value.Interface().(aws.JSONValue); !ok {
+                                t = "map"
+                        }
+                }
+        }
+
+        switch t {
+        case "structure":
+                if field, ok := vtype.FieldByName("_"); ok {
+                        tag = field.Tag
+                }
+                return unmarshalStruct(value, data, tag)
+        case "list":
+                return unmarshalList(value, data, tag)
+        case "map":
+                return unmarshalMap(value, data, tag)
+        default:
+                return unmarshalScalar(value, data, tag)
+        }
+}
+
+func unmarshalStruct(value reflect.Value, data interface{}, tag reflect.StructTag) error {
+        if data == nil {
+                return nil
+        }
+        mapData, ok := data.(map[string]interface{})
+        if !ok {
+                return fmt.Errorf("JSON value is not a structure (%#v)", data)
+        }
+
+        t := value.Type()
+        if value.Kind() == reflect.Ptr {
+                if value.IsNil() { // create the structure if it's nil
+                        s := reflect.New(value.Type().Elem())
+                        value.Set(s)
+                        value = s
+                }
+
+                value = value.Elem()
+                t = t.Elem()
+        }
+
+        // unwrap any payloads
+        if payload := tag.Get("payload"); payload != "" {
+                field, _ := t.FieldByName(payload)
+                return unmarshalAny(value.FieldByName(payload), data, field.Tag)
+        }
+
+        for i := 0; i < t.NumField(); i++ {
+                field := t.Field(i)
+                if field.PkgPath != "" {
+                        continue // ignore unexported fields
+                }
+
+                // figure out what this field is called
+                name := field.Name
+                if locName := field.Tag.Get("locationName"); locName != "" {
+                        name = locName
+                }
+
+                member := value.FieldByIndex(field.Index)
+                err := unmarshalAny(member, mapData[name], field.Tag)
+                if err != nil {
+                        return err
+                }
+        }
+        return nil
+}
+
+func unmarshalList(value reflect.Value, data interface{}, tag reflect.StructTag) error {
+        if data == nil {
+                return nil
+        }
+        listData, ok := data.([]interface{})
+        if !ok {
+                return fmt.Errorf("JSON value is not a list (%#v)", data)
+        }
+
+        if value.IsNil() {
+                l := len(listData)
+                value.Set(reflect.MakeSlice(value.Type(), l, l))
+        }
+
+        for i, c := range listData {
+                err := unmarshalAny(value.Index(i), c, "")
+                if err != nil {
+                        return err
+                }
+        }
+
+        return nil
+}
+
+func unmarshalMap(value reflect.Value, data interface{}, tag reflect.StructTag) error {
+        if data == nil {
+                return nil
+        }
+        mapData, ok := data.(map[string]interface{})
+        if !ok {
+                return fmt.Errorf("JSON value is not a map (%#v)", data)
+        }
+
+        if value.IsNil() {
+                value.Set(reflect.MakeMap(value.Type()))
+        }
+
+        for k, v := range mapData {
+                kvalue := reflect.ValueOf(k)
+                vvalue := reflect.New(value.Type().Elem()).Elem()
+
+                unmarshalAny(vvalue, v, "")
+                value.SetMapIndex(kvalue, vvalue)
+        }
+
+        return nil
+}
+
+func unmarshalScalar(value reflect.Value, data interface{}, tag reflect.StructTag) error {
+
+        switch d := data.(type) {
+        case nil:
+                return nil // nothing to do here
+        case string:
+                switch value.Interface().(type) {
+                case *string:
+                        value.Set(reflect.ValueOf(&d))
+                case []byte:
+                        b, err := base64.StdEncoding.DecodeString(d)
+                        if err != nil {
+                                return err
+                        }
+                        value.Set(reflect.ValueOf(b))
+                case *time.Time:
+                        format := tag.Get("timestampFormat")
+                        if len(format) == 0 {
+                                format = protocol.ISO8601TimeFormatName
+                        }
+
+                        t, err := protocol.ParseTime(format, d)
+                        if err != nil {
+                                return err
+                        }
+                        value.Set(reflect.ValueOf(&t))
+                case aws.JSONValue:
+                        // No need to use escaping as the value is a non-quoted string.
+                        v, err := protocol.DecodeJSONValue(d, protocol.NoEscape)
+                        if err != nil {
+                                return err
+                        }
+                        value.Set(reflect.ValueOf(v))
+                default:
+                        return fmt.Errorf("unsupported value: %v (%s)", value.Interface(), value.Type())
+                }
+        case float64:
+                switch value.Interface().(type) {
+                case *int64:
+                        di := int64(d)
+                        value.Set(reflect.ValueOf(&di))
+                case *float64:
+                        value.Set(reflect.ValueOf(&d))
+                case *time.Time:
+                        // Time unmarshaled from a float64 can only be epoch seconds
+                        t := time.Unix(int64(d), 0).UTC()
+                        value.Set(reflect.ValueOf(&t))
+                default:
+                        return fmt.Errorf("unsupported value: %v (%s)", value.Interface(), value.Type())
+                }
+        case bool:
+                switch value.Interface().(type) {
+                case *bool:
+                        value.Set(reflect.ValueOf(&d))
+                default:
+                        return fmt.Errorf("unsupported value: %v (%s)", value.Interface(), value.Type())
+                }
+        default:
+                return fmt.Errorf("unsupported JSON value (%v)", data)
+        }
+        return nil
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/query/build.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/build.go
index 60e5b09..0cb99eb 100644
--- a/vendor/github.com/aws/aws-sdk-go/private/protocol/query/build.go
+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/build.go
@@ -21,7 +21,7 @@ func Build(r *request.Request) {
                 "Version": {r.ClientInfo.APIVersion},
         }
         if err := queryutil.Parse(body, r.Params, false); err != nil {
-                r.Error = awserr.New("SerializationError", "failed encoding Query request", err)
+                r.Error = awserr.New(request.ErrCodeSerialization, "failed encoding Query request", err)
                 return
         }
 
diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal.go
index 3495c73..f69c1ef 100644
--- a/vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal.go
+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal.go
@@ -24,7 +24,7 @@ func Unmarshal(r *request.Request) {
                 err := xmlutil.UnmarshalXML(r.Data, decoder, r.Operation.Name+"Result")
                 if err != nil {
                         r.Error = awserr.NewRequestFailure(
-                                awserr.New("SerializationError", "failed decoding Query response", err),
+                                awserr.New(request.ErrCodeSerialization, "failed decoding Query response", err),
                                 r.HTTPResponse.StatusCode,
                                 r.RequestID,
                         )
diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal_error.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal_error.go
index 46d354e..831b011 100644
--- a/vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal_error.go
+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal_error.go
@@ -2,73 +2,68 @@ package query
 
 import (
         "encoding/xml"
-        "io/ioutil"
+        "fmt"
 
         "github.com/aws/aws-sdk-go/aws/awserr"
         "github.com/aws/aws-sdk-go/aws/request"
+        "github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil"
 )
 
+// UnmarshalErrorHandler is a name request handler to unmarshal request errors
+var UnmarshalErrorHandler = request.NamedHandler{Name: "awssdk.query.UnmarshalError", Fn: UnmarshalError}
+
 type xmlErrorResponse struct {
-        XMLName   xml.Name `xml:"ErrorResponse"`
-        Code      string   `xml:"Error>Code"`
-        Message   string   `xml:"Error>Message"`
-        RequestID string   `xml:"RequestId"`
+        Code      string `xml:"Error>Code"`
+        Message   string `xml:"Error>Message"`
+        RequestID string `xml:"RequestId"`
 }
 
-type xmlServiceUnavailableResponse struct {
-        XMLName xml.Name `xml:"ServiceUnavailableException"`
+type xmlResponseError struct {
+        xmlErrorResponse
 }
 
-// UnmarshalErrorHandler is a name request handler to unmarshal request errors
-var UnmarshalErrorHandler = request.NamedHandler{Name: "awssdk.query.UnmarshalError", Fn: UnmarshalError}
+func (e *xmlResponseError) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
+        const svcUnavailableTagName = "ServiceUnavailableException"
+        const errorResponseTagName = "ErrorResponse"
+
+        switch start.Name.Local {
+        case svcUnavailableTagName:
+                e.Code = svcUnavailableTagName
+                e.Message = "service is unavailable"
+                return d.Skip()
+
+        case errorResponseTagName:
+                return d.DecodeElement(&e.xmlErrorResponse, &start)
+
+        default:
+                return fmt.Errorf("unknown error response tag, %v", start)
+        }
+}
 
 // UnmarshalError unmarshals an error response for an AWS Query service.
 func UnmarshalError(r *request.Request) {
         defer r.HTTPResponse.Body.Close()
 
-        bodyBytes, err := ioutil.ReadAll(r.HTTPResponse.Body)
+        var respErr xmlResponseError
+        err := xmlutil.UnmarshalXMLError(&respErr, r.HTTPResponse.Body)
         if err != nil {
                 r.Error = awserr.NewRequestFailure(
-                        awserr.New("SerializationError", "failed to read from query HTTP response body", err),
+                        awserr.New(request.ErrCodeSerialization,
+                                "failed to unmarshal error message", err),
                         r.HTTPResponse.StatusCode,
                         r.RequestID,
                 )
                 return
         }
 
-        // First check for specific error
-        resp := xmlErrorResponse{}
-        decodeErr := xml.Unmarshal(bodyBytes, &resp)
-        if decodeErr == nil {
-                reqID := resp.RequestID
-                if reqID == "" {
-                        reqID = r.RequestID
-                }
-                r.Error = awserr.NewRequestFailure(
-                        awserr.New(resp.Code, resp.Message, nil),
-                        r.HTTPResponse.StatusCode,
-                        reqID,
-                )
-                return
-        }
-
-        // Check for unhandled error
-        servUnavailResp := xmlServiceUnavailableResponse{}
-        unavailErr := xml.Unmarshal(bodyBytes, &servUnavailResp)
-        if unavailErr == nil {
-                r.Error = awserr.NewRequestFailure(
-                        awserr.New("ServiceUnavailableException", "service is unavailable", nil),
-                        r.HTTPResponse.StatusCode,
-                        r.RequestID,
-                )
-                return
+        reqID := respErr.RequestID
+        if len(reqID) == 0 {
+                reqID = r.RequestID
         }
 
-        // Failed to retrieve any error message from the response body
         r.Error = awserr.NewRequestFailure(
-                awserr.New("SerializationError",
-                        "failed to decode query XML error response", decodeErr),
+                awserr.New(respErr.Code, respErr.Message, nil),
                 r.HTTPResponse.StatusCode,
-                r.RequestID,
+                reqID,
         )
 }
diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/build.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/build.go
index b80f84f..1301b14 100644
--- a/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/build.go
+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/build.go
@@ -25,6 +25,8 @@ var noEscape [256]bool
 
 var errValueNotSet = fmt.Errorf("value not set")
 
+var byteSliceType = reflect.TypeOf([]byte{})
+
 func init() {
         for i := 0; i < len(noEscape); i++ {
                 // AWS expects every character except these to be escaped
@@ -94,6 +96,14 @@ func buildLocationElements(r *request.Request, v reflect.Value, buildGETQuery bo
                                 continue
                         }
 
+                        // Support the ability to customize values to be marshaled as a
+                        // blob even though they were modeled as a string. Required for S3
+                        // API operations like SSECustomerKey is modeled as stirng but
+                        // required to be base64 encoded in request.
+                        if field.Tag.Get("marshal-as") == "blob" {
+                                m = m.Convert(byteSliceType)
+                        }
+
                         var err error
                         switch field.Tag.Get("location") {
                         case "headers": // header maps
@@ -137,7 +147,7 @@ func buildBody(r *request.Request, v reflect.Value) {
                                         case string:
                                                 r.SetStringBody(reader)
                                         default:
-                                                r.Error = awserr.New("SerializationError",
+                                                r.Error = awserr.New(request.ErrCodeSerialization,
                                                         "failed to encode REST request",
                                                         fmt.Errorf("unknown payload type %s", payload.Type()))
                                         }
@@ -152,7 +162,7 @@ func buildHeader(header *http.Header, v reflect.Value, name string, tag reflect.
         if err == errValueNotSet {
                 return nil
         } else if err != nil {
-                return awserr.New("SerializationError", "failed to encode REST request", err)
+                return awserr.New(request.ErrCodeSerialization, "failed to encode REST request", err)
         }
 
         name = strings.TrimSpace(name)
@@ -170,7 +180,7 @@ func buildHeaderMap(header *http.Header, v reflect.Value, tag reflect.StructTag)
                 if err == errValueNotSet {
                         continue
                 } else if err != nil {
-                        return awserr.New("SerializationError", "failed to encode REST request", err)
+                        return awserr.New(request.ErrCodeSerialization, "failed to encode REST request", err)
 
                 }
                 keyStr := strings.TrimSpace(key.String())
@@ -186,7 +196,7 @@ func buildURI(u *url.URL, v reflect.Value, name string, tag reflect.StructTag) e
         if err == errValueNotSet {
                 return nil
         } else if err != nil {
-                return awserr.New("SerializationError", "failed to encode REST request", err)
+                return awserr.New(request.ErrCodeSerialization, "failed to encode REST request", err)
         }
 
         u.Path = strings.Replace(u.Path, "{"+name+"}", value, -1)
@@ -219,7 +229,7 @@ func buildQueryString(query url.Values, v reflect.Value, name string, tag reflec
                 if err == errValueNotSet {
                         return nil
                 } else if err != nil {
-                        return awserr.New("SerializationError", "failed to encode REST request", err)
+                        return awserr.New(request.ErrCodeSerialization, "failed to encode REST request", err)
                 }
                 query.Set(name, str)
         }
diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/unmarshal.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/unmarshal.go
index 33fd53b..de02136 100644
--- a/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/unmarshal.go
+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/rest/unmarshal.go
@@ -57,7 +57,7 @@ func unmarshalBody(r *request.Request, v reflect.Value) {
                                                 defer r.HTTPResponse.Body.Close()
                                                 b, err := ioutil.ReadAll(r.HTTPResponse.Body)
                                                 if err != nil {
-                                                        r.Error = awserr.New("SerializationError", "failed to decode REST response", err)
+                                                        r.Error = awserr.New(request.ErrCodeSerialization, "failed to decode REST response", err)
                                                 } else {
                                                         payload.Set(reflect.ValueOf(b))
                                                 }
@@ -65,7 +65,7 @@ func unmarshalBody(r *request.Request, v reflect.Value) {
                                                 defer r.HTTPResponse.Body.Close()
                                                 b, err := ioutil.ReadAll(r.HTTPResponse.Body)
                                                 if err != nil {
-                                                        r.Error = awserr.New("SerializationError", "failed to decode REST response", err)
+                                                        r.Error = awserr.New(request.ErrCodeSerialization, "failed to decode REST response", err)
                                                 } else {
                                                         str := string(b)
                                                         payload.Set(reflect.ValueOf(&str))
@@ -77,7 +77,7 @@ func unmarshalBody(r *request.Request, v reflect.Value) {
                                                 case "io.ReadSeeker":
                                                         b, err := ioutil.ReadAll(r.HTTPResponse.Body)
                                                         if err != nil {
-                                                                r.Error = awserr.New("SerializationError",
+                                                                r.Error = awserr.New(request.ErrCodeSerialization,
                                                                         "failed to read response body", err)
                                                                 return
                                                         }
@@ -85,7 +85,7 @@ func unmarshalBody(r *request.Request, v reflect.Value) {
                                                 default:
                                                         io.Copy(ioutil.Discard, r.HTTPResponse.Body)
                                                         defer r.HTTPResponse.Body.Close()
-                                                        r.Error = awserr.New("SerializationError",
+                                                        r.Error = awserr.New(request.ErrCodeSerialization,
                                                                 "failed to decode REST response",
                                                                 fmt.Errorf("unknown payload type %s", payload.Type()))
                                                 }
@@ -115,14 +115,14 @@ func unmarshalLocationElements(r *request.Request, v reflect.Value) {
                         case "header":
                                 err := unmarshalHeader(m, r.HTTPResponse.Header.Get(name), field.Tag)
                                 if err != nil {
-                                        r.Error = awserr.New("SerializationError", "failed to decode REST response", err)
+                                        r.Error = awserr.New(request.ErrCodeSerialization, "failed to decode REST response", err)
                                         break
                                 }
                         case "headers":
                                 prefix := field.Tag.Get("locationName")
                                 err := unmarshalHeaderMap(m, r.HTTPResponse.Header, prefix)
                                 if err != nil {
-                                        r.Error = awserr.New("SerializationError", "failed to decode REST response", err)
+                                        r.Error = awserr.New(request.ErrCodeSerialization, "failed to decode REST response", err)
                                         break
                                 }
                         }
diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/restxml/restxml.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/restxml/restxml.go
index b0f4e24..cf56964 100644
--- a/vendor/github.com/aws/aws-sdk-go/private/protocol/restxml/restxml.go
+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/restxml/restxml.go
@@ -37,7 +37,8 @@ func Build(r *request.Request) {
                 err := xmlutil.BuildXML(r.Params, xml.NewEncoder(&buf))
                 if err != nil {
                         r.Error = awserr.NewRequestFailure(
-                                awserr.New("SerializationError", "failed to encode rest XML request", err),
+                                awserr.New(request.ErrCodeSerialization,
+                                        "failed to encode rest XML request", err),
                                 r.HTTPResponse.StatusCode,
                                 r.RequestID,
                         )
@@ -55,7 +56,8 @@ func Unmarshal(r *request.Request) {
                 err := xmlutil.UnmarshalXML(r.Data, decoder, "")
                 if err != nil {
                         r.Error = awserr.NewRequestFailure(
-                                awserr.New("SerializationError", "failed to decode REST XML response", err),
+                                awserr.New(request.ErrCodeSerialization,
+                                        "failed to decode REST XML response", err),
                                 r.HTTPResponse.StatusCode,
                                 r.RequestID,
                         )
diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/unmarshal.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/unmarshal.go
index ff1ef68..7108d38 100644
--- a/vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/unmarshal.go
+++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/unmarshal.go
@@ -1,6 +1,7 @@
 package xmlutil
 
 import (
+        "bytes"
         "encoding/base64"
         "encoding/xml"
         "fmt"
@@ -10,9 +11,27 @@ import (
         "strings"
         "time"
 
+        "github.com/aws/aws-sdk-go/aws/awserr"
         "github.com/aws/aws-sdk-go/private/protocol"
 )
 
+// UnmarshalXMLError unmarshals the XML error from the stream into the value
+// type specified. The value must be a pointer. If the message fails to
+// unmarshal, the message content will be included in the returned error as a
+// awserr.UnmarshalError.
+func UnmarshalXMLError(v interface{}, stream io.Reader) error {
+        var errBuf bytes.Buffer
+        body := io.TeeReader(stream, &errBuf)
+
+        err := xml.NewDecoder(body).Decode(v)
+        if err != nil && err != io.EOF {
+                return awserr.NewUnmarshalError(err,
+                        "failed to unmarshal error message", errBuf.Bytes())
+        }
+
+        return nil
+}
+
 // UnmarshalXML deserializes an xml.Decoder into the container v. V
 // needs to match the shape of the XML expected to be decoded.
 // If the shape doesn't match unmarshaling will fail.