Merge branch 'fix_read_test' of github.com:alexandreFre/terraform-provider-statuscake

[github/fretlink/terraform-provider-statuscake.git] / vendor / github.com / aws / aws-sdk-go / aws / config.go

package aws

import (
        "net/http"
        "time"

        "github.com/aws/aws-sdk-go/aws/credentials"
        "github.com/aws/aws-sdk-go/aws/endpoints"
)

// UseServiceDefaultRetries instructs the config to use the service's own
// default number of retries. This will be the default action if
// Config.MaxRetries is nil also.
const UseServiceDefaultRetries = -1

// RequestRetryer is an alias for a type that implements the request.Retryer
// interface.
type RequestRetryer interface{}

// A Config provides service configuration for service clients. By default,
// all clients will use the defaults.DefaultConfig structure.
//
//     // Create Session with MaxRetry configuration to be shared by multiple
//     // service clients.
//     sess := session.Must(session.NewSession(&aws.Config{
//         MaxRetries: aws.Int(3),
//     }))
//
//     // Create S3 service client with a specific Region.
//     svc := s3.New(sess, &aws.Config{
//         Region: aws.String("us-west-2"),
//     })
type Config struct {
        // Enables verbose error printing of all credential chain errors.
        // Should be used when wanting to see all errors while attempting to
        // retrieve credentials.
        CredentialsChainVerboseErrors *bool

        // The credentials object to use when signing requests. Defaults to a
        // chain of credential providers to search for credentials in environment
        // variables, shared credential file, and EC2 Instance Roles.
        Credentials *credentials.Credentials

        // An optional endpoint URL (hostname only or fully qualified URI)
        // that overrides the default generated endpoint for a client. Set this
        // to `""` to use the default generated endpoint.
        //
        // Note: You must still provide a `Region` value when specifying an
        // endpoint for a client.
        Endpoint *string

        // The resolver to use for looking up endpoints for AWS service clients
        // to use based on region.
        EndpointResolver endpoints.Resolver

        // EnforceShouldRetryCheck is used in the AfterRetryHandler to always call
        // ShouldRetry regardless of whether or not if request.Retryable is set.
        // This will utilize ShouldRetry method of custom retryers. If EnforceShouldRetryCheck
        // is not set, then ShouldRetry will only be called if request.Retryable is nil.
        // Proper handling of the request.Retryable field is important when setting this field.
        EnforceShouldRetryCheck *bool

        // The region to send requests to. This parameter is required and must
        // be configured globally or on a per-client basis unless otherwise
        // noted. A full list of regions is found in the "Regions and Endpoints"
        // document.
        //
        // See http://docs.aws.amazon.com/general/latest/gr/rande.html for AWS
        // Regions and Endpoints.
        Region *string

        // Set this to `true` to disable SSL when sending requests. Defaults
        // to `false`.
        DisableSSL *bool

        // The HTTP client to use when sending requests. Defaults to
        // `http.DefaultClient`.
        HTTPClient *http.Client

        // An integer value representing the logging level. The default log level
        // is zero (LogOff), which represents no logging. To enable logging set
        // to a LogLevel Value.
        LogLevel *LogLevelType

        // The logger writer interface to write logging messages to. Defaults to
        // standard out.
        Logger Logger

        // The maximum number of times that a request will be retried for failures.
        // Defaults to -1, which defers the max retry setting to the service
        // specific configuration.
        MaxRetries *int

        // Retryer guides how HTTP requests should be retried in case of
        // recoverable failures.
        //
        // When nil or the value does not implement the request.Retryer interface,
        // the client.DefaultRetryer will be used.
        //
        // When both Retryer and MaxRetries are non-nil, the former is used and
        // the latter ignored.
        //
        // To set the Retryer field in a type-safe manner and with chaining, use
        // the request.WithRetryer helper function:
        //
        //   cfg := request.WithRetryer(aws.NewConfig(), myRetryer)
        //
        Retryer RequestRetryer

        // Disables semantic parameter validation, which validates input for
        // missing required fields and/or other semantic request input errors.
        DisableParamValidation *bool

        // Disables the computation of request and response checksums, e.g.,
        // CRC32 checksums in Amazon DynamoDB.
        DisableComputeChecksums *bool

        // Set this to `true` to force the request to use path-style addressing,
        // i.e., `http://s3.amazonaws.com/BUCKET/KEY`. By default, the S3 client
        // will use virtual hosted bucket addressing when possible
        // (`http://BUCKET.s3.amazonaws.com/KEY`).
        //
        // Note: This configuration option is specific to the Amazon S3 service.
        //
        // See http://docs.aws.amazon.com/AmazonS3/latest/dev/VirtualHosting.html
        // for Amazon S3: Virtual Hosting of Buckets
        S3ForcePathStyle *bool

        // Set this to `true` to disable the SDK adding the `Expect: 100-Continue`
        // header to PUT requests over 2MB of content. 100-Continue instructs the
        // HTTP client not to send the body until the service responds with a
        // `continue` status. This is useful to prevent sending the request body
        // until after the request is authenticated, and validated.
        //
        // http://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html
        //
        // 100-Continue is only enabled for Go 1.6 and above. See `http.Transport`'s
        // `ExpectContinueTimeout` for information on adjusting the continue wait
        // timeout. https://golang.org/pkg/net/http/#Transport
        //
        // You should use this flag to disble 100-Continue if you experience issues
        // with proxies or third party S3 compatible services.
        S3Disable100Continue *bool

        // Set this to `true` to enable S3 Accelerate feature. For all operations
        // compatible with S3 Accelerate will use the accelerate endpoint for
        // requests. Requests not compatible will fall back to normal S3 requests.
        //
        // The bucket must be enable for accelerate to be used with S3 client with
        // accelerate enabled. If the bucket is not enabled for accelerate an error
        // will be returned. The bucket name must be DNS compatible to also work
        // with accelerate.
        S3UseAccelerate *bool

        // S3DisableContentMD5Validation config option is temporarily disabled,
        // For S3 GetObject API calls, #1837.
        //
        // Set this to `true` to disable the S3 service client from automatically
        // adding the ContentMD5 to S3 Object Put and Upload API calls. This option
        // will also disable the SDK from performing object ContentMD5 validation
        // on GetObject API calls.
        S3DisableContentMD5Validation *bool

        // Set this to `true` to disable the EC2Metadata client from overriding the
        // default http.Client's Timeout. This is helpful if you do not want the
        // EC2Metadata client to create a new http.Client. This options is only
        // meaningful if you're not already using a custom HTTP client with the
        // SDK. Enabled by default.
        //
        // Must be set and provided to the session.NewSession() in order to disable
        // the EC2Metadata overriding the timeout for default credentials chain.
        //
        // Example:
        //    sess := session.Must(session.NewSession(aws.NewConfig()
        //       .WithEC2MetadataDiableTimeoutOverride(true)))
        //
        //    svc := s3.New(sess)
        //
        EC2MetadataDisableTimeoutOverride *bool

        // Instructs the endpoint to be generated for a service client to
        // be the dual stack endpoint. The dual stack endpoint will support
        // both IPv4 and IPv6 addressing.
        //
        // Setting this for a service which does not support dual stack will fail
        // to make requets. It is not recommended to set this value on the session
        // as it will apply to all service clients created with the session. Even
        // services which don't support dual stack endpoints.
        //
        // If the Endpoint config value is also provided the UseDualStack flag
        // will be ignored.
        //
        // Only supported with.
        //
        //     sess := session.Must(session.NewSession())
        //
        //     svc := s3.New(sess, &aws.Config{
        //         UseDualStack: aws.Bool(true),
        //     })
        UseDualStack *bool

        // SleepDelay is an override for the func the SDK will call when sleeping
        // during the lifecycle of a request. Specifically this will be used for
        // request delays. This value should only be used for testing. To adjust
        // the delay of a request see the aws/client.DefaultRetryer and
        // aws/request.Retryer.
        //
        // SleepDelay will prevent any Context from being used for canceling retry
        // delay of an API operation. It is recommended to not use SleepDelay at all
        // and specify a Retryer instead.
        SleepDelay func(time.Duration)

        // DisableRestProtocolURICleaning will not clean the URL path when making rest protocol requests.
        // Will default to false. This would only be used for empty directory names in s3 requests.
        //
        // Example:
        //    sess := session.Must(session.NewSession(&aws.Config{
        //         DisableRestProtocolURICleaning: aws.Bool(true),
        //    }))
        //
        //    svc := s3.New(sess)
        //    out, err := svc.GetObject(&s3.GetObjectInput {
        //      Bucket: aws.String("bucketname"),
        //      Key: aws.String("//foo//bar//moo"),
        //    })
        DisableRestProtocolURICleaning *bool

        // EnableEndpointDiscovery will allow for endpoint discovery on operations that
        // have the definition in its model. By default, endpoint discovery is off.
        //
        // Example:
        //    sess := session.Must(session.NewSession(&aws.Config{
        //         EnableEndpointDiscovery: aws.Bool(true),
        //    }))
        //
        //    svc := s3.New(sess)
        //    out, err := svc.GetObject(&s3.GetObjectInput {
        //      Bucket: aws.String("bucketname"),
        //      Key: aws.String("/foo/bar/moo"),
        //    })
        EnableEndpointDiscovery *bool

        // DisableEndpointHostPrefix will disable the SDK's behavior of prefixing
        // request endpoint hosts with modeled information.
        //
        // Disabling this feature is useful when you want to use local endpoints
        // for testing that do not support the modeled host prefix pattern.
        DisableEndpointHostPrefix *bool
}

