* The default configuration is to use HTTPS for all requests for increased security. */ private Protocol protocol = Protocol.HTTPS; /** * The protocol to use when connecting to an HTTP proxy. *
* The default configuration is to use {@link Protocol#HTTP}.
*/
private Protocol proxyProtocol = Protocol.HTTP;
/** Optionally specifies the proxy host to connect through. */
private String proxyHost = null;
/** Optionally specifies the port on the proxy host to connect through. */
private int proxyPort = -1;
/** Optionally specifies the user name to use when connecting through a proxy. */
private String proxyUsername = null;
/** Optionally specifies the password to use when connecting through a proxy. */
private String proxyPassword = null;
/** Optional Windows domain name for configuring NTLM proxy support. */
private String proxyDomain = null;
/** Optional Windows workstation name for configuring NTLM proxy support. */
private String proxyWorkstation = null;
/** Optional specifies the hosts that should be accessed without going through the proxy. */
private String nonProxyHosts = null;
/** Specifies the proxy authentication methods that should be used, in priority order. */
private List
* Actual TCP KeepAlive values (timeout, number of packets, etc) are configured via the
* operating system (sysctl on Linux, and Registry values on Windows).
*/
private boolean tcpKeepAlive = DEFAULT_TCP_KEEP_ALIVE;
/**
* Whether or not to cache response metadata.
*
* Response metadata is typically used for troubleshooting issues with AWS support staff when
* services aren't acting as expected.
*
* While this feature is useful for debugging it adds overhead and disabling it may
* be desired in high throughput applications.
*
* Response metadata is typically used for troubleshooting issues with AWS support staff when
* services aren't acting as expected.
*/
private int responseMetadataCacheSize = DEFAULT_RESPONSE_METADATA_CACHE_SIZE;
/**
* The DNS Resolver to resolve IP addresses of Amazon Web Services.
*/
private DnsResolver dnsResolver = new SystemDefaultDnsResolver();
/**
* An instance of {@link SecureRandom} configured by the user; or the JDK default will be used
* if it is set to null or not explicitly configured.
*/
private SecureRandom secureRandom;
/**
* Headers to be added to all requests
*/
private Map
* The detail of HTTP Expect Continue is defined at
* Use of the 100
* (Continue) Status. Setting this as false will reduce latency when you want to send small
* size of payload. It is highly recommended to use the default value if you want to transfer a
* large amount of data to the server, such as uploading a big file to S3 bucket.
*/
private boolean useExpectContinue = DEFAULT_USE_EXPECT_CONTINUE;
/**
* The maximum number of throttled retries if the initial request
* fails.
*/
private int maxConsecutiveRetriesBeforeThrottling = DEFAULT_MAX_CONSECUTIVE_RETRIES_BEFORE_THROTTLING;
/**
* Can be used to specify custom specific Apache HTTP client configurations.
*/
private final ApacheHttpClientConfig apacheHttpClientConfig;
/**
* Configuration option to disable the host prefix injection.
*
* The hostPrefix template is specified in the service model and is used by the SDK to modify the endpoint
* the request is sent to. Host prefix injection is enabled by default. This option can be set to disable the behavior.
*/
private boolean disableHostPrefixInjection;
private final AtomicReference
* The default configuration is to use HTTPS for all requests for increased security.
*
* Individual clients can also override this setting by explicitly including the protocol as
* part of the endpoint URL when calling {@link AmazonWebServiceClient#setEndpoint(String)}.
*
* @return The protocol to use when connecting to Amazon Web Services.
*/
public Protocol getProtocol() {
return protocol;
}
/**
* Sets the protocol (i.e. HTTP or HTTPS) to use when connecting to Amazon Web Services.
*
* The default configuration is to use HTTPS for all requests for increased security.
*
* Individual clients can also override this setting by explicitly including the protocol as
* part of the endpoint URL when calling {@link AmazonWebServiceClient#setEndpoint(String)}.
*
* @param protocol
* The protocol to use when connecting to Amazon Web Services.
*/
public void setProtocol(Protocol protocol) {
this.protocol = protocol;
}
/**
* Sets the protocol (i.e. HTTP or HTTPS) to use when connecting to Amazon Web Services, and
* returns the updated ClientConfiguration object so that additional calls may be chained
* together.
*
* The default configuration is to use HTTPS for all requests for increased security.
*
* Individual clients can also override this setting by explicitly including the protocol as
* part of the endpoint URL when calling {@link AmazonWebServiceClient#setEndpoint(String)}.
*
* @param protocol
* The protocol to use when connecting to Amazon Web Services.
* @return The updated ClientConfiguration object with the new max HTTP connections setting.
*/
public ClientConfiguration withProtocol(Protocol protocol) {
setProtocol(protocol);
return this;
}
/**
* Returns the maximum number of allowed open HTTP connections.
*
* @return The maximum number of allowed open HTTP connections.
*/
public int getMaxConnections() {
return maxConnections;
}
/**
* Sets the maximum number of allowed open HTTP connections.
*
* @param maxConnections
* The maximum number of allowed open HTTP connections.
*/
public void setMaxConnections(int maxConnections) {
this.maxConnections = maxConnections;
}
/**
* Sets the maximum number of allowed open HTTP connections and returns the updated
* ClientConfiguration object.
*
* @param maxConnections
* The maximum number of allowed open HTTP connections.
* @return The updated ClientConfiguration object with the new max HTTP connections setting.
*/
public ClientConfiguration withMaxConnections(int maxConnections) {
setMaxConnections(maxConnections);
return this;
}
/**
* @deprecated Replaced by {@link #getUserAgentPrefix()} and {@link #getUserAgentSuffix()}
* @return The user agent string to use when sending requests.
*/
@Deprecated
public String getUserAgent() {
return getUserAgentPrefix();
}
/**
* @deprecated Replaced by {@link #setUserAgentPrefix(String)} and {@link #setUserAgentSuffix(String)}
* @param userAgent
* The user agent string to use when sending requests.
*/
@Deprecated
public void setUserAgent(String userAgent) {
setUserAgentPrefix(userAgent);
}
/**
* @deprecated Replaced by {@link #withUserAgentPrefix(String)} and {@link #withUserAgentSuffix(String)}
* @param userAgent
* The user agent string to use when sending requests.
* @return The updated ClientConfiguration object.
*/
@Deprecated
public ClientConfiguration withUserAgent(String userAgent) {
return withUserAgentPrefix(userAgent);
}
/**
* Returns the HTTP user agent header prefix to send with all requests.
*
* @return The user agent string prefix to use when sending requests.
*/
public String getUserAgentPrefix() {
return userAgentPrefix;
}
/**
* Sets the HTTP user agent prefix to send with all requests.
*
* @param prefix
* The string to prefix to user agent to use when sending requests.
*/
public void setUserAgentPrefix(String prefix) {
this.userAgentPrefix = prefix;
}
/**
* Sets the HTTP user agent prefix header used in requests and returns the updated ClientConfiguration
* object.
*
* @param prefix
* The string to prefix to user agent to use when sending requests.
* @return The updated ClientConfiguration object.
*/
public ClientConfiguration withUserAgentPrefix(String prefix) {
setUserAgentPrefix(prefix);
return this;
}
/**
* Returns the HTTP user agent header suffix to add to the end of the user agent header on all requests.
*
* @return The user agent string suffix to use when sending requests.
*/
public String getUserAgentSuffix() {
return userAgentSuffix;
}
/**
* Sets the HTTP user agent suffix to send with all requests.
*
* @param suffix
* The string to suffix to user agent to use when sending requests.
*/
public void setUserAgentSuffix(String suffix) {
this.userAgentSuffix = suffix;
}
/**
* Sets the HTTP user agent suffix header used in requests and returns the updated ClientConfiguration
* object.
*
* @param suffix
* The string to suffix to user agent to use when sending requests.
* @return The updated ClientConfiguration object.
*/
public ClientConfiguration withUserAgentSuffix(String suffix) {
setUserAgentSuffix(suffix);
return this;
}
/**
* Returns the optional local address the client will bind to.
*
* @return The local address the client will bind to.
*/
public InetAddress getLocalAddress() {
return localAddress;
}
/**
* Sets the optional local address the client will bind to.
*
* @param localAddress
* The local address the client will bind to.
*/
public void setLocalAddress(InetAddress localAddress) {
this.localAddress = localAddress;
}
/**
* Sets the optional local address the client will bind to and returns the updated
* ClientConfiguration object.
*
* @param localAddress
* The local address the client will bind to.
* @return The updated ClientConfiguration object.
*/
public ClientConfiguration withLocalAddress(InetAddress localAddress) {
setLocalAddress(localAddress);
return this;
}
/**
* Returns the value for the given system property.
*/
private String getSystemProperty(String property) {
return System.getProperty(property);
}
/**
* Returns the value for the given environment variable.
*/
private String getEnvironmentVariable(String environmentVariable) {
String value = StringUtils.trim(System.getenv(environmentVariable));
return StringUtils.hasValue(value) ? value : null;
}
/**
* Returns the value for the given environment variable if its set, otherwise returns
* the lowercase version of variable.
*/
private String getEnvironmentVariableCaseInsensitive(String environmentVariable) {
String result = getEnvironmentVariable(environmentVariable);
return result != null ? result : getEnvironmentVariable(environmentVariable.toLowerCase());
}
/**
* @return The {@link Protocol} to use for connecting to the proxy.
*/
public Protocol getProxyProtocol() {
return proxyProtocol;
}
/**
* Set the {@link Protocol} to use for connecting to the proxy.
*
* @param proxyProtocol The protocol.
* @return The updated ClientConfiguration object.
*/
public ClientConfiguration withProxyProtocol(Protocol proxyProtocol) {
this.proxyProtocol = proxyProtocol == null ? Protocol.HTTP : proxyProtocol;
return this;
}
/**
* Set the {@link Protocol} to use for connecting to the proxy.
*
* @param proxyProtocol The protocol.
*/
public void setProxyProtocol(Protocol proxyProtocol) {
withProxyProtocol(proxyProtocol);
}
/**
* Returns the Java system property for proxy host depending on
* {@link #getProtocol()}: i.e. if protocol is https, returns
* the value of the system property https.proxyHost, otherwise
* returns value of http.proxyHost.
*/
private String getProxyHostProperty() {
return getProtocol() == Protocol.HTTPS
? getSystemProperty("https.proxyHost")
: getSystemProperty("http.proxyHost");
}
/**
* Returns the environment variable for proxy host depending on
* {@link #getProtocol()}: i.e. if protocol is https, returns
* the host in the value of the environment variable HTTPS_PROXY/https_proxy,
* otherwise, returns the host in the value of the environment
* variable HTTP_PROXY/http_proxy.
*/
private String getProxyHostEnvironment() {
URL httpProxy = getHttpProxyEnvironmentVariable();
if (httpProxy != null) {
return httpProxy.getHost();
}
return null;
}
/**
* Returns the optional proxy host the client will connect
* through. Returns either the proxyHost set on this object, or
* if not provided, checks the value of the Java system property
* for proxy host according to {@link #getProtocol()}: i.e. if
* protocol is https, returns the value of the system property
* https.proxyHost, otherwise returns value of http.proxyHost.
* If neither are set, checks the value of the environment variable
* according to {@link #getProtocol()}: i.e. if protocol is https,
* returns the host in the value of the HTTPS_PROXY/https_proxy
* environment variable, otherwise returns the host in the value
* of the HTTP_PROXY/http_proxy environment variable.
*
* @return The proxy host the client will connect through.
*/
public String getProxyHost() {
if (proxyHost != null) {
return proxyHost;
} else if (getProxyHostProperty() != null) {
return getProxyHostProperty();
} else {
return getProxyHostEnvironment();
}
}
/**
* Sets the optional proxy host the client will connect through.
*
* @param proxyHost
* The proxy host the client will connect through.
*/
public void setProxyHost(String proxyHost) {
this.proxyHost = proxyHost;
}
/**
* Sets the optional proxy host the client will connect through and returns the updated
* ClientConfiguration object.
*
* @param proxyHost
* The proxy host the client will connect through.
* @return The updated ClientConfiguration object.
*/
public ClientConfiguration withProxyHost(String proxyHost) {
setProxyHost(proxyHost);
return this;
}
/**
* Returns the Java system property for proxy port depending on
* {@link #getProtocol()}: i.e. if protocol is https, returns
* the value of the system property https.proxyPort, otherwise
* returns value of http.proxyPort. Defaults to {@link this.proxyPort}
* if the system property is not set with a valid port number.
*/
private int getProxyPortProperty() {
try {
return getProtocol() == Protocol.HTTPS
? Integer.parseInt(getSystemProperty("https.proxyPort"))
: Integer.parseInt(getSystemProperty("http.proxyPort"));
} catch (NumberFormatException e) {
return proxyPort;
}
}
/**
* Returns the environment variable for proxy port depending on
* {@link #getProtocol()}: i.e. if protocol is https, returns
* the port in the value of the environment variable HTTPS_PROXY/https_proxy,
* otherwise, returns the port in the value of the environment
* variable HTTP_PROXY/http_proxy.
*/
private int getProxyPortEnvironment() {
URL httpProxy = getHttpProxyEnvironmentVariable();
if (httpProxy != null) {
return httpProxy.getPort();
}
return proxyPort;
}
/**
* Returns the optional proxy port the client will connect
* through. Returns either the proxyPort set on this object, or
* if not provided, checks the value of the Java system property
* for proxy port according to {@link #getProtocol()}: i.e. if
* protocol is https, returns the value of the system property
* https.proxyPort, otherwise returns value of http.proxyPort.
* If neither are set, checks the value of the environment variable
* according to {@link #getProtocol()}: i.e. if protocol is https,
* returns the port in the value of the HTTPS_PROXY/https_proxy
* environment variable, otherwise returns the port in the value
* of the HTTP_PROXY/http_proxy environment variable.
*
* @return The proxy port the client will connect through.
*/
public int getProxyPort() {
if (proxyPort >= 0) {
return proxyPort;
} else if (getProxyPortProperty() >= 0) {
return getProxyPortProperty();
} else {
return getProxyPortEnvironment();
}
}
/**
* Sets the optional proxy port the client will connect through.
*
* @param proxyPort
* The proxy port the client will connect through.
*/
public void setProxyPort(int proxyPort) {
this.proxyPort = proxyPort;
}
/**
* Sets the optional proxy port the client will connect through and returns the updated
* ClientConfiguration object.
*
* @param proxyPort
* The proxy port the client will connect through.
* @return The updated ClientConfiguration object.
*/
public ClientConfiguration withProxyPort(int proxyPort) {
setProxyPort(proxyPort);
return this;
}
/**
* Set whether to disable proxies at the socket level.
*
* @param disableSocketProxy Whether to disable proxies at the socket level.
*
* @return The updated ClientConfiguration object.
*/
public ClientConfiguration withDisableSocketProxy(boolean disableSocketProxy) {
this.disableSocketProxy = disableSocketProxy;
return this;
}
/**
* Set whether to disable proxies at the socket level.
*
* @param disableSocketProxy Whether to disable proxies at the socket level.
*/
public void setDisableSocketProxy(boolean disableSocketProxy) {
withDisableSocketProxy(disableSocketProxy);
}
/**
* @return Whether to disable proxies at the socket level.
*/
public boolean disableSocketProxy() {
return disableSocketProxy;
}
/**
* Returns the Java system property for proxy user name depending on
* {@link #getProtocol()}: i.e. if protocol is https, returns
* the value of the system property https.proxyUser, otherwise
* returns value of http.proxyUser.
*/
private String getProxyUsernameProperty() {
return (getProtocol() == Protocol.HTTPS)
? getSystemProperty("https.proxyUser")
: getSystemProperty("http.proxyUser");
}
/**
* Returns the environment variable for proxy host depending on
* {@link #getProtocol()}: i.e. if protocol is https, returns
* the user name in the value of the environment variable
* HTTPS_PROXY/https_proxy, otherwise, returns the user name in
* the value of the environment variable HTTP_PROXY/http_proxy.
*/
private String getProxyUsernameEnvironment() {
URL httpProxy = getHttpProxyEnvironmentVariable();
if (httpProxy != null) {
try {
return httpProxy.getUserInfo().split(":", 2)[0];
} catch (Exception ignored) {
}
}
return null;
}
/**
* Returns the optional proxy user name to use if connecting
* through a proxy. Returns either the proxyUsername set on this
* object, or if not provided, checks the value of the Java system
* property for proxy user name according to {@link #getProtocol()}:
* i.e. if protocol is https, returns the value of the system
* property https.proxyUser, otherwise returns value of
* http.proxyUser. If neither are set, checks the value of the
* environment variable according to {@link #getProtocol()}: i.e.
* if protocol is https, returns the user name in the value of the
* HTTPS_PROXY/https_proxy environment variable, otherwise returns
* the user name in the value of the HTTP_PROXY/http_proxy environment
* variable.
*
* @return The optional proxy user name the configured client will use if connecting through a
* proxy.
*/
public String getProxyUsername() {
if (proxyUsername != null) {
return proxyUsername;
} else if (getProxyUsernameProperty() != null) {
return getProxyUsernameProperty();
} else {
return getProxyUsernameEnvironment();
}
}
/**
* Sets the optional proxy user name to use if connecting through a proxy.
*
* @param proxyUsername
* The proxy user name to use if connecting through a proxy.
*/
public void setProxyUsername(String proxyUsername) {
this.proxyUsername = proxyUsername;
}
/**
* Sets the optional proxy user name and returns the updated ClientConfiguration object.
*
* @param proxyUsername
* The proxy user name to use if connecting through a proxy.
* @return The updated ClientConfiguration object.
*/
public ClientConfiguration withProxyUsername(String proxyUsername) {
setProxyUsername(proxyUsername);
return this;
}
/**
* Returns the Java system property for proxy password depending on
* {@link #getProtocol()}: i.e. if protocol is https, returns
* the value of the system property https.proxyPassword, otherwise
* returns value of http.proxyPassword.
*/
private String getProxyPasswordProperty() {
return (getProtocol() == Protocol.HTTPS)
? getSystemProperty("https.proxyPassword")
: getSystemProperty("http.proxyPassword");
}
/**
* Returns the environment variable for proxy host depending on
* {@link #getProtocol()}: i.e. if protocol is https, returns
* the password in the value of the environment variable HTTPS_PROXY/https_proxy,
* otherwise, returns the password in the value of the environment
* variable HTTP_PROXY/http_proxy.
*/
private String getProxyPasswordEnvironment() {
URL httpProxy = getHttpProxyEnvironmentVariable();
if (httpProxy != null) {
try {
return httpProxy.getUserInfo().split(":", 2)[1];
} catch (Exception ignored) {
}
}
return null;
}
/**
* Returns the optional proxy password to use if connecting
* through a proxy. Returns either the proxyPassword set on this
* object, or if not provided, checks the value of the Java system
* property for proxy password according to {@link #getProtocol()}:
* i.e. if protocol is https, returns the value of the system
* property https.proxyPassword, otherwise returns value of
* http.proxyPassword. If neither are set, checks the value of the
* environment variable according to {@link #getProtocol()}: i.e. if
* protocol is https, returns the password in the value of the
* HTTPS_PROXY/https_proxy environment variable, otherwise returns
* the password in the value of the HTTP_PROXY/http_proxy environment
* variable.
*
* @return The password to use when connecting through a proxy.
*/
public String getProxyPassword() {
if (proxyPassword != null) {
return proxyPassword;
} else if (getProxyPasswordProperty() != null) {
return getProxyPasswordProperty();
} else {
return getProxyPasswordEnvironment();
}
}
/**
* Sets the optional proxy password to use when connecting through a proxy.
*
* @param proxyPassword
* The password to use when connecting through a proxy.
*/
public void setProxyPassword(String proxyPassword) {
this.proxyPassword = proxyPassword;
}
/**
* Sets the optional proxy password to use when connecting through a proxy, and returns the
* updated ClientConfiguration object.
*
* @param proxyPassword
* The password to use when connecting through a proxy.
* @return The updated ClientConfiguration object.
*/
public ClientConfiguration withProxyPassword(String proxyPassword) {
setProxyPassword(proxyPassword);
return this;
}
/**
* Returns the optional Windows domain name for configuring an NTLM proxy. If you aren't using a
* Windows NTLM proxy, you do not need to set this field.
*
* @return The optional Windows domain name for configuring an NTLM proxy.
*/
public String getProxyDomain() {
return proxyDomain;
}
/**
* Sets the optional Windows domain name for configuration an NTLM proxy. If you aren't using a
* Windows NTLM proxy, you do not need to set this field.
*
* @param proxyDomain
* The optional Windows domain name for configuring an NTLM proxy.
*/
public void setProxyDomain(String proxyDomain) {
this.proxyDomain = proxyDomain;
}
/**
* Sets the optional Windows domain name for configuration an NTLM proxy and returns a reference
* to this updated ClientConfiguration object so that additional method calls can be chained
* together. If you aren't using a Windows NTLM proxy, you do not need to set this field.
*
* @param proxyDomain
* The optional Windows domain name for configuring an NTLM proxy.
* @return The updated ClientConfiguration object.
*/
public ClientConfiguration withProxyDomain(String proxyDomain) {
setProxyDomain(proxyDomain);
return this;
}
/**
* Returns the optional Windows workstation name for configuring NTLM proxy support. If you
* aren't using a Windows NTLM proxy, you do not need to set this field.
*
* @return The optional Windows workstation name for configuring NTLM proxy support.
*/
public String getProxyWorkstation() {
return proxyWorkstation;
}
/**
* Sets the optional Windows workstation name for configuring NTLM proxy support. If you aren't
* using a Windows NTLM proxy, you do not need to set this field.
*
* @param proxyWorkstation
* The optional Windows workstation name for configuring NTLM proxy support.
*/
public void setProxyWorkstation(String proxyWorkstation) {
this.proxyWorkstation = proxyWorkstation;
}
/**
* Sets the optional Windows workstation name for configuring NTLM proxy support, and returns
* the updated ClientConfiguration object so that additional method calls can be chained
* together. If you aren't using a Windows NTLM proxy, you do not need to set this field.
*
* @param proxyWorkstation
* The optional Windows workstation name for configuring NTLM proxy support.
* @return The updated ClientConfiguration object.
*/
public ClientConfiguration withProxyWorkstation(String proxyWorkstation) {
setProxyWorkstation(proxyWorkstation);
return this;
}
/**
* Returns the Java system property for nonProxyHosts. We still honor this property even
* {@link #getProtocol()} is https, see http://docs.oracle.com/javase/7/docs/api/java/net/doc-files/net-properties.html.
*
* This method expects the property to be set as pipe separated list.
*/
private String getNonProxyHostsProperty() {
return getSystemProperty("http.nonProxyHosts");
}
/**
* Returns the value of the environment variable NO_PROXY/no_proxy. This method expects
* the environment variable to be set as a comma separated list, so this method
* converts the comma separated list to pipe separated list to be used internally.
*/
private String getNonProxyHostsEnvironment() {
String nonProxyHosts = getEnvironmentVariableCaseInsensitive("NO_PROXY");
if (nonProxyHosts != null) {
nonProxyHosts = nonProxyHosts.replace(",", "|");
}
return nonProxyHosts;
}
/**
* Returns the optional hosts the client will access without going
* through the proxy. Returns either the nonProxyHosts set on this
* object, or if not provided, returns the value of the Java system property
* http.nonProxyHosts. We still honor this property even when
* {@link #getProtocol()} is https, see http://docs.oracle.com/javase/7/docs/api/java/net/doc-files/net-properties.html.
* This property is expected to be set as a pipe separated list. If neither are set,
* returns the value of the environment variable NO_PROXY/no_proxy. This environment
* variable is expected to be set as a comma separated list.
*
* @return The hosts the client will connect through bypassing the proxy.
*/
public String getNonProxyHosts() {
if (nonProxyHosts != null) {
return nonProxyHosts;
} else if (getNonProxyHostsProperty() != null) {
return getNonProxyHostsProperty();
} else {
return getNonProxyHostsEnvironment();
}
}
/**
* Set the optional hosts the client will access without going
* through the proxy.
*
* @param nonProxyHosts
* The hosts the client will access without going through the proxy.
*/
public void setNonProxyHosts(String nonProxyHosts) {
this.nonProxyHosts = nonProxyHosts;
}
/**
* Set the optional hosts the client will access without going
* through the proxy.
*
* @param nonProxyHosts
* The hosts the client will access without going through the proxy.
* @return The updated ClientConfiguration object.
*/
public ClientConfiguration withNonProxyHosts(String nonProxyHosts) {
setNonProxyHosts(nonProxyHosts);
return this;
}
/**
* Returns the list of authentication methods that should be used when authenticating against an HTTP proxy, in the order they
* should be attempted.
*
* @return An unmodifiable view of the proxy authentication methods that should be attempted, in order.
*/
public List Setting this value to null indicates using the default behavior, which is to try all authentication methods in an
* unspecified order. Setting this value to null indicates using the default behavior, which is to try all authentication methods in an
* unspecified order.
* This feature requires buffering the entire response (for non-streaming APIs) into memory to
* enforce a hard timeout when reading the response. For APIs that return large responses this
* could be expensive.
*
*
* The request timeout feature doesn't have strict guarantees on how quickly a request is
* aborted when the timeout is breached. The typical case aborts the request within a few
* milliseconds but there may occasionally be requests that don't get aborted until several
* seconds after the timer has been breached. Because of this, the request timeout feature
* should not be used when absolute precision is needed.
*
* This feature requires buffering the entire response (for non-streaming APIs) into memory to
* enforce a hard timeout when reading the response. For APIs that return large responses this
* could be expensive.
*
*
* The request timeout feature doesn't have strict guarantees on how quickly a request is
* aborted when the timeout is breached. The typical case aborts the request within a few
* milliseconds but there may occasionally be requests that don't get aborted until several
* seconds after the timer has been breached. Because of this, the request timeout feature
* should not be used when absolute precision is needed.
*
* Note: This feature is not compatible with Java 1.6.
*
* This feature requires buffering the entire response (for non-streaming APIs) into memory to
* enforce a hard timeout when reading the response. For APIs that return large responses this
* could be expensive.
*
*
* The request timeout feature doesn't have strict guarantees on how quickly a request is
* aborted when the timeout is breached. The typical case aborts the request within a few
* milliseconds but there may occasionally be requests that don't get aborted until several
* seconds after the timer has been breached. Because of this, the request timeout feature
* should not be used when absolute precision is needed.
*
* Note: This feature is not compatible with Java 1.6.
*
* This feature requires buffering the entire response (for non-streaming APIs) into memory to
* enforce a hard timeout when reading the response. For APIs that return large responses this
* could be expensive.
*
*
* The client execution timeout feature doesn't have strict guarantees on how quickly a request
* is aborted when the timeout is breached. The typical case aborts the request within a few
* milliseconds but there may occasionally be requests that don't get aborted until several
* seconds after the timer has been breached. Because of this, the client execution timeout
* feature should not be used when absolute precision is needed.
*
* This may be used together with {@link ClientConfiguration#setRequestTimeout(int)} to enforce
* both a timeout on each individual HTTP request (i.e. each retry) and the total time spent on
* all requests across retries (i.e. the 'client execution' time). A non-positive value disables
* this feature.
*
* Note: This feature is not compatible with Java 1.6.
*
* This feature requires buffering the entire response (for non-streaming APIs) into memory to
* enforce a hard timeout when reading the response. For APIs that return large responses this
* could be expensive.
*
*
* The client execution timeout feature doesn't have strict guarantees on how quickly a request
* is aborted when the timeout is breached. The typical case aborts the request within a few
* milliseconds but there may occasionally be requests that don't get aborted until several
* seconds after the timer has been breached. Because of this, the client execution timeout
* feature should not be used when absolute precision is needed.
*
* This may be used together with {@link ClientConfiguration#setRequestTimeout(int)} to enforce
* both a timeout on each individual HTTP request (i.e. each retry) and the total time spent on
* all requests across retries (i.e. the 'client execution' time). A non-positive value disables
* this feature.
*
* Note: This feature is not compatible with Java 1.6.
*
* This feature requires buffering the entire response (for non-streaming APIs) into memory to
* enforce a hard timeout when reading the response. For APIs that return large responses this
* could be expensive.
*
*
* The client execution timeout feature doesn't have strict guarantees on how quickly a request
* is aborted when the timeout is breached. The typical case aborts the request within a few
* milliseconds but there may occasionally be requests that don't get aborted until several
* seconds after the timer has been breached. Because of this, the client execution timeout
* feature should not be used when absolute precision is needed.
*
* This may be used together with {@link ClientConfiguration#setRequestTimeout(int)} to enforce
* both a timeout on each individual HTTP request (i.e. each retry) and the total time spent on
* all requests across retries (i.e. the 'client execution' time). A non-positive value disables
* this feature.
*
* Note: This feature is not compatible with Java 1.6.
*
* Retry throttling is a feature which intelligently throttles retry attempts when a
* large percentage of requests are failing and retries are unsuccessful, particularly
* in scenarios of degraded service health. In these situations the client will drain its
* internal retry capacity and slowly roll off from retry attempts until requests begin
* to succeed again. At that point the retry capacity pool will begin to refill and
* retries will once again be permitted.
*
* In situations where retries have been throttled this feature will effectively result in
* fail-fast behavior from the client. Because retries are circumvented exceptions will
* be immediately returned to the caller if the initial request is unsuccessful. This
* will result in a greater number of exceptions being returned up front but prevents
* requests being tied up attempting subsequent retries which are also likely to fail.
*
* Retry throttling is a feature which intelligently throttles retry attempts when a
* large percentage of requests are failing and retries are unsuccessful, particularly
* in scenarios of degraded service health. In these situations the client will drain its
* internal retry capacity and slowly roll off from retry attempts until requests begin
* to succeed again. At that point the retry capacity pool will begin to refill and
* retries will once again be permitted.
*
* In situations where retries have been throttled this feature will effectively result in
* fail-fast behavior from the client. Because retries are circumvented exceptions will
* be immediately returned to the caller if the initial request is unsuccessful. This
* will result in a greater number of exceptions being returned up front but prevents
* requests being tied up attempting subsequent retries which are also likely to fail.
*
* Retry throttling is a feature which intelligently throttles retry attempts when a
* large percentage of requests are failing and retries are unsuccessful, particularly
* in scenarios of degraded service health. In these situations the client will drain its
* internal retry capacity and slowly roll off from retry attempts until requests begin
* to succeed again. At that point the retry capacity pool will begin to refill and
* retries will once again be permitted.
*
* In situations where retries have been throttled this feature will effectively result in
* fail-fast behavior from the client. Because retries are circumvented exceptions will
* be immediately returned to the caller if the initial request is unsuccessful. This
* will result in a greater number of exceptions being returned up front but prevents
* requests being tied up attempting subsequent retries which are also likely to fail.
*
* Note: This does not guarantee that each failed request will be retried up to this many times.
* Depending on the configured {@link RetryPolicy} and the number of past failed and successful
* requests, the actual number of retries attempted may be less.
*
* This has a default value of {@link #DEFAULT_MAX_CONSECUTIVE_RETRIES_BEFORE_THROTTLING}.
*
* @param maxConsecutiveRetriesBeforeThrottling The maximum number of consecutive retries.
*/
public void setMaxConsecutiveRetriesBeforeThrottling(int maxConsecutiveRetriesBeforeThrottling) {
this.maxConsecutiveRetriesBeforeThrottling = ValidationUtils.assertIsPositive(maxConsecutiveRetriesBeforeThrottling,
"maxConsecutiveRetriesBeforeThrottling");
}
/**
* Set the maximum number of consecutive failed retries that the client will permit before
* throttling all subsequent retries of failed requests.
*
* Note: This does not guarantee that each failed request will be retried up to this many times.
* Depending on the configured {@link RetryPolicy} and the number of past failed and successful
* requests, the actual number of retries attempted may be less.
*
* This has a default value of {@link #DEFAULT_MAX_CONSECUTIVE_RETRIES_BEFORE_THROTTLING}.
*
* @param maxConsecutiveRetriesBeforeThrottling The maximum number of consecutive retries.
*
* @return This object for chaining.
*/
public ClientConfiguration withMaxConsecutiveRetriesBeforeThrottling(int maxConsecutiveRetriesBeforeThrottling) {
setMaxConsecutiveRetriesBeforeThrottling(maxConsecutiveRetriesBeforeThrottling);
return this;
}
/**
* @return Set the maximum number of consecutive failed retries that the client will permit
* before throttling all subsequent retries of failed requests.
*/
public int getMaxConsecutiveRetriesBeforeThrottling() {
return maxConsecutiveRetriesBeforeThrottling;
}
/**
* Checks if gzip decompression is used when receiving HTTP responses.
*
* @return if gzip decompression is used
*/
public boolean useGzip() {
return useGzip;
}
/**
* Sets whether gzip decompression should be used when receiving HTTP responses.
*
*
* Note
* useGzip should only be enabled if the HTTP response is gzipped
*
* @param use
* whether gzip decompression should be used
*/
public void setUseGzip(boolean use) {
this.useGzip = use;
}
/**
* Sets whether gzip decompression should be used when receiving HTTP responses.
*
*
* Note
* useGzip should only be enabled if the HTTP response is gzipped
*
* @param use
* whether gzip decompression should be used
* @return The updated ClientConfiguration object.
*/
public ClientConfiguration withGzip(boolean use) {
setUseGzip(use);
return this;
}
/**
* Returns the optional size hints (in bytes) for the low level TCP send and receive buffers.
* This is an advanced option for advanced users who want to tune low level TCP parameters to
* try and squeeze out more performance.
*
* The optimal TCP buffer sizes for a particular application are highly dependent on network
* configuration and operating system configuration and capabilities. For example, most modern
* operating systems provide auto-tuning functionality for TCP buffer sizes, which can have a
* big impact on performance for TCP connections that are held open long enough for the
* auto-tuning to optimize buffer sizes.
*
* Large buffer sizes (ex: 2MB) will allow the operating system to buffer more data in memory
* without requiring the remote server to acknowledge receipt of that information, so can be
* particularly useful when the network has high latency.
*
* This is only a hint, and the operating system may choose not to honor it. When using
* this option, users should always check the operating system's configured limits and
* defaults. Most OS's have a maximum TCP buffer size limit configured, and won't let you go
* beyond that limit unless you explicitly raise the max TCP buffer size limit.
*
* There are many resources available online to help with configuring TCP buffer sizes and
* operating system specific TCP settings, including:
*
* The optimal TCP buffer sizes for a particular application are highly dependent on network
* configuration and operating system configuration and capabilities. For example, most modern
* operating systems provide auto-tuning functionality for TCP buffer sizes, which can have a
* big impact on performance for TCP connections that are held open long enough for the
* auto-tuning to optimize buffer sizes.
*
* Large buffer sizes (ex: 2MB) will allow the operating system to buffer more data in memory
* without requiring the remote server to acknowledge receipt of that information, so can be
* particularly useful when the network has high latency.
*
* This is only a hint, and the operating system may choose not to honor it. When using
* this option, users should always check the operating system's configured limits and
* defaults. Most OS's have a maximum TCP buffer size limit configured, and won't let you go
* beyond that limit unless you explicitly raise the max TCP buffer size limit.
*
* There are many resources available online to help with configuring TCP buffer sizes and
* operating system specific TCP settings, including:
*
* This is an advanced option for advanced users who want to tune low level TCP parameters to
* try and squeeze out more performance.
*
* The optimal TCP buffer sizes for a particular application are highly dependent on network
* configuration and operating system configuration and capabilities. For example, most modern
* operating systems provide auto-tuning functionality for TCP buffer sizes, which can have a
* big impact on performance for TCP connections that are held open long enough for the
* auto-tuning to optimize buffer sizes.
*
* Large buffer sizes (ex: 2MB) will allow the operating system to buffer more data in memory
* without requiring the remote server to acknowledge receipt of that information, so can be
* particularly useful when the network has high latency.
*
* This is only a hint, and the operating system may choose not to honor it. When using
* this option, users should always check the operating system's configured limits and
* defaults. Most OS's have a maximum TCP buffer size limit configured, and won't let you go
* beyond that limit unless you explicitly raise the max TCP buffer size limit.
*
* There are many resources available online to help with configuring TCP buffer sizes and
* operating system specific TCP settings, including:
*
* Most users do not need to concern themselves with which signature algorithm is being used, as
* the defaults will be sufficient. This setting exists only so advanced users can opt in to
* newer signature protocols which have not yet been made the default for a particular
* service/region.
*
* Not all services support all signature algorithms, and configuring an unsupported signature
* algorithm will lead to authentication failures. Use me at your own risk, and only after
* consulting the documentation for the service to ensure it actually does supports your chosen
* algorithm.
*
* If non-null, the name returned from this method is used to look up a {@code Signer} class
* implementing the chosen algorithm by the {@code com.amazonaws.auth.SignerFactory} class.
*
* @return The signature algorithm to use for this client, or null to use the default.
*/
public String getSignerOverride() {
return signerOverride;
}
/**
* Sets the name of the signature algorithm to use for signing requests made by this client. If
* not set or explicitly set to null, the client will choose a signature algorithm to use based
* on a configuration file of supported signature algorithms for the service and region.
*
* Most users do not need to concern themselves with which signature algorithm is being used, as
* the defaults will be sufficient. This setting exists only so advanced users can opt in to
* newer signature protocols which have not yet been made the default for a particular
* service/region.
*
* Not all services support all signature algorithms, and configuring an unsupported signature
* algorithm will lead to authentication failures. Use me at your own risk, and only after
* consulting the documentation for the service to ensure it actually does supports your chosen
* algorithm.
*
* If non-null, the name returned from this method is used to look up a {@code Signer} class
* implementing the chosen algorithm by the {@code com.amazonaws.auth.SignerFactory} class.
*
* @param value
* The signature algorithm to use for this client, or null to use the default.
*/
public void setSignerOverride(final String value) {
signerOverride = value;
}
/**
* Sets the name of the signature algorithm to use for signing requests made by this client. If
* not set or explicitly set to null, the client will choose a signature algorithm to use based
* on a configuration file of supported signature algorithms for the service and region.
*
* Most users do not need to concern themselves with which signature algorithm is being used, as
* the defaults will be sufficient. This setting exists only so advanced users can opt in to
* newer signature protocols which have not yet been made the default for a particular
* service/region.
*
* Not all services support all signature algorithms, and configuring an unsupported signature
* algorithm will lead to authentication failures. Use me at your own risk, and only after
* consulting the documentation for the service to ensure it actually does supports your chosen
* algorithm.
*
* If non-null, the name returned from this method is used to look up a {@code Signer} class
* implementing the chosen algorithm by the {@code com.amazonaws.auth.SignerFactory} class.
*
* @param value
* The signature algorithm to use for this client, or null to use the default.
* @return The updated ClientConfiguration object.
*/
public ClientConfiguration withSignerOverride(final String value) {
setSignerOverride(value);
return this;
}
/**
* Returns whether to attempt to authenticate preemptively against proxy servers using basic
* authentication
*
* @return Whether to authenticate preemptively against proxy server.
*/
public boolean isPreemptiveBasicProxyAuth() {
return preemptiveBasicProxyAuth;
}
/**
* Sets whether to attempt to authenticate preemptively against proxy servers using basic
* authentication
*
* @param preemptiveBasicProxyAuth
* Whether to authenticate preemptively against proxy server.
*/
public void setPreemptiveBasicProxyAuth(Boolean preemptiveBasicProxyAuth) {
this.preemptiveBasicProxyAuth = preemptiveBasicProxyAuth;
}
/**
* Sets whether to attempt to authenticate preemptively against proxy servers using basic
* authentication, and returns the updated ClientConfiguration object so that additional method
* calls may be chained together.
*
* @param preemptiveBasicProxyAuth
* Whether to authenticate preemptively against proxy server.
* @return The updated ClientConfiguration object.
*/
public ClientConfiguration withPreemptiveBasicProxyAuth(boolean preemptiveBasicProxyAuth) {
setPreemptiveBasicProxyAuth(preemptiveBasicProxyAuth);
return this;
}
/**
* Returns the expiration time (in milliseconds) for a connection in the connection pool. When
* retrieving a connection from the pool to make a request, the total time that the connection
* has been open is compared against this value. Connections which have been open for longer are
* discarded, and if needed a new connection is created.
*
* Tuning this setting down (together with an appropriately-low setting for Java's DNS cache
* TTL) ensures that your application will quickly rotate over to new IP addresses when the
* service begins announcing them through DNS, at the cost of having to re-establish new
* connections more frequently.
*
* @return the connection TTL, in milliseconds
*/
public long getConnectionTTL() {
return connectionTTL;
}
/**
* Sets the expiration time (in milliseconds) for a connection in the connection pool. When
* retrieving a connection from the pool to make a request, the total time that the connection
* has been open is compared against this value. Connections which have been open for longer are
* discarded, and if needed a new connection is created.
*
* Tuning this setting down (together with an appropriately-low setting for Java's DNS cache
* TTL) ensures that your application will quickly rotate over to new IP addresses when the
* service begins announcing them through DNS, at the cost of having to re-establish new
* connections more frequently.
*
* By default, it is set to {@code -1], i.e. connections do not expire.
*
* @param connectionTTL
* the connection TTL, in milliseconds
*/
public void setConnectionTTL(long connectionTTL) {
this.connectionTTL = connectionTTL;
}
/**
* Sets the expiration time (in milliseconds) for a connection in the connection pool. When
* retrieving a connection from the pool to make a request, the total time that the connection
* has been open is compared against this value. Connections which have been open for longer are
* discarded, and if needed a new connection is created.
*
* Tuning this setting down (together with an appropriately-low setting for Java's DNS cache
* TTL) ensures that your application will quickly rotate over to new IP addresses when the
* service begins announcing them through DNS, at the cost of having to re-establish new
* connections more frequently.
*
* By default, it is set to {@code -1}, i.e. connections do not expire.
*
* @param connectionTTL
* the connection TTL, in milliseconds
* @return the updated ClientConfiguration object
*/
public ClientConfiguration withConnectionTTL(long connectionTTL) {
setConnectionTTL(connectionTTL);
return this;
}
/**
* Returns the maximum amount of time that an idle connection may sit in the connection pool and
* still be eligible for reuse. When retrieving a connection from the pool to make a request,
* the amount of time the connection has been idle is compared against this value. Connections
* which have been idle for longer are discarded, and if needed a new connection is created.
*
* Tuning this setting down reduces the likelihood of a race condition (wherein you begin
* sending a request down a connection which appears to be healthy, but before it arrives the
* service decides the connection has been idle for too long and closes it) at the cost of
* having to re-establish new connections more frequently.
*
* @return the connection maximum idle time, in milliseconds
*/
public long getConnectionMaxIdleMillis() {
return connectionMaxIdleMillis;
}
/**
* Sets the maximum amount of time that an idle connection may sit in the connection pool and
* still be eligible for reuse. When retrieving a connection from the pool to make a request,
* the amount of time the connection has been idle is compared against this value. Connections
* which have been idle for longer are discarded, and if needed a new connection is created.
*
* Tuning this setting down reduces the likelihood of a race condition (wherein you begin
* sending a request down a connection which appears to be healthy, but before it arrives the
* service decides the connection has been idle for too long and closes it) at the cost of
* having to re-establish new connections more frequently.
*
* By default, it is set to one minute (60000ms).
*
* @param connectionMaxIdleMillis
* the connection maximum idle time, in milliseconds
*/
public void setConnectionMaxIdleMillis(long connectionMaxIdleMillis) {
this.connectionMaxIdleMillis = connectionMaxIdleMillis;
}
/**
* Sets the maximum amount of time that an idle connection may sit in the connection pool and
* still be eligible for reuse. When retrieving a connection from the pool to make a request,
* the amount of time the connection has been idle is compared against this value. Connections
* which have been idle for longer are discarded, and if needed a new connection is created.
*
* Tuning this setting down reduces the likelihood of a race condition (wherein you begin
* sending a request down a connection which appears to be healthy, but before it arrives the
* service decides the connection has been idle for too long and closes it) at the cost of
* having to re-establish new connections more frequently.
*
* By default, it is set to one minute (60000ms).
*
* @param connectionMaxIdleMillis
* the connection maximum idle time, in milliseconds
* @return the updated ClientConfiguration object
*/
public ClientConfiguration withConnectionMaxIdleMillis(long connectionMaxIdleMillis) {
setConnectionMaxIdleMillis(connectionMaxIdleMillis);
return this;
}
/**
* Returns the amount of time (in milliseconds) that a connection can be idle in the connection pool before it must be
* validated to ensure it's still open. This "stale connection check" adds a small bit of overhead to validate the
* connection. Setting this value to larger values may increase the likelihood that the connection is not usable, potentially
* resulting in a {@link org.apache.http.NoHttpResponseException}. Lowering this setting increases the overhead when leasing
* connections from the connection pool. It is recommended to tune this setting based on how long a service allows a
* connection to be idle before closing.
*
* A non positive value disables validation of connections. The default value is {@value #DEFAULT_VALIDATE_AFTER_INACTIVITY_MILLIS} milliseconds. A non positive value disables validation of connections. The default value is {@value #DEFAULT_VALIDATE_AFTER_INACTIVITY_MILLIS} milliseconds. A non positive value disables validation of connections. The default value is {@value #DEFAULT_VALIDATE_AFTER_INACTIVITY_MILLIS} milliseconds.
* Response metadata is typically used for troubleshooting issues with AWS support staff when
* services aren't acting as expected.
*
* While this feature is useful for debugging it adds overhead and disabling it may
* be desired in high throughput applications.
*
* Response metadata is typically used for troubleshooting issues with AWS support staff when
* services aren't acting as expected.
*
* While this feature is useful for debugging it adds overhead and disabling it may
* be desired in high throughput applications.
*
* Response metadata is typically used for troubleshooting issues with AWS support staff when
* services aren't acting as expected.
*
* While this feature is useful for debugging it adds overhead and disabling it may
* be desired in high throughput applications.
*
* The default is {@link SystemPropertyTlsKeyManagersProvider}.
*/
public TlsKeyManagersProvider getTlsKeyManagersProvider() {
return tlsKeyManagersProvider;
}
/**
* Sets {@link TlsKeyManagersProvider} that will provide the {@link javax.net.ssl.KeyManager}s to use when
* constructing the client's SSL context.
*
* The default is {@link SystemPropertyTlsKeyManagersProvider}.
*/
public ClientConfiguration withTlsKeyManagersProvider(TlsKeyManagersProvider tlsKeyManagersProvider) {
this.tlsKeyManagersProvider = tlsKeyManagersProvider;
return this;
}
/**
* Sets {@link TlsKeyManagersProvider} that will provide the {@link javax.net.ssl.KeyManager}s to use when
* constructing the client's SSL context.
*
* The default used by the client will be {@link SystemPropertyTlsKeyManagersProvider}. Set an instance {@link
* com.amazonaws.http.NoneTlsKeyManagersProvider} or another instance of {@link TlsKeyManagersProvider} to override
* it.
*/
public void setTlsKeyManagersProvider(TlsKeyManagersProvider tlsKeyManagersProvider) {
withTlsKeyManagersProvider(tlsKeyManagersProvider);
}
private URL getHttpProxyEnvironmentVariable() {
if (getProtocol() == Protocol.HTTP) {
return getUrlEnvVar(httpProxyHolder, "HTTP_PROXY");
}
return getUrlEnvVar(httpsProxyHolder, "HTTPS_PROXY");
}
private URL getUrlEnvVar(AtomicReference
*
*
* @return A two element array containing first the TCP send buffer size hint and then the TCP
* receive buffer size hint.
*/
public int[] getSocketBufferSizeHints() {
return new int[] { socketSendBufferSizeHint, socketReceiveBufferSizeHint };
}
/**
* Sets the optional size hints (in bytes) for the low level TCP send and receive buffers. This
* is an advanced option for advanced users who want to tune low level TCP parameters to try and
* squeeze out more performance.
*
*
*
* @param socketSendBufferSizeHint
* The size hint (in bytes) for the low level TCP send buffer.
* @param socketReceiveBufferSizeHint
* The size hint (in bytes) for the low level TCP receive buffer.
*/
public void setSocketBufferSizeHints(int socketSendBufferSizeHint, int socketReceiveBufferSizeHint) {
this.socketSendBufferSizeHint = socketSendBufferSizeHint;
this.socketReceiveBufferSizeHint = socketReceiveBufferSizeHint;
}
/**
* Sets the optional size hints (in bytes) for the low level TCP send and receive buffers, and
* returns the updated ClientConfiguration object so that additional method calls may be chained
* together.
*
*
*
* @param socketSendBufferSizeHint
* The size hint (in bytes) for the low level TCP send buffer.
* @param socketReceiveBufferSizeHint
* The size hint (in bytes) for the low level TCP receive buffer.
* @return The updated ClientConfiguration object.
*/
public ClientConfiguration withSocketBufferSizeHints(int socketSendBufferSizeHint,
int socketReceiveBufferSizeHint) {
setSocketBufferSizeHints(socketSendBufferSizeHint, socketReceiveBufferSizeHint);
return this;
}
/**
* Returns the name of the signature algorithm to use for signing requests made by this client.
* If not set or explicitly set to null, the client will choose a signature algorithm to use
* based on a configuration file of supported signature algorithms for the service and region.
*