Documentation

Index

Constants

This section is empty.

Variables

View Source
var AfterRetryHandler = request.NamedHandler{Name: "core.AfterRetryHandler", Fn: func(r *request.Request) {

	if r.Retryable == nil || aws.BoolValue(r.Config.EnforceShouldRetryCheck) {
		r.Retryable = aws.Bool(r.ShouldRetry(r))
	}

	if r.WillRetry() {
		r.RetryDelay = r.RetryRules(r)

		if sleepFn := r.Config.SleepDelay; sleepFn != nil {

			sleepFn(r.RetryDelay)
		} else if err := aws.SleepWithContext(r.Context(), r.RetryDelay); err != nil {
			r.Error = awserr.New(request.CanceledErrorCode,
				"request context canceled", err)
			r.Retryable = aws.Bool(false)
			return
		}

		if r.IsErrorExpired() {
			r.Config.Credentials.Expire()
		}

		r.RetryCount++
		r.Error = nil
	}
}}

    AfterRetryHandler performs final checks to determine if the request should be retried and how long to delay.

    View Source
    var BuildContentLengthHandler = request.NamedHandler{Name: "core.BuildContentLengthHandler", Fn: func(r *request.Request) {
    	var length int64
    
    	if slength := r.HTTPRequest.Header.Get("Content-Length"); slength != "" {
    		length, _ = strconv.ParseInt(slength, 10, 64)
    	} else {
    		switch body := r.Body.(type) {
    		case nil:
    			length = 0
    		case lener:
    			length = int64(body.Len())
    		case io.Seeker:
    			r.BodyStart, _ = body.Seek(0, 1)
    			end, _ := body.Seek(0, 2)
    			body.Seek(r.BodyStart, 0)
    			length = end - r.BodyStart
    		default:
    			panic("Cannot get length of body, must provide `ContentLength`")
    		}
    	}
    
    	if length > 0 {
    		r.HTTPRequest.ContentLength = length
    		r.HTTPRequest.Header.Set("Content-Length", fmt.Sprintf("%d", length))
    	} else {
    		r.HTTPRequest.ContentLength = 0
    		r.HTTPRequest.Header.Del("Content-Length")
    	}
    }}

      BuildContentLengthHandler builds the content length of a request based on the body, or will use the HTTPRequest.Header's "Content-Length" if defined. If unable to determine request body length and no "Content-Length" was specified it will panic.

      The Content-Length will only be added to the request if the length of the body is greater than 0. If the body is empty or the current `Content-Length` header is <= 0, the header will also be stripped.

      View Source
      var SDKVersionUserAgentHandler = request.NamedHandler{
      	Name: "core.SDKVersionUserAgentHandler",
      	Fn: request.MakeAddToUserAgentHandler(aws.SDKName, aws.SDKVersion,
      		runtime.Version(), runtime.GOOS, runtime.GOARCH),
      }

        SDKVersionUserAgentHandler is a request handler for adding the SDK Version to the user agent.

        View Source
        var SendHandler = request.NamedHandler{
        	Name: "core.SendHandler",
        	Fn: func(r *request.Request) {
        		sender := sendFollowRedirects
        		if r.DisableFollowRedirects {
        			sender = sendWithoutFollowRedirects
        		}
        
        		if request.NoBody == r.HTTPRequest.Body {
        
        			reqOrig, reqCopy := r.HTTPRequest, *r.HTTPRequest
        			reqCopy.Body = nil
        			r.HTTPRequest = &reqCopy
        			defer func() {
        				r.HTTPRequest = reqOrig
        			}()
        		}
        
        		var err error
        		r.HTTPResponse, err = sender(r)
        		if err != nil {
        			handleSendError(r, err)
        		}
        	},
        }

          SendHandler is a request handler to send service request using HTTP client.

          View Source
          var ValidateEndpointHandler = request.NamedHandler{Name: "core.ValidateEndpointHandler", Fn: func(r *request.Request) {
          	if r.ClientInfo.SigningRegion == "" && aws.StringValue(r.Config.Region) == "" {
          		r.Error = aws.ErrMissingRegion
          	} else if r.ClientInfo.Endpoint == "" {
          		r.Error = aws.ErrMissingEndpoint
          	}
          }}

            ValidateEndpointHandler is a request handler to validate a request had the appropriate Region and Endpoint set. Will set r.Error if the endpoint or region is not valid.

            View Source
            var ValidateParametersHandler = request.NamedHandler{Name: "core.ValidateParametersHandler", Fn: func(r *request.Request) {
            	if !r.ParamsFilled() {
            		return
            	}
            
            	if v, ok := r.Params.(request.Validator); ok {
            		if err := v.Validate(); err != nil {
            			r.Error = err
            		}
            	}
            }}

              ValidateParametersHandler is a request handler to validate the input parameters. Validating parameters only has meaning if done prior to the request being sent.

              View Source
              var ValidateReqSigHandler = request.NamedHandler{
              	Name: "core.ValidateReqSigHandler",
              	Fn: func(r *request.Request) {
              
              		if r.Config.Credentials == credentials.AnonymousCredentials {
              			return
              		}
              
              		signedTime := r.Time
              		if !r.LastSignedAt.IsZero() {
              			signedTime = r.LastSignedAt
              		}
              
              		if signedTime.Add(10 * time.Minute).After(time.Now()) {
              			return
              		}
              
              		fmt.Println("request expired, resigning")
              		r.Sign()
              	},
              }

                ValidateReqSigHandler is a request handler to ensure that the request's signature doesn't expire before it is sent. This can happen when a request is built and signed significantly before it is sent. Or significant delays occur when retrying requests that would cause the signature to expire.

                View Source
                var ValidateResponseHandler = request.NamedHandler{Name: "core.ValidateResponseHandler", Fn: func(r *request.Request) {
                	if r.HTTPResponse.StatusCode == 0 || r.HTTPResponse.StatusCode >= 300 {
                
                		r.Error = awserr.New("UnknownError", "unknown error", nil)
                	}
                }}

                  ValidateResponseHandler is a request handler to validate service response.

                  Functions

                  This section is empty.

                  Types

                  This section is empty.