// NewConfig returns a new Config pointer that can be chained with builder
// methods to set multiple configuration values inline without using pointers.
//
//     // Create Session with MaxRetry configuration to be shared by multiple
//     // service clients.
//     sess := session.Must(session.NewSession(aws.NewConfig().
//         WithMaxRetries(3),
//     ))
//
//     // Create S3 service client with a specific Region.
//     svc := s3.New(sess, aws.NewConfig().
//         WithRegion("us-west-2"),
//     )
func NewConfig() *Config {
        return &Config{}
}

// WithCredentialsChainVerboseErrors sets a config verbose errors boolean and returning
// a Config pointer.
func (c *Config) WithCredentialsChainVerboseErrors(verboseErrs bool) *Config {
        c.CredentialsChainVerboseErrors = &verboseErrs
        return c
}

// WithCredentials sets a config Credentials value returning a Config pointer
// for chaining.
func (c *Config) WithCredentials(creds *credentials.Credentials) *Config {
        c.Credentials = creds
        return c
}

// WithEndpoint sets a config Endpoint value returning a Config pointer for
// chaining.
func (c *Config) WithEndpoint(endpoint string) *Config {
        c.Endpoint = &endpoint
        return c
}

// WithEndpointResolver sets a config EndpointResolver value returning a
// Config pointer for chaining.
func (c *Config) WithEndpointResolver(resolver endpoints.Resolver) *Config {
        c.EndpointResolver = resolver
        return c
}

