diff options
Diffstat (limited to 'vendor/github.com/aws/aws-sdk-go/aws/request/handlers.go')
-rw-r--r-- | vendor/github.com/aws/aws-sdk-go/aws/request/handlers.go | 225 |
1 files changed, 225 insertions, 0 deletions
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/handlers.go b/vendor/github.com/aws/aws-sdk-go/aws/request/handlers.go new file mode 100644 index 0000000..6c14336 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/aws/request/handlers.go | |||
@@ -0,0 +1,225 @@ | |||
1 | package request | ||
2 | |||
3 | import ( | ||
4 | "fmt" | ||
5 | "strings" | ||
6 | ) | ||
7 | |||
8 | // A Handlers provides a collection of request handlers for various | ||
9 | // stages of handling requests. | ||
10 | type Handlers struct { | ||
11 | Validate HandlerList | ||
12 | Build HandlerList | ||
13 | Sign HandlerList | ||
14 | Send HandlerList | ||
15 | ValidateResponse HandlerList | ||
16 | Unmarshal HandlerList | ||
17 | UnmarshalMeta HandlerList | ||
18 | UnmarshalError HandlerList | ||
19 | Retry HandlerList | ||
20 | AfterRetry HandlerList | ||
21 | Complete HandlerList | ||
22 | } | ||
23 | |||
24 | // Copy returns of this handler's lists. | ||
25 | func (h *Handlers) Copy() Handlers { | ||
26 | return Handlers{ | ||
27 | Validate: h.Validate.copy(), | ||
28 | Build: h.Build.copy(), | ||
29 | Sign: h.Sign.copy(), | ||
30 | Send: h.Send.copy(), | ||
31 | ValidateResponse: h.ValidateResponse.copy(), | ||
32 | Unmarshal: h.Unmarshal.copy(), | ||
33 | UnmarshalError: h.UnmarshalError.copy(), | ||
34 | UnmarshalMeta: h.UnmarshalMeta.copy(), | ||
35 | Retry: h.Retry.copy(), | ||
36 | AfterRetry: h.AfterRetry.copy(), | ||
37 | Complete: h.Complete.copy(), | ||
38 | } | ||
39 | } | ||
40 | |||
41 | // Clear removes callback functions for all handlers | ||
42 | func (h *Handlers) Clear() { | ||
43 | h.Validate.Clear() | ||
44 | h.Build.Clear() | ||
45 | h.Send.Clear() | ||
46 | h.Sign.Clear() | ||
47 | h.Unmarshal.Clear() | ||
48 | h.UnmarshalMeta.Clear() | ||
49 | h.UnmarshalError.Clear() | ||
50 | h.ValidateResponse.Clear() | ||
51 | h.Retry.Clear() | ||
52 | h.AfterRetry.Clear() | ||
53 | h.Complete.Clear() | ||
54 | } | ||
55 | |||
56 | // A HandlerListRunItem represents an entry in the HandlerList which | ||
57 | // is being run. | ||
58 | type HandlerListRunItem struct { | ||
59 | Index int | ||
60 | Handler NamedHandler | ||
61 | Request *Request | ||
62 | } | ||
63 | |||
64 | // A HandlerList manages zero or more handlers in a list. | ||
65 | type HandlerList struct { | ||
66 | list []NamedHandler | ||
67 | |||
68 | // Called after each request handler in the list is called. If set | ||
69 | // and the func returns true the HandlerList will continue to iterate | ||
70 | // over the request handlers. If false is returned the HandlerList | ||
71 | // will stop iterating. | ||
72 | // | ||
73 | // Should be used if extra logic to be performed between each handler | ||
74 | // in the list. This can be used to terminate a list's iteration | ||
75 | // based on a condition such as error like, HandlerListStopOnError. | ||
76 | // Or for logging like HandlerListLogItem. | ||
77 | AfterEachFn func(item HandlerListRunItem) bool | ||
78 | } | ||
79 | |||
80 | // A NamedHandler is a struct that contains a name and function callback. | ||
81 | type NamedHandler struct { | ||
82 | Name string | ||
83 | Fn func(*Request) | ||
84 | } | ||
85 | |||
86 | // copy creates a copy of the handler list. | ||
87 | func (l *HandlerList) copy() HandlerList { | ||
88 | n := HandlerList{ | ||
89 | AfterEachFn: l.AfterEachFn, | ||
90 | } | ||
91 | if len(l.list) == 0 { | ||
92 | return n | ||
93 | } | ||
94 | |||
95 | n.list = append(make([]NamedHandler, 0, len(l.list)), l.list...) | ||
96 | return n | ||
97 | } | ||
98 | |||
99 | // Clear clears the handler list. | ||
100 | func (l *HandlerList) Clear() { | ||
101 | l.list = l.list[0:0] | ||
102 | } | ||
103 | |||
104 | // Len returns the number of handlers in the list. | ||
105 | func (l *HandlerList) Len() int { | ||
106 | return len(l.list) | ||
107 | } | ||
108 | |||
109 | // PushBack pushes handler f to the back of the handler list. | ||
110 | func (l *HandlerList) PushBack(f func(*Request)) { | ||
111 | l.PushBackNamed(NamedHandler{"__anonymous", f}) | ||
112 | } | ||
113 | |||
114 | // PushBackNamed pushes named handler f to the back of the handler list. | ||
115 | func (l *HandlerList) PushBackNamed(n NamedHandler) { | ||
116 | if cap(l.list) == 0 { | ||
117 | l.list = make([]NamedHandler, 0, 5) | ||
118 | } | ||
119 | l.list = append(l.list, n) | ||
120 | } | ||
121 | |||
122 | // PushFront pushes handler f to the front of the handler list. | ||
123 | func (l *HandlerList) PushFront(f func(*Request)) { | ||
124 | l.PushFrontNamed(NamedHandler{"__anonymous", f}) | ||
125 | } | ||
126 | |||
127 | // PushFrontNamed pushes named handler f to the front of the handler list. | ||
128 | func (l *HandlerList) PushFrontNamed(n NamedHandler) { | ||
129 | if cap(l.list) == len(l.list) { | ||
130 | // Allocating new list required | ||
131 | l.list = append([]NamedHandler{n}, l.list...) | ||
132 | } else { | ||
133 | // Enough room to prepend into list. | ||
134 | l.list = append(l.list, NamedHandler{}) | ||
135 | copy(l.list[1:], l.list) | ||
136 | l.list[0] = n | ||
137 | } | ||
138 | } | ||
139 | |||
140 | // Remove removes a NamedHandler n | ||
141 | func (l *HandlerList) Remove(n NamedHandler) { | ||
142 | l.RemoveByName(n.Name) | ||
143 | } | ||
144 | |||
145 | // RemoveByName removes a NamedHandler by name. | ||
146 | func (l *HandlerList) RemoveByName(name string) { | ||
147 | for i := 0; i < len(l.list); i++ { | ||
148 | m := l.list[i] | ||
149 | if m.Name == name { | ||
150 | // Shift array preventing creating new arrays | ||
151 | copy(l.list[i:], l.list[i+1:]) | ||
152 | l.list[len(l.list)-1] = NamedHandler{} | ||
153 | l.list = l.list[:len(l.list)-1] | ||
154 | |||
155 | // decrement list so next check to length is correct | ||
156 | i-- | ||
157 | } | ||
158 | } | ||
159 | } | ||
160 | |||
161 | // Run executes all handlers in the list with a given request object. | ||
162 | func (l *HandlerList) Run(r *Request) { | ||
163 | for i, h := range l.list { | ||
164 | h.Fn(r) | ||
165 | item := HandlerListRunItem{ | ||
166 | Index: i, Handler: h, Request: r, | ||
167 | } | ||
168 | if l.AfterEachFn != nil && !l.AfterEachFn(item) { | ||
169 | return | ||
170 | } | ||
171 | } | ||
172 | } | ||
173 | |||
174 | // HandlerListLogItem logs the request handler and the state of the | ||
175 | // request's Error value. Always returns true to continue iterating | ||
176 | // request handlers in a HandlerList. | ||
177 | func HandlerListLogItem(item HandlerListRunItem) bool { | ||
178 | if item.Request.Config.Logger == nil { | ||
179 | return true | ||
180 | } | ||
181 | item.Request.Config.Logger.Log("DEBUG: RequestHandler", | ||
182 | item.Index, item.Handler.Name, item.Request.Error) | ||
183 | |||
184 | return true | ||
185 | } | ||
186 | |||
187 | // HandlerListStopOnError returns false to stop the HandlerList iterating | ||
188 | // over request handlers if Request.Error is not nil. True otherwise | ||
189 | // to continue iterating. | ||
190 | func HandlerListStopOnError(item HandlerListRunItem) bool { | ||
191 | return item.Request.Error == nil | ||
192 | } | ||
193 | |||
194 | // WithAppendUserAgent will add a string to the user agent prefixed with a | ||
195 | // single white space. | ||
196 | func WithAppendUserAgent(s string) Option { | ||
197 | return func(r *Request) { | ||
198 | r.Handlers.Build.PushBack(func(r2 *Request) { | ||
199 | AddToUserAgent(r, s) | ||
200 | }) | ||
201 | } | ||
202 | } | ||
203 | |||
204 | // MakeAddToUserAgentHandler will add the name/version pair to the User-Agent request | ||
205 | // header. If the extra parameters are provided they will be added as metadata to the | ||
206 | // name/version pair resulting in the following format. | ||
207 | // "name/version (extra0; extra1; ...)" | ||
208 | // The user agent part will be concatenated with this current request's user agent string. | ||
209 | func MakeAddToUserAgentHandler(name, version string, extra ...string) func(*Request) { | ||
210 | ua := fmt.Sprintf("%s/%s", name, version) | ||
211 | if len(extra) > 0 { | ||
212 | ua += fmt.Sprintf(" (%s)", strings.Join(extra, "; ")) | ||
213 | } | ||
214 | return func(r *Request) { | ||
215 | AddToUserAgent(r, ua) | ||
216 | } | ||
217 | } | ||
218 | |||
219 | // MakeAddToUserAgentFreeFormHandler adds the input to the User-Agent request header. | ||
220 | // The input string will be concatenated with the current request's user agent string. | ||
221 | func MakeAddToUserAgentFreeFormHandler(s string) func(*Request) { | ||
222 | return func(r *Request) { | ||
223 | AddToUserAgent(r, s) | ||
224 | } | ||
225 | } | ||