diff options
Diffstat (limited to 'vendor/github.com/aws/aws-sdk-go/private/protocol/query')
4 files changed, 374 insertions, 0 deletions
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 new file mode 100644 index 0000000..18169f0 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/build.go | |||
@@ -0,0 +1,36 @@ | |||
1 | // Package query provides serialization of AWS query requests, and responses. | ||
2 | package query | ||
3 | |||
4 | //go:generate go run -tags codegen ../../../models/protocol_tests/generate.go ../../../models/protocol_tests/input/query.json build_test.go | ||
5 | |||
6 | import ( | ||
7 | "net/url" | ||
8 | |||
9 | "github.com/aws/aws-sdk-go/aws/awserr" | ||
10 | "github.com/aws/aws-sdk-go/aws/request" | ||
11 | "github.com/aws/aws-sdk-go/private/protocol/query/queryutil" | ||
12 | ) | ||
13 | |||
14 | // BuildHandler is a named request handler for building query protocol requests | ||
15 | var BuildHandler = request.NamedHandler{Name: "awssdk.query.Build", Fn: Build} | ||
16 | |||
17 | // Build builds a request for an AWS Query service. | ||
18 | func Build(r *request.Request) { | ||
19 | body := url.Values{ | ||
20 | "Action": {r.Operation.Name}, | ||
21 | "Version": {r.ClientInfo.APIVersion}, | ||
22 | } | ||
23 | if err := queryutil.Parse(body, r.Params, false); err != nil { | ||
24 | r.Error = awserr.New("SerializationError", "failed encoding Query request", err) | ||
25 | return | ||
26 | } | ||
27 | |||
28 | if r.ExpireTime == 0 { | ||
29 | r.HTTPRequest.Method = "POST" | ||
30 | r.HTTPRequest.Header.Set("Content-Type", "application/x-www-form-urlencoded; charset=utf-8") | ||
31 | r.SetBufferBody([]byte(body.Encode())) | ||
32 | } else { // This is a pre-signed request | ||
33 | r.HTTPRequest.Method = "GET" | ||
34 | r.HTTPRequest.URL.RawQuery = body.Encode() | ||
35 | } | ||
36 | } | ||
diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/query/queryutil/queryutil.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/queryutil/queryutil.go new file mode 100644 index 0000000..524ca95 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/queryutil/queryutil.go | |||
@@ -0,0 +1,237 @@ | |||
1 | package queryutil | ||
2 | |||
3 | import ( | ||
4 | "encoding/base64" | ||
5 | "fmt" | ||
6 | "net/url" | ||
7 | "reflect" | ||
8 | "sort" | ||
9 | "strconv" | ||
10 | "strings" | ||
11 | "time" | ||
12 | |||
13 | "github.com/aws/aws-sdk-go/private/protocol" | ||
14 | ) | ||
15 | |||
16 | // Parse parses an object i and fills a url.Values object. The isEC2 flag | ||
17 | // indicates if this is the EC2 Query sub-protocol. | ||
18 | func Parse(body url.Values, i interface{}, isEC2 bool) error { | ||
19 | q := queryParser{isEC2: isEC2} | ||
20 | return q.parseValue(body, reflect.ValueOf(i), "", "") | ||
21 | } | ||
22 | |||
23 | func elemOf(value reflect.Value) reflect.Value { | ||
24 | for value.Kind() == reflect.Ptr { | ||
25 | value = value.Elem() | ||
26 | } | ||
27 | return value | ||
28 | } | ||
29 | |||
30 | type queryParser struct { | ||
31 | isEC2 bool | ||
32 | } | ||
33 | |||
34 | func (q *queryParser) parseValue(v url.Values, value reflect.Value, prefix string, tag reflect.StructTag) error { | ||
35 | value = elemOf(value) | ||
36 | |||
37 | // no need to handle zero values | ||
38 | if !value.IsValid() { | ||
39 | return nil | ||
40 | } | ||
41 | |||
42 | t := tag.Get("type") | ||
43 | if t == "" { | ||
44 | switch value.Kind() { | ||
45 | case reflect.Struct: | ||
46 | t = "structure" | ||
47 | case reflect.Slice: | ||
48 | t = "list" | ||
49 | case reflect.Map: | ||
50 | t = "map" | ||
51 | } | ||
52 | } | ||
53 | |||
54 | switch t { | ||
55 | case "structure": | ||
56 | return q.parseStruct(v, value, prefix) | ||
57 | case "list": | ||
58 | return q.parseList(v, value, prefix, tag) | ||
59 | case "map": | ||
60 | return q.parseMap(v, value, prefix, tag) | ||
61 | default: | ||
62 | return q.parseScalar(v, value, prefix, tag) | ||
63 | } | ||
64 | } | ||
65 | |||
66 | func (q *queryParser) parseStruct(v url.Values, value reflect.Value, prefix string) error { | ||
67 | if !value.IsValid() { | ||
68 | return nil | ||
69 | } | ||
70 | |||
71 | t := value.Type() | ||
72 | for i := 0; i < value.NumField(); i++ { | ||
73 | elemValue := elemOf(value.Field(i)) | ||
74 | field := t.Field(i) | ||
75 | |||
76 | if field.PkgPath != "" { | ||
77 | continue // ignore unexported fields | ||
78 | } | ||
79 | if field.Tag.Get("ignore") != "" { | ||
80 | continue | ||
81 | } | ||
82 | |||
83 | if protocol.CanSetIdempotencyToken(value.Field(i), field) { | ||
84 | token := protocol.GetIdempotencyToken() | ||
85 | elemValue = reflect.ValueOf(token) | ||
86 | } | ||
87 | |||
88 | var name string | ||
89 | if q.isEC2 { | ||
90 | name = field.Tag.Get("queryName") | ||
91 | } | ||
92 | if name == "" { | ||
93 | if field.Tag.Get("flattened") != "" && field.Tag.Get("locationNameList") != "" { | ||
94 | name = field.Tag.Get("locationNameList") | ||
95 | } else if locName := field.Tag.Get("locationName"); locName != "" { | ||
96 | name = locName | ||
97 | } | ||
98 | if name != "" && q.isEC2 { | ||
99 | name = strings.ToUpper(name[0:1]) + name[1:] | ||
100 | } | ||
101 | } | ||
102 | if name == "" { | ||
103 | name = field.Name | ||
104 | } | ||
105 | |||
106 | if prefix != "" { | ||
107 | name = prefix + "." + name | ||
108 | } | ||
109 | |||
110 | if err := q.parseValue(v, elemValue, name, field.Tag); err != nil { | ||
111 | return err | ||
112 | } | ||
113 | } | ||
114 | return nil | ||
115 | } | ||
116 | |||
117 | func (q *queryParser) parseList(v url.Values, value reflect.Value, prefix string, tag reflect.StructTag) error { | ||
118 | // If it's empty, generate an empty value | ||
119 | if !value.IsNil() && value.Len() == 0 { | ||
120 | v.Set(prefix, "") | ||
121 | return nil | ||
122 | } | ||
123 | |||
124 | // check for unflattened list member | ||
125 | if !q.isEC2 && tag.Get("flattened") == "" { | ||
126 | if listName := tag.Get("locationNameList"); listName == "" { | ||
127 | prefix += ".member" | ||
128 | } else { | ||
129 | prefix += "." + listName | ||
130 | } | ||
131 | } | ||
132 | |||
133 | for i := 0; i < value.Len(); i++ { | ||
134 | slicePrefix := prefix | ||
135 | if slicePrefix == "" { | ||
136 | slicePrefix = strconv.Itoa(i + 1) | ||
137 | } else { | ||
138 | slicePrefix = slicePrefix + "." + strconv.Itoa(i+1) | ||
139 | } | ||
140 | if err := q.parseValue(v, value.Index(i), slicePrefix, ""); err != nil { | ||
141 | return err | ||
142 | } | ||
143 | } | ||
144 | return nil | ||
145 | } | ||
146 | |||
147 | func (q *queryParser) parseMap(v url.Values, value reflect.Value, prefix string, tag reflect.StructTag) error { | ||
148 | // If it's empty, generate an empty value | ||
149 | if !value.IsNil() && value.Len() == 0 { | ||
150 | v.Set(prefix, "") | ||
151 | return nil | ||
152 | } | ||
153 | |||
154 | // check for unflattened list member | ||
155 | if !q.isEC2 && tag.Get("flattened") == "" { | ||
156 | prefix += ".entry" | ||
157 | } | ||
158 | |||
159 | // sort keys for improved serialization consistency. | ||
160 | // this is not strictly necessary for protocol support. | ||
161 | mapKeyValues := value.MapKeys() | ||
162 | mapKeys := map[string]reflect.Value{} | ||
163 | mapKeyNames := make([]string, len(mapKeyValues)) | ||
164 | for i, mapKey := range mapKeyValues { | ||
165 | name := mapKey.String() | ||
166 | mapKeys[name] = mapKey | ||
167 | mapKeyNames[i] = name | ||
168 | } | ||
169 | sort.Strings(mapKeyNames) | ||
170 | |||
171 | for i, mapKeyName := range mapKeyNames { | ||
172 | mapKey := mapKeys[mapKeyName] | ||
173 | mapValue := value.MapIndex(mapKey) | ||
174 | |||
175 | kname := tag.Get("locationNameKey") | ||
176 | if kname == "" { | ||
177 | kname = "key" | ||
178 | } | ||
179 | vname := tag.Get("locationNameValue") | ||
180 | if vname == "" { | ||
181 | vname = "value" | ||
182 | } | ||
183 | |||
184 | // serialize key | ||
185 | var keyName string | ||
186 | if prefix == "" { | ||
187 | keyName = strconv.Itoa(i+1) + "." + kname | ||
188 | } else { | ||
189 | keyName = prefix + "." + strconv.Itoa(i+1) + "." + kname | ||
190 | } | ||
191 | |||
192 | if err := q.parseValue(v, mapKey, keyName, ""); err != nil { | ||
193 | return err | ||
194 | } | ||
195 | |||
196 | // serialize value | ||
197 | var valueName string | ||
198 | if prefix == "" { | ||
199 | valueName = strconv.Itoa(i+1) + "." + vname | ||
200 | } else { | ||
201 | valueName = prefix + "." + strconv.Itoa(i+1) + "." + vname | ||
202 | } | ||
203 | |||
204 | if err := q.parseValue(v, mapValue, valueName, ""); err != nil { | ||
205 | return err | ||
206 | } | ||
207 | } | ||
208 | |||
209 | return nil | ||
210 | } | ||
211 | |||
212 | func (q *queryParser) parseScalar(v url.Values, r reflect.Value, name string, tag reflect.StructTag) error { | ||
213 | switch value := r.Interface().(type) { | ||
214 | case string: | ||
215 | v.Set(name, value) | ||
216 | case []byte: | ||
217 | if !r.IsNil() { | ||
218 | v.Set(name, base64.StdEncoding.EncodeToString(value)) | ||
219 | } | ||
220 | case bool: | ||
221 | v.Set(name, strconv.FormatBool(value)) | ||
222 | case int64: | ||
223 | v.Set(name, strconv.FormatInt(value, 10)) | ||
224 | case int: | ||
225 | v.Set(name, strconv.Itoa(value)) | ||
226 | case float64: | ||
227 | v.Set(name, strconv.FormatFloat(value, 'f', -1, 64)) | ||
228 | case float32: | ||
229 | v.Set(name, strconv.FormatFloat(float64(value), 'f', -1, 32)) | ||
230 | case time.Time: | ||
231 | const ISO8601UTC = "2006-01-02T15:04:05Z" | ||
232 | v.Set(name, value.UTC().Format(ISO8601UTC)) | ||
233 | default: | ||
234 | return fmt.Errorf("unsupported value for param %s: %v (%s)", name, r.Interface(), r.Type().Name()) | ||
235 | } | ||
236 | return nil | ||
237 | } | ||
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 new file mode 100644 index 0000000..e0f4d5a --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal.go | |||
@@ -0,0 +1,35 @@ | |||
1 | package query | ||
2 | |||
3 | //go:generate go run -tags codegen ../../../models/protocol_tests/generate.go ../../../models/protocol_tests/output/query.json unmarshal_test.go | ||
4 | |||
5 | import ( | ||
6 | "encoding/xml" | ||
7 | |||
8 | "github.com/aws/aws-sdk-go/aws/awserr" | ||
9 | "github.com/aws/aws-sdk-go/aws/request" | ||
10 | "github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil" | ||
11 | ) | ||
12 | |||
13 | // UnmarshalHandler is a named request handler for unmarshaling query protocol requests | ||
14 | var UnmarshalHandler = request.NamedHandler{Name: "awssdk.query.Unmarshal", Fn: Unmarshal} | ||
15 | |||
16 | // UnmarshalMetaHandler is a named request handler for unmarshaling query protocol request metadata | ||
17 | var UnmarshalMetaHandler = request.NamedHandler{Name: "awssdk.query.UnmarshalMeta", Fn: UnmarshalMeta} | ||
18 | |||
19 | // Unmarshal unmarshals a response for an AWS Query service. | ||
20 | func Unmarshal(r *request.Request) { | ||
21 | defer r.HTTPResponse.Body.Close() | ||
22 | if r.DataFilled() { | ||
23 | decoder := xml.NewDecoder(r.HTTPResponse.Body) | ||
24 | err := xmlutil.UnmarshalXML(r.Data, decoder, r.Operation.Name+"Result") | ||
25 | if err != nil { | ||
26 | r.Error = awserr.New("SerializationError", "failed decoding Query response", err) | ||
27 | return | ||
28 | } | ||
29 | } | ||
30 | } | ||
31 | |||
32 | // UnmarshalMeta unmarshals header response values for an AWS Query service. | ||
33 | func UnmarshalMeta(r *request.Request) { | ||
34 | r.RequestID = r.HTTPResponse.Header.Get("X-Amzn-Requestid") | ||
35 | } | ||
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 new file mode 100644 index 0000000..f214296 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/query/unmarshal_error.go | |||
@@ -0,0 +1,66 @@ | |||
1 | package query | ||
2 | |||
3 | import ( | ||
4 | "encoding/xml" | ||
5 | "io/ioutil" | ||
6 | |||
7 | "github.com/aws/aws-sdk-go/aws/awserr" | ||
8 | "github.com/aws/aws-sdk-go/aws/request" | ||
9 | ) | ||
10 | |||
11 | type xmlErrorResponse struct { | ||
12 | XMLName xml.Name `xml:"ErrorResponse"` | ||
13 | Code string `xml:"Error>Code"` | ||
14 | Message string `xml:"Error>Message"` | ||
15 | RequestID string `xml:"RequestId"` | ||
16 | } | ||
17 | |||
18 | type xmlServiceUnavailableResponse struct { | ||
19 | XMLName xml.Name `xml:"ServiceUnavailableException"` | ||
20 | } | ||
21 | |||
22 | // UnmarshalErrorHandler is a name request handler to unmarshal request errors | ||
23 | var UnmarshalErrorHandler = request.NamedHandler{Name: "awssdk.query.UnmarshalError", Fn: UnmarshalError} | ||
24 | |||
25 | // UnmarshalError unmarshals an error response for an AWS Query service. | ||
26 | func UnmarshalError(r *request.Request) { | ||
27 | defer r.HTTPResponse.Body.Close() | ||
28 | |||
29 | bodyBytes, err := ioutil.ReadAll(r.HTTPResponse.Body) | ||
30 | if err != nil { | ||
31 | r.Error = awserr.New("SerializationError", "failed to read from query HTTP response body", err) | ||
32 | return | ||
33 | } | ||
34 | |||
35 | // First check for specific error | ||
36 | resp := xmlErrorResponse{} | ||
37 | decodeErr := xml.Unmarshal(bodyBytes, &resp) | ||
38 | if decodeErr == nil { | ||
39 | reqID := resp.RequestID | ||
40 | if reqID == "" { | ||
41 | reqID = r.RequestID | ||
42 | } | ||
43 | r.Error = awserr.NewRequestFailure( | ||
44 | awserr.New(resp.Code, resp.Message, nil), | ||
45 | r.HTTPResponse.StatusCode, | ||
46 | reqID, | ||
47 | ) | ||
48 | return | ||
49 | } | ||
50 | |||
51 | // Check for unhandled error | ||
52 | servUnavailResp := xmlServiceUnavailableResponse{} | ||
53 | unavailErr := xml.Unmarshal(bodyBytes, &servUnavailResp) | ||
54 | if unavailErr == nil { | ||
55 | r.Error = awserr.NewRequestFailure( | ||
56 | awserr.New("ServiceUnavailableException", "service is unavailable", nil), | ||
57 | r.HTTPResponse.StatusCode, | ||
58 | r.RequestID, | ||
59 | ) | ||
60 | return | ||
61 | } | ||
62 | |||
63 | // Failed to retrieve any error message from the response body | ||
64 | r.Error = awserr.New("SerializationError", | ||
65 | "failed to decode query XML error response", decodeErr) | ||
66 | } | ||