// WithRegion sets a config Region value returning a Config pointer for
// chaining.
func (c *Config) WithRegion(region string) *Config {
        c.Region = &region
        return c
}

// WithDisableSSL sets a config DisableSSL value returning a Config pointer
// for chaining.
func (c *Config) WithDisableSSL(disable bool) *Config {
        c.DisableSSL = &disable
        return c
}

// WithHTTPClient sets a config HTTPClient value returning a Config pointer
// for chaining.
func (c *Config) WithHTTPClient(client *http.Client) *Config {
        c.HTTPClient = client
        return c
}

// WithMaxRetries sets a config MaxRetries value returning a Config pointer
// for chaining.
func (c *Config) WithMaxRetries(max int) *Config {
        c.MaxRetries = &max
        return c
}

// WithDisableParamValidation sets a config DisableParamValidation value
// returning a Config pointer for chaining.
func (c *Config) WithDisableParamValidation(disable bool) *Config {
        c.DisableParamValidation = &disable
        return c
}

// WithDisableComputeChecksums sets a config DisableComputeChecksums value
// returning a Config pointer for chaining.
func (c *Config) WithDisableComputeChecksums(disable bool) *Config {
        c.DisableComputeChecksums = &disable
        return c
}

// WithLogLevel sets a config LogLevel value returning a Config pointer for
// chaining.
func (c *Config) WithLogLevel(level LogLevelType) *Config {
        c.LogLevel = &level
        return c
}

// WithLogger sets a config Logger value returning a Config pointer for
// chaining.
func (c *Config) WithLogger(logger Logger) *Config {
        c.Logger = logger
        return c
}

// WithS3ForcePathStyle sets a config S3ForcePathStyle value returning a Config
// pointer for chaining.
func (c *Config) WithS3ForcePathStyle(force bool) *Config {
        c.S3ForcePathStyle = &force
        return c
}

// WithS3Disable100Continue sets a config S3Disable100Continue value returning
// a Config pointer for chaining.
func (c *Config) WithS3Disable100Continue(disable bool) *Config {
        c.S3Disable100Continue = &disable
        return c
}

// WithS3UseAccelerate sets a config S3UseAccelerate value returning a Config
// pointer for chaining.
func (c *Config) WithS3UseAccelerate(enable bool) *Config {
        c.S3UseAccelerate = &enable
        return c

}

// WithS3DisableContentMD5Validation sets a config
// S3DisableContentMD5Validation value returning a Config pointer for chaining.
func (c *Config) WithS3DisableContentMD5Validation(enable bool) *Config {
        c.S3DisableContentMD5Validation = &enable
        return c

}

