15 files changed, 1975 insertions, 0 deletions

diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/connection_reset_error.go b/vendor/github.com/aws/aws-sdk-go/aws/request/connection_reset_error.go
new file mode 100644
index 0000000..10fc8cb
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/connection_reset_error.go
@@ -0,0 +1,19 @@
+// +build !appengine
+
+package request
+
+import (
+        "net"
+        "os"
+        "syscall"
+)
+
+func isErrConnectionReset(err error) bool {
+        if opErr, ok := err.(*net.OpError); ok {
+                if sysErr, ok := opErr.Err.(*os.SyscallError); ok {
+                        return sysErr.Err == syscall.ECONNRESET
+                }
+        }
+
+        return false
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/connection_reset_error_appengine.go b/vendor/github.com/aws/aws-sdk-go/aws/request/connection_reset_error_appengine.go
new file mode 100644
index 0000000..996196e
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/connection_reset_error_appengine.go
@@ -0,0 +1,11 @@
+// +build appengine
+
+package request
+
+import (
+        "strings"
+)
+
+func isErrConnectionReset(err error) bool {
+        return strings.Contains(err.Error(), "connection reset")
+}
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 @@
+package request
+
+import (
+        "fmt"
+        "strings"
+)
+
+// A Handlers provides a collection of request handlers for various
+// stages of handling requests.
+type Handlers struct {
+        Validate         HandlerList
+        Build            HandlerList
+        Sign             HandlerList
+        Send             HandlerList
+        ValidateResponse HandlerList
+        Unmarshal        HandlerList
+        UnmarshalMeta    HandlerList
+        UnmarshalError   HandlerList
+        Retry            HandlerList
+        AfterRetry       HandlerList
+        Complete         HandlerList
+}
+
+// Copy returns of this handler's lists.
+func (h *Handlers) Copy() Handlers {
+        return Handlers{
+                Validate:         h.Validate.copy(),
+                Build:            h.Build.copy(),
+                Sign:             h.Sign.copy(),
+                Send:             h.Send.copy(),
+                ValidateResponse: h.ValidateResponse.copy(),
+                Unmarshal:        h.Unmarshal.copy(),
+                UnmarshalError:   h.UnmarshalError.copy(),
+                UnmarshalMeta:    h.UnmarshalMeta.copy(),
+                Retry:            h.Retry.copy(),
+                AfterRetry:       h.AfterRetry.copy(),
+                Complete:         h.Complete.copy(),
+        }
+}
+
+// Clear removes callback functions for all handlers
+func (h *Handlers) Clear() {
+        h.Validate.Clear()
+        h.Build.Clear()
+        h.Send.Clear()
+        h.Sign.Clear()
+        h.Unmarshal.Clear()
+        h.UnmarshalMeta.Clear()
+        h.UnmarshalError.Clear()
+        h.ValidateResponse.Clear()
+        h.Retry.Clear()
+        h.AfterRetry.Clear()
+        h.Complete.Clear()
+}
+
+// A HandlerListRunItem represents an entry in the HandlerList which
+// is being run.
+type HandlerListRunItem struct {
+        Index   int
+        Handler NamedHandler
+        Request *Request
+}
+
+// A HandlerList manages zero or more handlers in a list.
+type HandlerList struct {
+        list []NamedHandler
+
+        // Called after each request handler in the list is called. If set
+        // and the func returns true the HandlerList will continue to iterate
+        // over the request handlers. If false is returned the HandlerList
+        // will stop iterating.
+        //
+        // Should be used if extra logic to be performed between each handler
+        // in the list. This can be used to terminate a list's iteration
+        // based on a condition such as error like, HandlerListStopOnError.
+        // Or for logging like HandlerListLogItem.
+        AfterEachFn func(item HandlerListRunItem) bool
+}
+
+// A NamedHandler is a struct that contains a name and function callback.
+type NamedHandler struct {
+        Name string
+        Fn   func(*Request)
+}
+
+// copy creates a copy of the handler list.
+func (l *HandlerList) copy() HandlerList {
+        n := HandlerList{
+                AfterEachFn: l.AfterEachFn,
+        }
+        if len(l.list) == 0 {
+                return n
+        }
+
+        n.list = append(make([]NamedHandler, 0, len(l.list)), l.list...)
+        return n
+}
+
+// Clear clears the handler list.
+func (l *HandlerList) Clear() {
+        l.list = l.list[0:0]
+}
+
+// Len returns the number of handlers in the list.
+func (l *HandlerList) Len() int {
+        return len(l.list)
+}
+
+// PushBack pushes handler f to the back of the handler list.
+func (l *HandlerList) PushBack(f func(*Request)) {
+        l.PushBackNamed(NamedHandler{"__anonymous", f})
+}
+
+// PushBackNamed pushes named handler f to the back of the handler list.
+func (l *HandlerList) PushBackNamed(n NamedHandler) {
+        if cap(l.list) == 0 {
+                l.list = make([]NamedHandler, 0, 5)
+        }
+        l.list = append(l.list, n)
+}
+
+// PushFront pushes handler f to the front of the handler list.
+func (l *HandlerList) PushFront(f func(*Request)) {
+        l.PushFrontNamed(NamedHandler{"__anonymous", f})
+}
+
+// PushFrontNamed pushes named handler f to the front of the handler list.
+func (l *HandlerList) PushFrontNamed(n NamedHandler) {
+        if cap(l.list) == len(l.list) {
+                // Allocating new list required
+                l.list = append([]NamedHandler{n}, l.list...)
+        } else {
+                // Enough room to prepend into list.
+                l.list = append(l.list, NamedHandler{})
+                copy(l.list[1:], l.list)
+                l.list[0] = n
+        }
+}
+
+// Remove removes a NamedHandler n
+func (l *HandlerList) Remove(n NamedHandler) {
+        l.RemoveByName(n.Name)
+}
+
+// RemoveByName removes a NamedHandler by name.
+func (l *HandlerList) RemoveByName(name string) {
+        for i := 0; i < len(l.list); i++ {
+                m := l.list[i]
+                if m.Name == name {
+                        // Shift array preventing creating new arrays
+                        copy(l.list[i:], l.list[i+1:])
+                        l.list[len(l.list)-1] = NamedHandler{}
+                        l.list = l.list[:len(l.list)-1]
+
+                        // decrement list so next check to length is correct
+                        i--
+                }
+        }
+}
+
+// Run executes all handlers in the list with a given request object.
+func (l *HandlerList) Run(r *Request) {
+        for i, h := range l.list {
+                h.Fn(r)
+                item := HandlerListRunItem{
+                        Index: i, Handler: h, Request: r,
+                }
+                if l.AfterEachFn != nil && !l.AfterEachFn(item) {
+                        return
+                }
+        }
+}
+
+// HandlerListLogItem logs the request handler and the state of the
+// request's Error value. Always returns true to continue iterating
+// request handlers in a HandlerList.
+func HandlerListLogItem(item HandlerListRunItem) bool {
+        if item.Request.Config.Logger == nil {
+                return true
+        }
+        item.Request.Config.Logger.Log("DEBUG: RequestHandler",
+                item.Index, item.Handler.Name, item.Request.Error)
+
+        return true
+}
+
+// HandlerListStopOnError returns false to stop the HandlerList iterating
+// over request handlers if Request.Error is not nil. True otherwise
+// to continue iterating.
+func HandlerListStopOnError(item HandlerListRunItem) bool {
+        return item.Request.Error == nil
+}
+
+// WithAppendUserAgent will add a string to the user agent prefixed with a
+// single white space.
+func WithAppendUserAgent(s string) Option {
+        return func(r *Request) {
+                r.Handlers.Build.PushBack(func(r2 *Request) {
+                        AddToUserAgent(r, s)
+                })
+        }
+}
+
+// MakeAddToUserAgentHandler will add the name/version pair to the User-Agent request
+// header. If the extra parameters are provided they will be added as metadata to the
+// name/version pair resulting in the following format.
+// "name/version (extra0; extra1; ...)"
+// The user agent part will be concatenated with this current request's user agent string.
+func MakeAddToUserAgentHandler(name, version string, extra ...string) func(*Request) {
+        ua := fmt.Sprintf("%s/%s", name, version)
+        if len(extra) > 0 {
+                ua += fmt.Sprintf(" (%s)", strings.Join(extra, "; "))
+        }
+        return func(r *Request) {
+                AddToUserAgent(r, ua)
+        }
+}
+
+// MakeAddToUserAgentFreeFormHandler adds the input to the User-Agent request header.
+// The input string will be concatenated with the current request's user agent string.
+func MakeAddToUserAgentFreeFormHandler(s string) func(*Request) {
+        return func(r *Request) {
+                AddToUserAgent(r, s)
+        }
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/http_request.go b/vendor/github.com/aws/aws-sdk-go/aws/request/http_request.go
new file mode 100644
index 0000000..79f7960
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/http_request.go
@@ -0,0 +1,24 @@
+package request
+
+import (
+        "io"
+        "net/http"
+        "net/url"
+)
+
+func copyHTTPRequest(r *http.Request, body io.ReadCloser) *http.Request {
+        req := new(http.Request)
+        *req = *r
+        req.URL = &url.URL{}
+        *req.URL = *r.URL
+        req.Body = body
+
+        req.Header = http.Header{}
+        for k, v := range r.Header {
+                for _, vv := range v {
+                        req.Header.Add(k, vv)
+                }
+        }
+
+        return req
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/offset_reader.go b/vendor/github.com/aws/aws-sdk-go/aws/request/offset_reader.go
new file mode 100644
index 0000000..02f07f4
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/offset_reader.go
@@ -0,0 +1,58 @@
+package request
+
+import (
+        "io"
+        "sync"
+)
+
+// offsetReader is a thread-safe io.ReadCloser to prevent racing
+// with retrying requests
+type offsetReader struct {
+        buf    io.ReadSeeker
+        lock   sync.Mutex
+        closed bool
+}
+
+func newOffsetReader(buf io.ReadSeeker, offset int64) *offsetReader {
+        reader := &offsetReader{}
+        buf.Seek(offset, 0)
+
+        reader.buf = buf
+        return reader
+}
+
+// Close will close the instance of the offset reader's access to
+// the underlying io.ReadSeeker.
+func (o *offsetReader) Close() error {
+        o.lock.Lock()
+        defer o.lock.Unlock()
+        o.closed = true
+        return nil
+}
+
+// Read is a thread-safe read of the underlying io.ReadSeeker
+func (o *offsetReader) Read(p []byte) (int, error) {
+        o.lock.Lock()
+        defer o.lock.Unlock()
+
+        if o.closed {
+                return 0, io.EOF
+        }
+
+        return o.buf.Read(p)
+}
+
+// Seek is a thread-safe seeking operation.
+func (o *offsetReader) Seek(offset int64, whence int) (int64, error) {
+        o.lock.Lock()
+        defer o.lock.Unlock()
+
+        return o.buf.Seek(offset, whence)
+}
+
+// CloseAndCopy will return a new offsetReader with a copy of the old buffer
+// and close the old buffer.
+func (o *offsetReader) CloseAndCopy(offset int64) *offsetReader {
+        o.Close()
+        return newOffsetReader(o.buf, offset)
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/request.go b/vendor/github.com/aws/aws-sdk-go/aws/request/request.go
new file mode 100644
index 0000000..4f4f112
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/request.go
@@ -0,0 +1,575 @@
+package request
+
+import (
+        "bytes"
+        "fmt"
+        "io"
+        "net"
+        "net/http"
+        "net/url"
+        "reflect"
+        "strings"
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/client/metadata"
+)
+
+const (
+        // ErrCodeSerialization is the serialization error code that is received
+        // during protocol unmarshaling.
+        ErrCodeSerialization = "SerializationError"
+
+        // ErrCodeRead is an error that is returned during HTTP reads.
+        ErrCodeRead = "ReadError"
+
+        // ErrCodeResponseTimeout is the connection timeout error that is recieved
+        // during body reads.
+        ErrCodeResponseTimeout = "ResponseTimeout"
+
+        // CanceledErrorCode is the error code that will be returned by an
+        // API request that was canceled. Requests given a aws.Context may
+        // return this error when canceled.
+        CanceledErrorCode = "RequestCanceled"
+)
+
+// A Request is the service request to be made.
+type Request struct {
+        Config     aws.Config
+        ClientInfo metadata.ClientInfo
+        Handlers   Handlers
+
+        Retryer
+        Time                   time.Time
+        ExpireTime             time.Duration
+        Operation              *Operation
+        HTTPRequest            *http.Request
+        HTTPResponse           *http.Response
+        Body                   io.ReadSeeker
+        BodyStart              int64 // offset from beginning of Body that the request body starts
+        Params                 interface{}
+        Error                  error
+        Data                   interface{}
+        RequestID              string
+        RetryCount             int
+        Retryable              *bool
+        RetryDelay             time.Duration
+        NotHoist               bool
+        SignedHeaderVals       http.Header
+        LastSignedAt           time.Time
+        DisableFollowRedirects bool
+
+        context aws.Context
+
+        built bool
+
+        // Need to persist an intermediate body between the input Body and HTTP
+        // request body because the HTTP Client's transport can maintain a reference
+        // to the HTTP request's body after the client has returned. This value is
+        // safe to use concurrently and wrap the input Body for each HTTP request.
+        safeBody *offsetReader
+}
+
+// An Operation is the service API operation to be made.
+type Operation struct {
+        Name       string
+        HTTPMethod string
+        HTTPPath   string
+        *Paginator
+
+        BeforePresignFn func(r *Request) error
+}
+
+// New returns a new Request pointer for the service API
+// operation and parameters.
+//
+// Params is any value of input parameters to be the request payload.
+// Data is pointer value to an object which the request's response
+// payload will be deserialized to.
+func New(cfg aws.Config, clientInfo metadata.ClientInfo, handlers Handlers,
+        retryer Retryer, operation *Operation, params interface{}, data interface{}) *Request {
+
+        method := operation.HTTPMethod
+        if method == "" {
+                method = "POST"
+        }
+
+        httpReq, _ := http.NewRequest(method, "", nil)
+
+        var err error
+        httpReq.URL, err = url.Parse(clientInfo.Endpoint + operation.HTTPPath)
+        if err != nil {
+                httpReq.URL = &url.URL{}
+                err = awserr.New("InvalidEndpointURL", "invalid endpoint uri", err)
+        }
+
+        r := &Request{
+                Config:     cfg,
+                ClientInfo: clientInfo,
+                Handlers:   handlers.Copy(),
+
+                Retryer:     retryer,
+                Time:        time.Now(),
+                ExpireTime:  0,
+                Operation:   operation,
+                HTTPRequest: httpReq,
+                Body:        nil,
+                Params:      params,
+                Error:       err,
+                Data:        data,
+        }
+        r.SetBufferBody([]byte{})
+
+        return r
+}
+
+// A Option is a functional option that can augment or modify a request when
+// using a WithContext API operation method.
+type Option func(*Request)
+
+// WithGetResponseHeader builds a request Option which will retrieve a single
+// header value from the HTTP Response. If there are multiple values for the
+// header key use WithGetResponseHeaders instead to access the http.Header
+// map directly. The passed in val pointer must be non-nil.
+//
+// This Option can be used multiple times with a single API operation.
+//
+//    var id2, versionID string
+//    svc.PutObjectWithContext(ctx, params,
+//        request.WithGetResponseHeader("x-amz-id-2", &id2),
+//        request.WithGetResponseHeader("x-amz-version-id", &versionID),
+//    )
+func WithGetResponseHeader(key string, val *string) Option {
+        return func(r *Request) {
+                r.Handlers.Complete.PushBack(func(req *Request) {
+                        *val = req.HTTPResponse.Header.Get(key)
+                })
+        }
+}
+
+// WithGetResponseHeaders builds a request Option which will retrieve the
+// headers from the HTTP response and assign them to the passed in headers
+// variable. The passed in headers pointer must be non-nil.
+//
+//    var headers http.Header
+//    svc.PutObjectWithContext(ctx, params, request.WithGetResponseHeaders(&headers))
+func WithGetResponseHeaders(headers *http.Header) Option {
+        return func(r *Request) {
+                r.Handlers.Complete.PushBack(func(req *Request) {
+                        *headers = req.HTTPResponse.Header
+                })
+        }
+}
+
+// WithLogLevel is a request option that will set the request to use a specific
+// log level when the request is made.
+//
+//     svc.PutObjectWithContext(ctx, params, request.WithLogLevel(aws.LogDebugWithHTTPBody)
+func WithLogLevel(l aws.LogLevelType) Option {
+        return func(r *Request) {
+                r.Config.LogLevel = aws.LogLevel(l)
+        }
+}
+
+// ApplyOptions will apply each option to the request calling them in the order
+// the were provided.
+func (r *Request) ApplyOptions(opts ...Option) {
+        for _, opt := range opts {
+                opt(r)
+        }
+}
+
+// Context will always returns a non-nil context. If Request does not have a
+// context aws.BackgroundContext will be returned.
+func (r *Request) Context() aws.Context {
+        if r.context != nil {
+                return r.context
+        }
+        return aws.BackgroundContext()
+}
+
+// SetContext adds a Context to the current request that can be used to cancel
+// a in-flight request. The Context value must not be nil, or this method will
+// panic.
+//
+// Unlike http.Request.WithContext, SetContext does not return a copy of the
+// Request. It is not safe to use use a single Request value for multiple
+// requests. A new Request should be created for each API operation request.
+//
+// Go 1.6 and below:
+// The http.Request's Cancel field will be set to the Done() value of
+// the context. This will overwrite the Cancel field's value.
+//
+// Go 1.7 and above:
+// The http.Request.WithContext will be used to set the context on the underlying
+// http.Request. This will create a shallow copy of the http.Request. The SDK
+// may create sub contexts in the future for nested requests such as retries.
+func (r *Request) SetContext(ctx aws.Context) {
+        if ctx == nil {
+                panic("context cannot be nil")
+        }
+        setRequestContext(r, ctx)
+}
+
+// WillRetry returns if the request's can be retried.
+func (r *Request) WillRetry() bool {
+        return r.Error != nil && aws.BoolValue(r.Retryable) && r.RetryCount < r.MaxRetries()
+}
+
+// ParamsFilled returns if the request's parameters have been populated
+// and the parameters are valid. False is returned if no parameters are
+// provided or invalid.
+func (r *Request) ParamsFilled() bool {
+        return r.Params != nil && reflect.ValueOf(r.Params).Elem().IsValid()
+}
+
+// DataFilled returns true if the request's data for response deserialization
+// target has been set and is a valid. False is returned if data is not
+// set, or is invalid.
+func (r *Request) DataFilled() bool {
+        return r.Data != nil && reflect.ValueOf(r.Data).Elem().IsValid()
+}
+
+// SetBufferBody will set the request's body bytes that will be sent to
+// the service API.
+func (r *Request) SetBufferBody(buf []byte) {
+        r.SetReaderBody(bytes.NewReader(buf))
+}
+
+// SetStringBody sets the body of the request to be backed by a string.
+func (r *Request) SetStringBody(s string) {
+        r.SetReaderBody(strings.NewReader(s))
+}
+
+// SetReaderBody will set the request's body reader.
+func (r *Request) SetReaderBody(reader io.ReadSeeker) {
+        r.Body = reader
+        r.ResetBody()
+}
+
+// Presign returns the request's signed URL. Error will be returned
+// if the signing fails.
+func (r *Request) Presign(expireTime time.Duration) (string, error) {
+        r.ExpireTime = expireTime
+        r.NotHoist = false
+
+        if r.Operation.BeforePresignFn != nil {
+                r = r.copy()
+                err := r.Operation.BeforePresignFn(r)
+                if err != nil {
+                        return "", err
+                }
+        }
+
+        r.Sign()
+        if r.Error != nil {
+                return "", r.Error
+        }
+        return r.HTTPRequest.URL.String(), nil
+}
+
+// PresignRequest behaves just like presign, but hoists all headers and signs them.
+// Also returns the signed hash back to the user
+func (r *Request) PresignRequest(expireTime time.Duration) (string, http.Header, error) {
+        r.ExpireTime = expireTime
+        r.NotHoist = true
+        r.Sign()
+        if r.Error != nil {
+                return "", nil, r.Error
+        }
+        return r.HTTPRequest.URL.String(), r.SignedHeaderVals, nil
+}
+
+func debugLogReqError(r *Request, stage string, retrying bool, err error) {
+        if !r.Config.LogLevel.Matches(aws.LogDebugWithRequestErrors) {
+                return
+        }
+
+        retryStr := "not retrying"
+        if retrying {
+                retryStr = "will retry"
+        }
+
+        r.Config.Logger.Log(fmt.Sprintf("DEBUG: %s %s/%s failed, %s, error %v",
+                stage, r.ClientInfo.ServiceName, r.Operation.Name, retryStr, err))
+}
+
+// Build will build the request's object so it can be signed and sent
+// to the service. Build will also validate all the request's parameters.
+// Anny additional build Handlers set on this request will be run
+// in the order they were set.
+//
+// The request will only be built once. Multiple calls to build will have
+// no effect.
+//
+// If any Validate or Build errors occur the build will stop and the error
+// which occurred will be returned.
+func (r *Request) Build() error {
+        if !r.built {
+                r.Handlers.Validate.Run(r)
+                if r.Error != nil {
+                        debugLogReqError(r, "Validate Request", false, r.Error)
+                        return r.Error
+                }
+                r.Handlers.Build.Run(r)
+                if r.Error != nil {
+                        debugLogReqError(r, "Build Request", false, r.Error)
+                        return r.Error
+                }
+                r.built = true
+        }
+
+        return r.Error
+}
+
+// Sign will sign the request returning error if errors are encountered.
+//
+// Send will build the request prior to signing. All Sign Handlers will
+// be executed in the order they were set.
+func (r *Request) Sign() error {
+        r.Build()
+        if r.Error != nil {
+                debugLogReqError(r, "Build Request", false, r.Error)
+                return r.Error
+        }
+
+        r.Handlers.Sign.Run(r)
+        return r.Error
+}
+
+// ResetBody rewinds the request body backto its starting position, and
+// set's the HTTP Request body reference. When the body is read prior
+// to being sent in the HTTP request it will need to be rewound.
+func (r *Request) ResetBody() {
+        if r.safeBody != nil {
+                r.safeBody.Close()
+        }
+
+        r.safeBody = newOffsetReader(r.Body, r.BodyStart)
+
+        // Go 1.8 tightened and clarified the rules code needs to use when building
+        // requests with the http package. Go 1.8 removed the automatic detection
+        // of if the Request.Body was empty, or actually had bytes in it. The SDK
+        // always sets the Request.Body even if it is empty and should not actually
+        // be sent. This is incorrect.
+        //
+        // Go 1.8 did add a http.NoBody value that the SDK can use to tell the http
+        // client that the request really should be sent without a body. The
+        // Request.Body cannot be set to nil, which is preferable, because the
+        // field is exported and could introduce nil pointer dereferences for users
+        // of the SDK if they used that field.
+        //
+        // Related golang/go#18257
+        l, err := computeBodyLength(r.Body)
+        if err != nil {
+                r.Error = awserr.New(ErrCodeSerialization, "failed to compute request body size", err)
+                return
+        }
+
+        if l == 0 {
+                r.HTTPRequest.Body = noBodyReader
+        } else if l > 0 {
+                r.HTTPRequest.Body = r.safeBody
+        } else {
+                // Hack to prevent sending bodies for methods where the body
+                // should be ignored by the server. Sending bodies on these
+                // methods without an associated ContentLength will cause the
+                // request to socket timeout because the server does not handle
+                // Transfer-Encoding: chunked bodies for these methods.
+                //
+                // This would only happen if a aws.ReaderSeekerCloser was used with
+                // a io.Reader that was not also an io.Seeker.
+                switch r.Operation.HTTPMethod {
+                case "GET", "HEAD", "DELETE":
+                        r.HTTPRequest.Body = noBodyReader
+                default:
+                        r.HTTPRequest.Body = r.safeBody
+                }
+        }
+}
+
+// Attempts to compute the length of the body of the reader using the
+// io.Seeker interface. If the value is not seekable because of being
+// a ReaderSeekerCloser without an unerlying Seeker -1 will be returned.
+// If no error occurs the length of the body will be returned.
+func computeBodyLength(r io.ReadSeeker) (int64, error) {
+        seekable := true
+        // Determine if the seeker is actually seekable. ReaderSeekerCloser
+        // hides the fact that a io.Readers might not actually be seekable.
+        switch v := r.(type) {
+        case aws.ReaderSeekerCloser:
+                seekable = v.IsSeeker()
+        case *aws.ReaderSeekerCloser:
+                seekable = v.IsSeeker()
+        }
+        if !seekable {
+                return -1, nil
+        }
+
+        curOffset, err := r.Seek(0, 1)
+        if err != nil {
+                return 0, err
+        }
+
+        endOffset, err := r.Seek(0, 2)
+        if err != nil {
+                return 0, err
+        }
+
+        _, err = r.Seek(curOffset, 0)
+        if err != nil {
+                return 0, err
+        }
+
+        return endOffset - curOffset, nil
+}
+
+// GetBody will return an io.ReadSeeker of the Request's underlying
+// input body with a concurrency safe wrapper.
+func (r *Request) GetBody() io.ReadSeeker {
+        return r.safeBody
+}
+
+// Send will send the request returning error if errors are encountered.
+//
+// Send will sign the request prior to sending. All Send Handlers will
+// be executed in the order they were set.
+//
+// Canceling a request is non-deterministic. If a request has been canceled,
+// then the transport will choose, randomly, one of the state channels during
+// reads or getting the connection.
+//
+// readLoop() and getConn(req *Request, cm connectMethod)
+// https://github.com/golang/go/blob/master/src/net/http/transport.go
+//
+// Send will not close the request.Request's body.
+func (r *Request) Send() error {
+        defer func() {
+                // Regardless of success or failure of the request trigger the Complete
+                // request handlers.
+                r.Handlers.Complete.Run(r)
+        }()
+
+        for {
+                if aws.BoolValue(r.Retryable) {
+                        if r.Config.LogLevel.Matches(aws.LogDebugWithRequestRetries) {
+                                r.Config.Logger.Log(fmt.Sprintf("DEBUG: Retrying Request %s/%s, attempt %d",
+                                        r.ClientInfo.ServiceName, r.Operation.Name, r.RetryCount))
+                        }
+
+                        // The previous http.Request will have a reference to the r.Body
+                        // and the HTTP Client's Transport may still be reading from
+                        // the request's body even though the Client's Do returned.
+                        r.HTTPRequest = copyHTTPRequest(r.HTTPRequest, nil)
+                        r.ResetBody()
+
+                        // Closing response body to ensure that no response body is leaked
+                        // between retry attempts.
+                        if r.HTTPResponse != nil && r.HTTPResponse.Body != nil {
+                                r.HTTPResponse.Body.Close()
+                        }
+                }
+
+                r.Sign()
+                if r.Error != nil {
+                        return r.Error
+                }
+
+                r.Retryable = nil
+
+                r.Handlers.Send.Run(r)
+                if r.Error != nil {
+                        if !shouldRetryCancel(r) {
+                                return r.Error
+                        }
+
+                        err := r.Error
+                        r.Handlers.Retry.Run(r)
+                        r.Handlers.AfterRetry.Run(r)
+                        if r.Error != nil {
+                                debugLogReqError(r, "Send Request", false, r.Error)
+                                return r.Error
+                        }
+                        debugLogReqError(r, "Send Request", true, err)
+                        continue
+                }
+                r.Handlers.UnmarshalMeta.Run(r)
+                r.Handlers.ValidateResponse.Run(r)
+                if r.Error != nil {
+                        err := r.Error
+                        r.Handlers.UnmarshalError.Run(r)
+                        r.Handlers.Retry.Run(r)
+                        r.Handlers.AfterRetry.Run(r)
+                        if r.Error != nil {
+                                debugLogReqError(r, "Validate Response", false, r.Error)
+                                return r.Error
+                        }
+                        debugLogReqError(r, "Validate Response", true, err)
+                        continue
+                }
+
+                r.Handlers.Unmarshal.Run(r)
+                if r.Error != nil {
+                        err := r.Error
+                        r.Handlers.Retry.Run(r)
+                        r.Handlers.AfterRetry.Run(r)
+                        if r.Error != nil {
+                                debugLogReqError(r, "Unmarshal Response", false, r.Error)
+                                return r.Error
+                        }
+                        debugLogReqError(r, "Unmarshal Response", true, err)
+                        continue
+                }
+
+                break
+        }
+
+        return nil
+}
+
+// copy will copy a request which will allow for local manipulation of the
+// request.
+func (r *Request) copy() *Request {
+        req := &Request{}
+        *req = *r
+        req.Handlers = r.Handlers.Copy()
+        op := *r.Operation
+        req.Operation = &op
+        return req
+}
+
+// AddToUserAgent adds the string to the end of the request's current user agent.
+func AddToUserAgent(r *Request, s string) {
+        curUA := r.HTTPRequest.Header.Get("User-Agent")
+        if len(curUA) > 0 {
+                s = curUA + " " + s
+        }
+        r.HTTPRequest.Header.Set("User-Agent", s)
+}
+
+func shouldRetryCancel(r *Request) bool {
+        awsErr, ok := r.Error.(awserr.Error)
+        timeoutErr := false
+        errStr := r.Error.Error()
+        if ok {
+                if awsErr.Code() == CanceledErrorCode {
+                        return false
+                }
+                err := awsErr.OrigErr()
+                netErr, netOK := err.(net.Error)
+                timeoutErr = netOK && netErr.Temporary()
+                if urlErr, ok := err.(*url.Error); !timeoutErr && ok {
+                        errStr = urlErr.Err.Error()
+                }
+        }
+
+        // There can be two types of canceled errors here.
+        // The first being a net.Error and the other being an error.
+        // If the request was timed out, we want to continue the retry
+        // process. Otherwise, return the canceled error.
+        return timeoutErr ||
+                (errStr != "net/http: request canceled" &&
+                        errStr != "net/http: request canceled while waiting for connection")
+
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/request_1_7.go b/vendor/github.com/aws/aws-sdk-go/aws/request/request_1_7.go
new file mode 100644
index 0000000..1323af9
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/request_1_7.go
@@ -0,0 +1,21 @@
+// +build !go1.8
+
+package request
+
+import "io"
+
+// NoBody is an io.ReadCloser with no bytes. Read always returns EOF
+// and Close always returns nil. It can be used in an outgoing client
+// request to explicitly signal that a request has zero bytes.
+// An alternative, however, is to simply set Request.Body to nil.
+//
+// Copy of Go 1.8 NoBody type from net/http/http.go
+type noBody struct{}
+
+func (noBody) Read([]byte) (int, error)         { return 0, io.EOF }
+func (noBody) Close() error                     { return nil }
+func (noBody) WriteTo(io.Writer) (int64, error) { return 0, nil }
+
+// Is an empty reader that will trigger the Go HTTP client to not include
+// and body in the HTTP request.
+var noBodyReader = noBody{}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/request_1_8.go b/vendor/github.com/aws/aws-sdk-go/aws/request/request_1_8.go
new file mode 100644
index 0000000..8b963f4
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/request_1_8.go
@@ -0,0 +1,9 @@
+// +build go1.8
+
+package request
+
+import "net/http"
+
+// Is a http.NoBody reader instructing Go HTTP client to not include
+// and body in the HTTP request.
+var noBodyReader = http.NoBody
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/request_context.go b/vendor/github.com/aws/aws-sdk-go/aws/request/request_context.go
new file mode 100644
index 0000000..a7365cd
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/request_context.go
@@ -0,0 +1,14 @@
+// +build go1.7
+
+package request
+
+import "github.com/aws/aws-sdk-go/aws"
+
+// setContext updates the Request to use the passed in context for cancellation.
+// Context will also be used for request retry delay.
+//
+// Creates shallow copy of the http.Request with the WithContext method.
+func setRequestContext(r *Request, ctx aws.Context) {
+        r.context = ctx
+        r.HTTPRequest = r.HTTPRequest.WithContext(ctx)
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/request_context_1_6.go b/vendor/github.com/aws/aws-sdk-go/aws/request/request_context_1_6.go
new file mode 100644
index 0000000..307fa07
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/request_context_1_6.go
@@ -0,0 +1,14 @@
+// +build !go1.7
+
+package request
+
+import "github.com/aws/aws-sdk-go/aws"
+
+// setContext updates the Request to use the passed in context for cancellation.
+// Context will also be used for request retry delay.
+//
+// Creates shallow copy of the http.Request with the WithContext method.
+func setRequestContext(r *Request, ctx aws.Context) {
+        r.context = ctx
+        r.HTTPRequest.Cancel = ctx.Done()
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/request_pagination.go b/vendor/github.com/aws/aws-sdk-go/aws/request/request_pagination.go
new file mode 100644
index 0000000..59de673
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/request_pagination.go
@@ -0,0 +1,236 @@
+package request
+
+import (
+        "reflect"
+        "sync/atomic"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/awsutil"
+)
+
+// A Pagination provides paginating of SDK API operations which are paginatable.
+// Generally you should not use this type directly, but use the "Pages" API
+// operations method to automatically perform pagination for you. Such as,
+// "S3.ListObjectsPages", and "S3.ListObjectsPagesWithContext" methods.
+//
+// Pagination differs from a Paginator type in that pagination is the type that
+// does the pagination between API operations, and Paginator defines the
+// configuration that will be used per page request.
+//
+//     cont := true
+//     for p.Next() && cont {
+//         data := p.Page().(*s3.ListObjectsOutput)
+//         // process the page's data
+//     }
+//     return p.Err()
+//
+// See service client API operation Pages methods for examples how the SDK will
+// use the Pagination type.
+type Pagination struct {
+        // Function to return a Request value for each pagination request.
+        // Any configuration or handlers that need to be applied to the request
+        // prior to getting the next page should be done here before the request
+        // returned.
+        //
+        // NewRequest should always be built from the same API operations. It is
+        // undefined if different API operations are returned on subsequent calls.
+        NewRequest func() (*Request, error)
+
+        started    bool
+        nextTokens []interface{}
+
+        err     error
+        curPage interface{}
+}
+
+// HasNextPage will return true if Pagination is able to determine that the API
+// operation has additional pages. False will be returned if there are no more
+// pages remaining.
+//
+// Will always return true if Next has not been called yet.
+func (p *Pagination) HasNextPage() bool {
+        return !(p.started && len(p.nextTokens) == 0)
+}
+
+// Err returns the error Pagination encountered when retrieving the next page.
+func (p *Pagination) Err() error {
+        return p.err
+}
+
+// Page returns the current page. Page should only be called after a successful
+// call to Next. It is undefined what Page will return if Page is called after
+// Next returns false.
+func (p *Pagination) Page() interface{} {
+        return p.curPage
+}
+
+// Next will attempt to retrieve the next page for the API operation. When a page
+// is retrieved true will be returned. If the page cannot be retrieved, or there
+// are no more pages false will be returned.
+//
+// Use the Page method to retrieve the current page data. The data will need
+// to be cast to the API operation's output type.
+//
+// Use the Err method to determine if an error occurred if Page returns false.
+func (p *Pagination) Next() bool {
+        if !p.HasNextPage() {
+                return false
+        }
+
+        req, err := p.NewRequest()
+        if err != nil {
+                p.err = err
+                return false
+        }
+
+        if p.started {
+                for i, intok := range req.Operation.InputTokens {
+                        awsutil.SetValueAtPath(req.Params, intok, p.nextTokens[i])
+                }
+        }
+        p.started = true
+
+        err = req.Send()
+        if err != nil {
+                p.err = err
+                return false
+        }
+
+        p.nextTokens = req.nextPageTokens()
+        p.curPage = req.Data
+
+        return true
+}
+
+// A Paginator is the configuration data that defines how an API operation
+// should be paginated. This type is used by the API service models to define
+// the generated pagination config for service APIs.
+//
+// The Pagination type is what provides iterating between pages of an API. It
+// is only used to store the token metadata the SDK should use for performing
+// pagination.
+type Paginator struct {
+        InputTokens     []string
+        OutputTokens    []string
+        LimitToken      string
+        TruncationToken string
+}
+
+// nextPageTokens returns the tokens to use when asking for the next page of data.
+func (r *Request) nextPageTokens() []interface{} {
+        if r.Operation.Paginator == nil {
+                return nil
+        }
+        if r.Operation.TruncationToken != "" {
+                tr, _ := awsutil.ValuesAtPath(r.Data, r.Operation.TruncationToken)
+                if len(tr) == 0 {
+                        return nil
+                }
+
+                switch v := tr[0].(type) {
+                case *bool:
+                        if !aws.BoolValue(v) {
+                                return nil
+                        }
+                case bool:
+                        if v == false {
+                                return nil
+                        }
+                }
+        }
+
+        tokens := []interface{}{}
+        tokenAdded := false
+        for _, outToken := range r.Operation.OutputTokens {
+                v, _ := awsutil.ValuesAtPath(r.Data, outToken)
+                if len(v) > 0 {
+                        tokens = append(tokens, v[0])
+                        tokenAdded = true
+                } else {
+                        tokens = append(tokens, nil)
+                }
+        }
+        if !tokenAdded {
+                return nil
+        }
+
+        return tokens
+}
+
+// Ensure a deprecated item is only logged once instead of each time its used.
+func logDeprecatedf(logger aws.Logger, flag *int32, msg string) {
+        if logger == nil {
+                return
+        }
+        if atomic.CompareAndSwapInt32(flag, 0, 1) {
+                logger.Log(msg)
+        }
+}
+
+var (
+        logDeprecatedHasNextPage int32
+        logDeprecatedNextPage    int32
+        logDeprecatedEachPage    int32
+)
+
+// HasNextPage returns true if this request has more pages of data available.
+//
+// Deprecated Use Pagination type for configurable pagination of API operations
+func (r *Request) HasNextPage() bool {
+        logDeprecatedf(r.Config.Logger, &logDeprecatedHasNextPage,
+                "Request.HasNextPage deprecated. Use Pagination type for configurable pagination of API operations")
+
+        return len(r.nextPageTokens()) > 0
+}
+
+// NextPage returns a new Request that can be executed to return the next
+// page of result data. Call .Send() on this request to execute it.
+//
+// Deprecated Use Pagination type for configurable pagination of API operations
+func (r *Request) NextPage() *Request {
+        logDeprecatedf(r.Config.Logger, &logDeprecatedNextPage,
+                "Request.NextPage deprecated. Use Pagination type for configurable pagination of API operations")
+
+        tokens := r.nextPageTokens()
+        if len(tokens) == 0 {
+                return nil
+        }
+
+        data := reflect.New(reflect.TypeOf(r.Data).Elem()).Interface()
+        nr := New(r.Config, r.ClientInfo, r.Handlers, r.Retryer, r.Operation, awsutil.CopyOf(r.Params), data)
+        for i, intok := range nr.Operation.InputTokens {
+                awsutil.SetValueAtPath(nr.Params, intok, tokens[i])
+        }
+        return nr
+}
+
+// EachPage iterates over each page of a paginated request object. The fn
+// parameter should be a function with the following sample signature:
+//
+//   func(page *T, lastPage bool) bool {
+//       return true // return false to stop iterating
+//   }
+//
+// Where "T" is the structure type matching the output structure of the given
+// operation. For example, a request object generated by
+// DynamoDB.ListTablesRequest() would expect to see dynamodb.ListTablesOutput
+// as the structure "T". The lastPage value represents whether the page is
+// the last page of data or not. The return value of this function should
+// return true to keep iterating or false to stop.
+//
+// Deprecated Use Pagination type for configurable pagination of API operations
+func (r *Request) EachPage(fn func(data interface{}, isLastPage bool) (shouldContinue bool)) error {
+        logDeprecatedf(r.Config.Logger, &logDeprecatedEachPage,
+                "Request.EachPage deprecated. Use Pagination type for configurable pagination of API operations")
+
+        for page := r; page != nil; page = page.NextPage() {
+                if err := page.Send(); err != nil {
+                        return err
+                }
+                if getNextPage := fn(page.Data, !page.HasNextPage()); !getNextPage {
+                        return page.Error
+                }
+        }
+
+        return nil
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/retryer.go b/vendor/github.com/aws/aws-sdk-go/aws/request/retryer.go
new file mode 100644
index 0000000..7af81de
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/retryer.go
@@ -0,0 +1,154 @@
+package request
+
+import (
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/awserr"
+)
+
+// Retryer is an interface to control retry logic for a given service.
+// The default implementation used by most services is the service.DefaultRetryer
+// structure, which contains basic retry logic using exponential backoff.
+type Retryer interface {
+        RetryRules(*Request) time.Duration
+        ShouldRetry(*Request) bool
+        MaxRetries() int
+}
+
+// WithRetryer sets a config Retryer value to the given Config returning it
+// for chaining.
+func WithRetryer(cfg *aws.Config, retryer Retryer) *aws.Config {
+        cfg.Retryer = retryer
+        return cfg
+}
+
+// retryableCodes is a collection of service response codes which are retry-able
+// without any further action.
+var retryableCodes = map[string]struct{}{
+        "RequestError":            {},
+        "RequestTimeout":          {},
+        ErrCodeResponseTimeout:    {},
+        "RequestTimeoutException": {}, // Glacier's flavor of RequestTimeout
+}
+
+var throttleCodes = map[string]struct{}{
+        "ProvisionedThroughputExceededException": {},
+        "Throttling":                             {},
+        "ThrottlingException":                    {},
+        "RequestLimitExceeded":                   {},
+        "RequestThrottled":                       {},
+        "LimitExceededException":                 {}, // Deleting 10+ DynamoDb tables at once
+        "TooManyRequestsException":               {}, // Lambda functions
+        "PriorRequestNotComplete":                {}, // Route53
+}
+
+// credsExpiredCodes is a collection of error codes which signify the credentials
+// need to be refreshed. Expired tokens require refreshing of credentials, and
+// resigning before the request can be retried.
+var credsExpiredCodes = map[string]struct{}{
+        "ExpiredToken":          {},
+        "ExpiredTokenException": {},
+        "RequestExpired":        {}, // EC2 Only
+}
+
+func isCodeThrottle(code string) bool {
+        _, ok := throttleCodes[code]
+        return ok
+}
+
+func isCodeRetryable(code string) bool {
+        if _, ok := retryableCodes[code]; ok {
+                return true
+        }
+
+        return isCodeExpiredCreds(code)
+}
+
+func isCodeExpiredCreds(code string) bool {
+        _, ok := credsExpiredCodes[code]
+        return ok
+}
+
+var validParentCodes = map[string]struct{}{
+        ErrCodeSerialization: struct{}{},
+        ErrCodeRead:          struct{}{},
+}
+
+func isNestedErrorRetryable(parentErr awserr.Error) bool {
+        if parentErr == nil {
+                return false
+        }
+
+        if _, ok := validParentCodes[parentErr.Code()]; !ok {
+                return false
+        }
+
+        err := parentErr.OrigErr()
+        if err == nil {
+                return false
+        }
+
+        if aerr, ok := err.(awserr.Error); ok {
+                return isCodeRetryable(aerr.Code())
+        }
+
+        return isErrConnectionReset(err)
+}
+
+// IsErrorRetryable returns whether the error is retryable, based on its Code.
+// Returns false if error is nil.
+func IsErrorRetryable(err error) bool {
+        if err != nil {
+                if aerr, ok := err.(awserr.Error); ok {
+                        return isCodeRetryable(aerr.Code()) || isNestedErrorRetryable(aerr)
+                }
+        }
+        return false
+}
+
+// IsErrorThrottle returns whether the error is to be throttled based on its code.
+// Returns false if error is nil.
+func IsErrorThrottle(err error) bool {
+        if err != nil {
+                if aerr, ok := err.(awserr.Error); ok {
+                        return isCodeThrottle(aerr.Code())
+                }
+        }
+        return false
+}
+
+// IsErrorExpiredCreds returns whether the error code is a credential expiry error.
+// Returns false if error is nil.
+func IsErrorExpiredCreds(err error) bool {
+        if err != nil {
+                if aerr, ok := err.(awserr.Error); ok {
+                        return isCodeExpiredCreds(aerr.Code())
+                }
+        }
+        return false
+}
+
+// IsErrorRetryable returns whether the error is retryable, based on its Code.
+// Returns false if the request has no Error set.
+//
+// Alias for the utility function IsErrorRetryable
+func (r *Request) IsErrorRetryable() bool {
+        return IsErrorRetryable(r.Error)
+}
+
+// IsErrorThrottle returns whether the error is to be throttled based on its code.
+// Returns false if the request has no Error set
+//
+// Alias for the utility function IsErrorThrottle
+func (r *Request) IsErrorThrottle() bool {
+        return IsErrorThrottle(r.Error)
+}
+
+// IsErrorExpired returns whether the error code is a credential expiry error.
+// Returns false if the request has no Error set.
+//
+// Alias for the utility function IsErrorExpiredCreds
+func (r *Request) IsErrorExpired() bool {
+        return IsErrorExpiredCreds(r.Error)
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/timeout_read_closer.go b/vendor/github.com/aws/aws-sdk-go/aws/request/timeout_read_closer.go
new file mode 100644
index 0000000..09a44eb
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/timeout_read_closer.go
@@ -0,0 +1,94 @@
+package request
+
+import (
+        "io"
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws/awserr"
+)
+
+var timeoutErr = awserr.New(
+        ErrCodeResponseTimeout,
+        "read on body has reached the timeout limit",
+        nil,
+)
+
+type readResult struct {
+        n   int
+        err error
+}
+
+// timeoutReadCloser will handle body reads that take too long.
+// We will return a ErrReadTimeout error if a timeout occurs.
+type timeoutReadCloser struct {
+        reader   io.ReadCloser
+        duration time.Duration
+}
+
+// Read will spin off a goroutine to call the reader's Read method. We will
+// select on the timer's channel or the read's channel. Whoever completes first
+// will be returned.
+func (r *timeoutReadCloser) Read(b []byte) (int, error) {
+        timer := time.NewTimer(r.duration)
+        c := make(chan readResult, 1)
+
+        go func() {
+                n, err := r.reader.Read(b)
+                timer.Stop()
+                c <- readResult{n: n, err: err}
+        }()
+
+        select {
+        case data := <-c:
+                return data.n, data.err
+        case <-timer.C:
+                return 0, timeoutErr
+        }
+}
+
+func (r *timeoutReadCloser) Close() error {
+        return r.reader.Close()
+}
+
+const (
+        // HandlerResponseTimeout is what we use to signify the name of the
+        // response timeout handler.
+        HandlerResponseTimeout = "ResponseTimeoutHandler"
+)
+
+// adaptToResponseTimeoutError is a handler that will replace any top level error
+// to a ErrCodeResponseTimeout, if its child is that.
+func adaptToResponseTimeoutError(req *Request) {
+        if err, ok := req.Error.(awserr.Error); ok {
+                aerr, ok := err.OrigErr().(awserr.Error)
+                if ok && aerr.Code() == ErrCodeResponseTimeout {
+                        req.Error = aerr
+                }
+        }
+}
+
+// WithResponseReadTimeout is a request option that will wrap the body in a timeout read closer.
+// This will allow for per read timeouts. If a timeout occurred, we will return the
+// ErrCodeResponseTimeout.
+//
+//     svc.PutObjectWithContext(ctx, params, request.WithTimeoutReadCloser(30 * time.Second)
+func WithResponseReadTimeout(duration time.Duration) Option {
+        return func(r *Request) {
+
+                var timeoutHandler = NamedHandler{
+                        HandlerResponseTimeout,
+                        func(req *Request) {
+                                req.HTTPResponse.Body = &timeoutReadCloser{
+                                        reader:   req.HTTPResponse.Body,
+                                        duration: duration,
+                                }
+                        }}
+
+                // remove the handler so we are not stomping over any new durations.
+                r.Handlers.Send.RemoveByName(HandlerResponseTimeout)
+                r.Handlers.Send.PushBackNamed(timeoutHandler)
+
+                r.Handlers.Unmarshal.PushBack(adaptToResponseTimeoutError)
+                r.Handlers.UnmarshalError.PushBack(adaptToResponseTimeoutError)
+        }
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/validation.go b/vendor/github.com/aws/aws-sdk-go/aws/request/validation.go
new file mode 100644
index 0000000..2520286
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/validation.go
@@ -0,0 +1,234 @@
+package request
+
+import (
+        "bytes"
+        "fmt"
+
+        "github.com/aws/aws-sdk-go/aws/awserr"
+)
+
+const (
+        // InvalidParameterErrCode is the error code for invalid parameters errors
+        InvalidParameterErrCode = "InvalidParameter"
+        // ParamRequiredErrCode is the error code for required parameter errors
+        ParamRequiredErrCode = "ParamRequiredError"
+        // ParamMinValueErrCode is the error code for fields with too low of a
+        // number value.
+        ParamMinValueErrCode = "ParamMinValueError"
+        // ParamMinLenErrCode is the error code for fields without enough elements.
+        ParamMinLenErrCode = "ParamMinLenError"
+)
+
+// Validator provides a way for types to perform validation logic on their
+// input values that external code can use to determine if a type's values
+// are valid.
+type Validator interface {
+        Validate() error
+}
+
+// An ErrInvalidParams provides wrapping of invalid parameter errors found when
+// validating API operation input parameters.
+type ErrInvalidParams struct {
+        // Context is the base context of the invalid parameter group.
+        Context string
+        errs    []ErrInvalidParam
+}
+
+// Add adds a new invalid parameter error to the collection of invalid
+// parameters. The context of the invalid parameter will be updated to reflect
+// this collection.
+func (e *ErrInvalidParams) Add(err ErrInvalidParam) {
+        err.SetContext(e.Context)
+        e.errs = append(e.errs, err)
+}
+
+// AddNested adds the invalid parameter errors from another ErrInvalidParams
+// value into this collection. The nested errors will have their nested context
+// updated and base context to reflect the merging.
+//
+// Use for nested validations errors.
+func (e *ErrInvalidParams) AddNested(nestedCtx string, nested ErrInvalidParams) {
+        for _, err := range nested.errs {
+                err.SetContext(e.Context)
+                err.AddNestedContext(nestedCtx)
+                e.errs = append(e.errs, err)
+        }
+}
+
+// Len returns the number of invalid parameter errors
+func (e ErrInvalidParams) Len() int {
+        return len(e.errs)
+}
+
+// Code returns the code of the error
+func (e ErrInvalidParams) Code() string {
+        return InvalidParameterErrCode
+}
+
+// Message returns the message of the error
+func (e ErrInvalidParams) Message() string {
+        return fmt.Sprintf("%d validation error(s) found.", len(e.errs))
+}
+
+// Error returns the string formatted form of the invalid parameters.
+func (e ErrInvalidParams) Error() string {
+        w := &bytes.Buffer{}
+        fmt.Fprintf(w, "%s: %s\n", e.Code(), e.Message())
+
+        for _, err := range e.errs {
+                fmt.Fprintf(w, "- %s\n", err.Message())
+        }
+
+        return w.String()
+}
+
+// OrigErr returns the invalid parameters as a awserr.BatchedErrors value
+func (e ErrInvalidParams) OrigErr() error {
+        return awserr.NewBatchError(
+                InvalidParameterErrCode, e.Message(), e.OrigErrs())
+}
+
+// OrigErrs returns a slice of the invalid parameters
+func (e ErrInvalidParams) OrigErrs() []error {
+        errs := make([]error, len(e.errs))
+        for i := 0; i < len(errs); i++ {
+                errs[i] = e.errs[i]
+        }
+
+        return errs
+}
+
+// An ErrInvalidParam represents an invalid parameter error type.
+type ErrInvalidParam interface {
+        awserr.Error
+
+        // Field name the error occurred on.
+        Field() string
+
+        // SetContext updates the context of the error.
+        SetContext(string)
+
+        // AddNestedContext updates the error's context to include a nested level.
+        AddNestedContext(string)
+}
+
+type errInvalidParam struct {
+        context       string
+        nestedContext string
+        field         string
+        code          string
+        msg           string
+}
+
+// Code returns the error code for the type of invalid parameter.
+func (e *errInvalidParam) Code() string {
+        return e.code
+}
+
+// Message returns the reason the parameter was invalid, and its context.
+func (e *errInvalidParam) Message() string {
+        return fmt.Sprintf("%s, %s.", e.msg, e.Field())
+}
+
+// Error returns the string version of the invalid parameter error.
+func (e *errInvalidParam) Error() string {
+        return fmt.Sprintf("%s: %s", e.code, e.Message())
+}
+
+// OrigErr returns nil, Implemented for awserr.Error interface.
+func (e *errInvalidParam) OrigErr() error {
+        return nil
+}
+
+// Field Returns the field and context the error occurred.
+func (e *errInvalidParam) Field() string {
+        field := e.context
+        if len(field) > 0 {
+                field += "."
+        }
+        if len(e.nestedContext) > 0 {
+                field += fmt.Sprintf("%s.", e.nestedContext)
+        }
+        field += e.field
+
+        return field
+}
+
+// SetContext updates the base context of the error.
+func (e *errInvalidParam) SetContext(ctx string) {
+        e.context = ctx
+}
+
+// AddNestedContext prepends a context to the field's path.
+func (e *errInvalidParam) AddNestedContext(ctx string) {
+        if len(e.nestedContext) == 0 {
+                e.nestedContext = ctx
+        } else {
+                e.nestedContext = fmt.Sprintf("%s.%s", ctx, e.nestedContext)
+        }
+
+}
+
+// An ErrParamRequired represents an required parameter error.
+type ErrParamRequired struct {
+        errInvalidParam
+}
+
+// NewErrParamRequired creates a new required parameter error.
+func NewErrParamRequired(field string) *ErrParamRequired {
+        return &ErrParamRequired{
+                errInvalidParam{
+                        code:  ParamRequiredErrCode,
+                        field: field,
+                        msg:   fmt.Sprintf("missing required field"),
+                },
+        }
+}
+
+// An ErrParamMinValue represents a minimum value parameter error.
+type ErrParamMinValue struct {
+        errInvalidParam
+        min float64
+}
+
+// NewErrParamMinValue creates a new minimum value parameter error.
+func NewErrParamMinValue(field string, min float64) *ErrParamMinValue {
+        return &ErrParamMinValue{
+                errInvalidParam: errInvalidParam{
+                        code:  ParamMinValueErrCode,
+                        field: field,
+                        msg:   fmt.Sprintf("minimum field value of %v", min),
+                },
+                min: min,
+        }
+}
+
+// MinValue returns the field's require minimum value.
+//
+// float64 is returned for both int and float min values.
+func (e *ErrParamMinValue) MinValue() float64 {
+        return e.min
+}
+
+// An ErrParamMinLen represents a minimum length parameter error.
+type ErrParamMinLen struct {
+        errInvalidParam
+        min int
+}
+
+// NewErrParamMinLen creates a new minimum length parameter error.
+func NewErrParamMinLen(field string, min int) *ErrParamMinLen {
+        return &ErrParamMinLen{
+                errInvalidParam: errInvalidParam{
+                        code:  ParamMinValueErrCode,
+                        field: field,
+                        msg:   fmt.Sprintf("minimum field size of %v", min),
+                },
+                min: min,
+        }
+}
+
+// MinLen returns the field's required minimum length.
+func (e *ErrParamMinLen) MinLen() int {
+        return e.min
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/waiter.go b/vendor/github.com/aws/aws-sdk-go/aws/request/waiter.go
new file mode 100644
index 0000000..22d2f80
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/aws/request/waiter.go
@@ -0,0 +1,287 @@
+package request
+
+import (
+        "fmt"
+        "time"
+
+        "github.com/aws/aws-sdk-go/aws"
+        "github.com/aws/aws-sdk-go/aws/awserr"
+        "github.com/aws/aws-sdk-go/aws/awsutil"
+)
+
+// WaiterResourceNotReadyErrorCode is the error code returned by a waiter when
+// the waiter's max attempts have been exhausted.
+const WaiterResourceNotReadyErrorCode = "ResourceNotReady"
+
+// A WaiterOption is a function that will update the Waiter value's fields to
+// configure the waiter.
+type WaiterOption func(*Waiter)
+
+// WithWaiterMaxAttempts returns the maximum number of times the waiter should
+// attempt to check the resource for the target state.
+func WithWaiterMaxAttempts(max int) WaiterOption {
+        return func(w *Waiter) {
+                w.MaxAttempts = max
+        }
+}
+
+// WaiterDelay will return a delay the waiter should pause between attempts to
+// check the resource state. The passed in attempt is the number of times the
+// Waiter has checked the resource state.
+//
+// Attempt is the number of attempts the Waiter has made checking the resource
+// state.
+type WaiterDelay func(attempt int) time.Duration
+
+// ConstantWaiterDelay returns a WaiterDelay that will always return a constant
+// delay the waiter should use between attempts. It ignores the number of
+// attempts made.
+func ConstantWaiterDelay(delay time.Duration) WaiterDelay {
+        return func(attempt int) time.Duration {
+                return delay
+        }
+}
+
+// WithWaiterDelay will set the Waiter to use the WaiterDelay passed in.
+func WithWaiterDelay(delayer WaiterDelay) WaiterOption {
+        return func(w *Waiter) {
+                w.Delay = delayer
+        }
+}
+
+// WithWaiterLogger returns a waiter option to set the logger a waiter
+// should use to log warnings and errors to.
+func WithWaiterLogger(logger aws.Logger) WaiterOption {
+        return func(w *Waiter) {
+                w.Logger = logger
+        }
+}
+
+// WithWaiterRequestOptions returns a waiter option setting the request
+// options for each request the waiter makes. Appends to waiter's request
+// options already set.
+func WithWaiterRequestOptions(opts ...Option) WaiterOption {
+        return func(w *Waiter) {
+                w.RequestOptions = append(w.RequestOptions, opts...)
+        }
+}
+
+// A Waiter provides the functionality to perform a blocking call which will
+// wait for a resource state to be satisfied by a service.
+//
+// This type should not be used directly. The API operations provided in the
+// service packages prefixed with "WaitUntil" should be used instead.
+type Waiter struct {
+        Name      string
+        Acceptors []WaiterAcceptor
+        Logger    aws.Logger
+
+        MaxAttempts int
+        Delay       WaiterDelay
+
+        RequestOptions []Option
+        NewRequest     func([]Option) (*Request, error)
+}
+
+// ApplyOptions updates the waiter with the list of waiter options provided.
+func (w *Waiter) ApplyOptions(opts ...WaiterOption) {
+        for _, fn := range opts {
+                fn(w)
+        }
+}
+
+// WaiterState are states the waiter uses based on WaiterAcceptor definitions
+// to identify if the resource state the waiter is waiting on has occurred.
+type WaiterState int
+
+// String returns the string representation of the waiter state.
+func (s WaiterState) String() string {
+        switch s {
+        case SuccessWaiterState:
+                return "success"
+        case FailureWaiterState:
+                return "failure"
+        case RetryWaiterState:
+                return "retry"
+        default:
+                return "unknown waiter state"
+        }
+}
+
+// States the waiter acceptors will use to identify target resource states.
+const (
+        SuccessWaiterState WaiterState = iota // waiter successful
+        FailureWaiterState                    // waiter failed
+        RetryWaiterState                      // waiter needs to be retried
+)
+
+// WaiterMatchMode is the mode that the waiter will use to match the WaiterAcceptor
+// definition's Expected attribute.
+type WaiterMatchMode int
+
+// Modes the waiter will use when inspecting API response to identify target
+// resource states.
+const (
+        PathAllWaiterMatch  WaiterMatchMode = iota // match on all paths
+        PathWaiterMatch                            // match on specific path
+        PathAnyWaiterMatch                         // match on any path
+        PathListWaiterMatch                        // match on list of paths
+        StatusWaiterMatch                          // match on status code
+        ErrorWaiterMatch                           // match on error
+)
+
+// String returns the string representation of the waiter match mode.
+func (m WaiterMatchMode) String() string {
+        switch m {
+        case PathAllWaiterMatch:
+                return "pathAll"
+        case PathWaiterMatch:
+                return "path"
+        case PathAnyWaiterMatch:
+                return "pathAny"
+        case PathListWaiterMatch:
+                return "pathList"
+        case StatusWaiterMatch:
+                return "status"
+        case ErrorWaiterMatch:
+                return "error"
+        default:
+                return "unknown waiter match mode"
+        }
+}
+
+// WaitWithContext will make requests for the API operation using NewRequest to
+// build API requests. The request's response will be compared against the
+// Waiter's Acceptors to determine the successful state of the resource the
+// waiter is inspecting.
+//
+// The passed in context must not be nil. If it is nil a panic will occur. The
+// Context will be used to cancel the waiter's pending requests and retry delays.
+// Use aws.BackgroundContext if no context is available.
+//
+// The waiter will continue until the target state defined by the Acceptors,
+// or the max attempts expires.
+//
+// Will return the WaiterResourceNotReadyErrorCode error code if the waiter's
+// retryer ShouldRetry returns false. This normally will happen when the max
+// wait attempts expires.
+func (w Waiter) WaitWithContext(ctx aws.Context) error {
+
+        for attempt := 1; ; attempt++ {
+                req, err := w.NewRequest(w.RequestOptions)
+                if err != nil {
+                        waiterLogf(w.Logger, "unable to create request %v", err)
+                        return err
+                }
+                req.Handlers.Build.PushBack(MakeAddToUserAgentFreeFormHandler("Waiter"))
+                err = req.Send()
+
+                // See if any of the acceptors match the request's response, or error
+                for _, a := range w.Acceptors {
+                        if matched, matchErr := a.match(w.Name, w.Logger, req, err); matched {
+                                return matchErr
+                        }
+                }
+
+                // The Waiter should only check the resource state MaxAttempts times
+                // This is here instead of in the for loop above to prevent delaying
+                // unnecessary when the waiter will not retry.
+                if attempt == w.MaxAttempts {
+                        break
+                }
+
+                // Delay to wait before inspecting the resource again
+                delay := w.Delay(attempt)
+                if sleepFn := req.Config.SleepDelay; sleepFn != nil {
+                        // Support SleepDelay for backwards compatibility and testing
+                        sleepFn(delay)
+                } else if err := aws.SleepWithContext(ctx, delay); err != nil {
+                        return awserr.New(CanceledErrorCode, "waiter context canceled", err)
+                }
+        }
+
+        return awserr.New(WaiterResourceNotReadyErrorCode, "exceeded wait attempts", nil)
+}
+
+// A WaiterAcceptor provides the information needed to wait for an API operation
+// to complete.
+type WaiterAcceptor struct {
+        State    WaiterState
+        Matcher  WaiterMatchMode
+        Argument string
+        Expected interface{}
+}
+
+// match returns if the acceptor found a match with the passed in request
+// or error. True is returned if the acceptor made a match, error is returned
+// if there was an error attempting to perform the match.
+func (a *WaiterAcceptor) match(name string, l aws.Logger, req *Request, err error) (bool, error) {
+        result := false
+        var vals []interface{}
+
+        switch a.Matcher {
+        case PathAllWaiterMatch, PathWaiterMatch:
+                // Require all matches to be equal for result to match
+                vals, _ = awsutil.ValuesAtPath(req.Data, a.Argument)
+                if len(vals) == 0 {
+                        break
+                }
+                result = true
+                for _, val := range vals {
+                        if !awsutil.DeepEqual(val, a.Expected) {
+                                result = false
+                                break
+                        }
+                }
+        case PathAnyWaiterMatch:
+                // Only a single match needs to equal for the result to match
+                vals, _ = awsutil.ValuesAtPath(req.Data, a.Argument)
+                for _, val := range vals {
+                        if awsutil.DeepEqual(val, a.Expected) {
+                                result = true
+                                break
+                        }
+                }
+        case PathListWaiterMatch:
+                // ignored matcher
+        case StatusWaiterMatch:
+                s := a.Expected.(int)
+                result = s == req.HTTPResponse.StatusCode
+        case ErrorWaiterMatch:
+                if aerr, ok := err.(awserr.Error); ok {
+                        result = aerr.Code() == a.Expected.(string)
+                }
+        default:
+                waiterLogf(l, "WARNING: Waiter %s encountered unexpected matcher: %s",
+                        name, a.Matcher)
+        }
+
+        if !result {
+                // If there was no matching result found there is nothing more to do
+                // for this response, retry the request.
+                return false, nil
+        }
+
+        switch a.State {
+        case SuccessWaiterState:
+                // waiter completed
+                return true, nil
+        case FailureWaiterState:
+                // Waiter failure state triggered
+                return true, awserr.New(WaiterResourceNotReadyErrorCode,
+                        "failed waiting for successful resource state", err)
+        case RetryWaiterState:
+                // clear the error and retry the operation
+                return false, nil
+        default:
+                waiterLogf(l, "WARNING: Waiter %s encountered unexpected state: %s",
+                        name, a.State)
+                return false, nil
+        }
+}
+
+func waiterLogf(logger aws.Logger, msg string, args ...interface{}) {
+        if logger != nil {
+                logger.Log(fmt.Sprintf(msg, args...))
+        }
+}