// WithUseDualStack sets a config UseDualStack value returning a Config
// pointer for chaining.
func (c *Config) WithUseDualStack(enable bool) *Config {
        c.UseDualStack = &enable
        return c
}

// WithEC2MetadataDisableTimeoutOverride sets a config EC2MetadataDisableTimeoutOverride value
// returning a Config pointer for chaining.
func (c *Config) WithEC2MetadataDisableTimeoutOverride(enable bool) *Config {
        c.EC2MetadataDisableTimeoutOverride = &enable
        return c
}

// WithSleepDelay overrides the function used to sleep while waiting for the
// next retry. Defaults to time.Sleep.
func (c *Config) WithSleepDelay(fn func(time.Duration)) *Config {
        c.SleepDelay = fn
        return c
}

// WithEndpointDiscovery will set whether or not to use endpoint discovery.
func (c *Config) WithEndpointDiscovery(t bool) *Config {
        c.EnableEndpointDiscovery = &t
        return c
}

// WithDisableEndpointHostPrefix will set whether or not to use modeled host prefix
// when making requests.
func (c *Config) WithDisableEndpointHostPrefix(t bool) *Config {
        c.DisableEndpointHostPrefix = &t
        return c
}

// MergeIn merges the passed in configs into the existing config object.
func (c *Config) MergeIn(cfgs ...*Config) {
        for _, other := range cfgs {
                mergeInConfig(c, other)
        }
}

func mergeInConfig(dst *Config, other *Config) {
        if other == nil {
                return
        }

        if other.CredentialsChainVerboseErrors != nil {
                dst.CredentialsChainVerboseErrors = other.CredentialsChainVerboseErrors
        }

        if other.Credentials != nil {
                dst.Credentials = other.Credentials
        }

        if other.Endpoint != nil {
                dst.Endpoint = other.Endpoint
        }

        if other.EndpointResolver != nil {
                dst.EndpointResolver = other.EndpointResolver
        }

        if other.Region != nil {
                dst.Region = other.Region
        }

        if other.DisableSSL != nil {
                dst.DisableSSL = other.DisableSSL
        }

        if other.HTTPClient != nil {
                dst.HTTPClient = other.HTTPClient
        }

        if other.LogLevel != nil {
                dst.LogLevel = other.LogLevel
        }

        if other.Logger != nil {
                dst.Logger = other.Logger
        }

        if other.MaxRetries != nil {
                dst.MaxRetries = other.MaxRetries
        }

        if other.Retryer != nil {
                dst.Retryer = other.Retryer
        }

        if other.DisableParamValidation != nil {
                dst.DisableParamValidation = other.DisableParamValidation
        }

        if other.DisableComputeChecksums != nil {
                dst.DisableComputeChecksums = other.DisableComputeChecksums
        }

        if other.S3ForcePathStyle != nil {
                dst.S3ForcePathStyle = other.S3ForcePathStyle
        }

        if other.S3Disable100Continue != nil {
                dst.S3Disable100Continue = other.S3Disable100Continue
        }

        if other.S3UseAccelerate != nil {
                dst.S3UseAccelerate = other.S3UseAccelerate
        }

        if other.S3DisableContentMD5Validation != nil {
                dst.S3DisableContentMD5Validation = other.S3DisableContentMD5Validation
        }

        if other.UseDualStack != nil {
                dst.UseDualStack = other.UseDualStack
        }

        if other.EC2MetadataDisableTimeoutOverride != nil {
                dst.EC2MetadataDisableTimeoutOverride = other.EC2MetadataDisableTimeoutOverride
        }

        if other.SleepDelay != nil {
                dst.SleepDelay = other.SleepDelay
        }

        if other.DisableRestProtocolURICleaning != nil {
                dst.DisableRestProtocolURICleaning = other.DisableRestProtocolURICleaning
        }

        if other.EnforceShouldRetryCheck != nil {
                dst.EnforceShouldRetryCheck = other.EnforceShouldRetryCheck
        }

        if other.EnableEndpointDiscovery != nil {
                dst.EnableEndpointDiscovery = other.EnableEndpointDiscovery
        }

        if other.DisableEndpointHostPrefix != nil {
                dst.DisableEndpointHostPrefix = other.DisableEndpointHostPrefix
        }
}

// Copy will return a shallow copy of the Config object. If any additional
// configurations are provided they will be merged into the new config returned.
func (c *Config) Copy(cfgs ...*Config) *Config {
        dst := &Config{}
        dst.MergeIn(c)

        for _, cfg := range cfgs {
                dst.MergeIn(cfg)
        }

        return dst
}