diff --git a/client/src/main/java/org/asynchttpclient/DefaultAsyncHttpClientConfig.java b/client/src/main/java/org/asynchttpclient/DefaultAsyncHttpClientConfig.java index 17e8777c01..ef81c5fac5 100644 --- a/client/src/main/java/org/asynchttpclient/DefaultAsyncHttpClientConfig.java +++ b/client/src/main/java/org/asynchttpclient/DefaultAsyncHttpClientConfig.java @@ -21,6 +21,12 @@ import io.netty.channel.EventLoopGroup; import io.netty.handler.ssl.SslContext; import io.netty.util.Timer; +import static org.asynchttpclient.config.AsyncHttpClientConfigDefaults.*; + +import java.util.*; +import java.util.concurrent.ThreadFactory; +import java.util.function.Consumer; + import org.asynchttpclient.channel.ChannelPool; import org.asynchttpclient.channel.DefaultKeepAliveStrategy; import org.asynchttpclient.channel.KeepAliveStrategy; @@ -33,14 +39,6 @@ import org.asynchttpclient.proxy.ProxyServerSelector; import org.asynchttpclient.util.ProxyUtils; -import java.io.IOException; -import java.io.InputStream; -import java.util.*; -import java.util.concurrent.ThreadFactory; -import java.util.function.Consumer; - -import static org.asynchttpclient.config.AsyncHttpClientConfigDefaults.*; - /** * Configuration class to use with a {@link AsyncHttpClient}. System property can be also used to configure this object default behavior by doing:
* -Dorg.asynchttpclient.nameOfTheProperty @@ -49,18 +47,6 @@ */ public class DefaultAsyncHttpClientConfig implements AsyncHttpClientConfig { - private static final String AHC_VERSION; - - static { - try (InputStream is = DefaultAsyncHttpClientConfig.class.getResourceAsStream("/ahc-version.properties")) { - Properties prop = new Properties(); - prop.load(is); - AHC_VERSION = prop.getProperty("ahc.version", "UNKNOWN"); - } catch (IOException e) { - throw new ExceptionInInitializerError(e); - } - } - // http private final boolean followRedirect; private final int maxRedirects; diff --git a/client/src/main/java/org/asynchttpclient/PropertiesAsyncHttpClientConfig.java b/client/src/main/java/org/asynchttpclient/PropertiesAsyncHttpClientConfig.java new file mode 100644 index 0000000000..997cb76b65 --- /dev/null +++ b/client/src/main/java/org/asynchttpclient/PropertiesAsyncHttpClientConfig.java @@ -0,0 +1,373 @@ +/* + * Copyright (c) 2015 AsyncHttpClient Project. All rights reserved. + * + * This program is licensed to you under the Apache License Version 2.0, + * and you may not use this file except in compliance with the Apache License Version 2.0. + * You may obtain a copy of the Apache License Version 2.0 at + * http://www.apache.org/licenses/LICENSE-2.0. + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the Apache License Version 2.0 is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the Apache License Version 2.0 for the specific language governing permissions and limitations there under. + */ +package org.asynchttpclient; + +import io.netty.buffer.ByteBufAllocator; +import io.netty.channel.Channel; +import io.netty.channel.ChannelOption; +import io.netty.channel.EventLoopGroup; +import io.netty.handler.ssl.SslContext; +import io.netty.util.Timer; +import org.asynchttpclient.channel.ChannelPool; +import org.asynchttpclient.channel.DefaultKeepAliveStrategy; +import org.asynchttpclient.channel.KeepAliveStrategy; +import org.asynchttpclient.config.AsyncHttpClientConfigDefaults; +import org.asynchttpclient.config.AsyncHttpClientConfigHelper; +import org.asynchttpclient.cookie.CookieStore; +import org.asynchttpclient.cookie.ThreadSafeCookieStore; +import org.asynchttpclient.filter.IOExceptionFilter; +import org.asynchttpclient.filter.RequestFilter; +import org.asynchttpclient.filter.ResponseFilter; +import org.asynchttpclient.proxy.ProxyServerSelector; + +import java.util.*; +import java.util.concurrent.ThreadFactory; +import java.util.function.Consumer; + +import static org.asynchttpclient.config.AsyncHttpClientConfigDefaults.*; + +public class PropertiesAsyncHttpClientConfig implements AsyncHttpClientConfig { + + private final AsyncHttpClientConfigHelper.Config config; + + public PropertiesAsyncHttpClientConfig(Properties properties) { + this.config = new AsyncHttpClientConfigHelper.Config(properties); + } + + @Override + public String getAhcVersion() { + return AsyncHttpClientConfigDefaults.AHC_VERSION; + } + + @Override + public String getThreadPoolName() { + return config.getStringOpt(THREAD_POOL_NAME_CONFIG).orElse(defaultThreadPoolName()); + } + + @Override + public int getMaxConnections() { + return config.getIntOpt(MAX_CONNECTIONS_CONFIG).orElse(defaultMaxConnections()); + } + + @Override + public int getMaxConnectionsPerHost() { + return config.getIntOpt(MAX_CONNECTIONS_PER_HOST_CONFIG).orElse(defaultMaxConnectionsPerHost()); + } + + @Override + public int getConnectTimeout() { + return config.getIntOpt(CONNECTION_TIMEOUT_CONFIG).orElse(defaultConnectTimeout()); + } + + @Override + public int getReadTimeout() { + return config.getIntOpt(READ_TIMEOUT_CONFIG).orElse(defaultReadTimeout()); + } + + @Override + public int getPooledConnectionIdleTimeout() { + return config.getIntOpt(POOLED_CONNECTION_IDLE_TIMEOUT_CONFIG).orElse(defaultPooledConnectionIdleTimeout()); + } + + @Override + public int getConnectionPoolCleanerPeriod() { + return config.getIntOpt(CONNECTION_POOL_CLEANER_PERIOD_CONFIG).orElse(defaultConnectionPoolCleanerPeriod()); + } + + @Override + public int getRequestTimeout() { + return config.getIntOpt(REQUEST_TIMEOUT_CONFIG).orElse(defaultReadTimeout()); + } + + @Override + public boolean isFollowRedirect() { + return config.getBooleanOpt(FOLLOW_REDIRECT_CONFIG).orElse(defaultFollowRedirect()); + } + + @Override + public int getMaxRedirects() { + return config.getIntOpt(MAX_REDIRECT_CONFIG).orElse(defaultMaxRedirects()); + } + + @Override + public boolean isKeepAlive() { + return config.getBooleanOpt(KEEP_ALIVE_CONFIG).orElse(defaultKeepAlive()); + } + + @Override + public String getUserAgent() { + return config.getStringOpt(USER_AGENT_CONFIG).orElse(defaultUserAgent()); + } + + @Override + public boolean isCompressionEnforced() { + return config.getBooleanOpt(COMPRESSION_ENFORCED_CONFIG).orElse(defaultCompressionEnforced()); + } + + @Override + public ThreadFactory getThreadFactory() { + return null; + } + + @Override + public ProxyServerSelector getProxyServerSelector() { + return ProxyServerSelector.NO_PROXY_SELECTOR; + } + + @Override + public SslContext getSslContext() { + return null; + } + + @Override + public Realm getRealm() { + return null; + } + + @Override + public List getRequestFilters() { + return new LinkedList<>(); + } + + @Override + public List getResponseFilters() { + return new LinkedList<>(); + } + + @Override + public List getIoExceptionFilters() { + return new LinkedList<>(); + } + + @Override + public CookieStore getCookieStore() { + return new ThreadSafeCookieStore(); + } + + @Override + public int getMaxRequestRetry() { + return config.getIntOpt(MAX_REQUEST_RETRY_CONFIG).orElse(defaultMaxRequestRetry()); + } + + @Override + public boolean isDisableUrlEncodingForBoundRequests() { + return config.getBooleanOpt(DISABLE_URL_ENCODING_FOR_BOUND_REQUESTS_CONFIG).orElse(defaultDisableUrlEncodingForBoundRequests()); + } + + @Override + public boolean isUseLaxCookieEncoder() { + return config.getBooleanOpt(USE_LAX_COOKIE_ENCODER_CONFIG).orElse(defaultUseLaxCookieEncoder()); + } + + @Override + public boolean isStrict302Handling() { + return config.getBooleanOpt(STRICT_302_HANDLING_CONFIG).orElse(defaultStrict302Handling()); + } + + @Override + public int getConnectionTtl() { + return config.getIntOpt(CONNECTION_TTL_CONFIG).orElse(defaultConnectionTtl()); + } + + @Override + public boolean isUseOpenSsl() { + return config.getBooleanOpt(USE_OPEN_SSL_CONFIG).orElse(defaultUseOpenSsl()); + } + + @Override + public boolean isUseInsecureTrustManager() { + return config.getBooleanOpt(USE_INSECURE_TRUST_MANAGER_CONFIG).orElse(defaultUseInsecureTrustManager()); + } + + @Override + public boolean isDisableHttpsEndpointIdentificationAlgorithm() { + return config.getBooleanOpt(DISABLE_HTTPS_ENDPOINT_IDENTIFICATION_ALGORITHM_CONFIG).orElse(defaultDisableHttpsEndpointIdentificationAlgorithm()); + } + + @Override + public String[] getEnabledProtocols() { + return config.getStringArrayOpt(ENABLED_PROTOCOLS_CONFIG).orElse(defaultEnabledProtocols()); + } + + @Override + public String[] getEnabledCipherSuites() { + return config.getStringArrayOpt(ENABLED_CIPHER_SUITES_CONFIG).orElse(defaultEnabledCipherSuites()); + } + + @Override + public int getSslSessionCacheSize() { + return config.getIntOpt(SSL_SESSION_CACHE_SIZE_CONFIG).orElse(defaultSslSessionCacheSize()); + } + + @Override + public int getSslSessionTimeout() { + return config.getIntOpt(SSL_SESSION_TIMEOUT_CONFIG).orElse(defaultSslSessionTimeout()); + } + + @Override + public int getHttpClientCodecMaxInitialLineLength() { + return config.getIntOpt(HTTP_CLIENT_CODEC_MAX_INITIAL_LINE_LENGTH_CONFIG).orElse(defaultHttpClientCodecMaxInitialLineLength()); + } + + @Override + public int getHttpClientCodecMaxHeaderSize() { + return config.getIntOpt(HTTP_CLIENT_CODEC_MAX_HEADER_SIZE_CONFIG).orElse(defaultHttpClientCodecMaxHeaderSize()); + } + + @Override + public int getHttpClientCodecMaxChunkSize() { + return config.getIntOpt(HTTP_CLIENT_CODEC_MAX_CHUNK_SIZE_CONFIG).orElse(defaultHttpClientCodecMaxChunkSize()); + } + + @Override + public int getHttpClientCodecInitialBufferSize() { + return config.getIntOpt(HTTP_CLIENT_CODEC_INITIAL_BUFFER_SIZE_CONFIG).orElse(defaultHttpClientCodecInitialBufferSize()); + } + + @Override + public boolean isDisableZeroCopy() { + return config.getBooleanOpt(DISABLE_ZERO_COPY_CONFIG).orElse(defaultDisableZeroCopy()); + } + + @Override + public int getHandshakeTimeout() { + return config.getIntOpt(HANDSHAKE_TIMEOUT_CONFIG).orElse(defaultHandshakeTimeout()); + } + + @Override + public SslEngineFactory getSslEngineFactory() { + return null; + } + + @Override + public int getChunkedFileChunkSize() { + return config.getIntOpt(CHUNKED_FILE_CHUNK_SIZE_CONFIG).orElse(defaultChunkedFileChunkSize()); + } + + @Override + public int getWebSocketMaxBufferSize() { + return config.getIntOpt(WEB_SOCKET_MAX_BUFFER_SIZE_CONFIG).orElse(defaultWebSocketMaxBufferSize()); + } + + @Override + public int getWebSocketMaxFrameSize() { + return config.getIntOpt(WEB_SOCKET_MAX_FRAME_SIZE_CONFIG).orElse(defaultWebSocketMaxFrameSize()); + } + + @Override + public boolean isKeepEncodingHeader() { + return config.getBooleanOpt(KEEP_ENCODING_HEADER_CONFIG).orElse(defaultKeepEncodingHeader()); + } + + @Override + public int getShutdownQuietPeriod() { + return config.getIntOpt(SHUTDOWN_QUIET_PERIOD_CONFIG).orElse(defaultShutdownQuietPeriod()); + } + + @Override + public int getShutdownTimeout() { + return config.getIntOpt(SHUTDOWN_TIMEOUT_CONFIG).orElse(defaultShutdownTimeout()); + } + + @Override + public Map, Object> getChannelOptions() { + return Collections.emptyMap(); + } + + @Override + public EventLoopGroup getEventLoopGroup() { + return null; + } + + @Override + public boolean isUseNativeTransport() { + return config.getBooleanOpt(USE_NATIVE_TRANSPORT_CONFIG).orElse(defaultUseNativeTransport()); + } + + @Override + public Consumer getHttpAdditionalChannelInitializer() { + return null; + } + + @Override + public Consumer getWsAdditionalChannelInitializer() { + return null; + } + + @Override + public ResponseBodyPartFactory getResponseBodyPartFactory() { + return ResponseBodyPartFactory.EAGER; + } + + @Override + public ChannelPool getChannelPool() { + return null; + } + + @Override + public Timer getNettyTimer() { + return null; + } + + @Override + public KeepAliveStrategy getKeepAliveStrategy() { + return new DefaultKeepAliveStrategy(); + } + + @Override + public boolean isValidateResponseHeaders() { + return config.getBooleanOpt(VALIDATE_RESPONSE_HEADERS_CONFIG).orElse(defaultValidateResponseHeaders()); + } + + @Override + public boolean isAggregateWebSocketFrameFragments() { + return config.getBooleanOpt(AGGREGATE_WEB_SOCKET_FRAME_FRAGMENTS_CONFIG).orElse(defaultAggregateWebSocketFrameFragments()); + } + + @Override + public boolean isTcpNoDelay() { + return config.getBooleanOpt(TCP_NO_DELAY_CONFIG).orElse(defaultTcpNoDelay()); + } + + @Override + public boolean isSoReuseAddress() { + return config.getBooleanOpt(SO_REUSE_ADDRESS_CONFIG).orElse(defaultSoReuseAddress()); + } + + @Override + public int getSoLinger() { + return config.getIntOpt(SO_LINGER_CONFIG).orElse(defaultSoLinger()); + } + + @Override + public int getSoSndBuf() { + return config.getIntOpt(SO_SND_BUF_CONFIG).orElse(defaultSoSndBuf()); + } + + @Override + public int getSoRcvBuf() { + return config.getIntOpt(SO_RCV_BUF_CONFIG).orElse(defaultSoRcvBuf()); + } + + @Override + public ByteBufAllocator getAllocator() { + return null; + } + + @Override + public int getIoThreadsCount() { + return config.getIntOpt(IO_THREADS_COUNT_CONFIG).orElse(defaultIoThreadsCount()); + } + +} diff --git a/client/src/main/java/org/asynchttpclient/config/AsyncHttpClientConfigDefaults.java b/client/src/main/java/org/asynchttpclient/config/AsyncHttpClientConfigDefaults.java index 1a8e8a38ff..847a28a9d2 100644 --- a/client/src/main/java/org/asynchttpclient/config/AsyncHttpClientConfigDefaults.java +++ b/client/src/main/java/org/asynchttpclient/config/AsyncHttpClientConfigDefaults.java @@ -12,202 +12,268 @@ */ package org.asynchttpclient.config; +import org.asynchttpclient.DefaultAsyncHttpClientConfig; + +import java.io.IOException; +import java.io.InputStream; +import java.util.Properties; + public final class AsyncHttpClientConfigDefaults { - public static final String ASYNC_CLIENT_CONFIG_ROOT = "org.asynchttpclient."; + public static final String AHC_VERSION; + + static { + try (InputStream is = DefaultAsyncHttpClientConfig.class.getResourceAsStream("/ahc-version.properties")) { + Properties prop = new Properties(); + prop.load(is); + AHC_VERSION = prop.getProperty("ahc.version", "UNKNOWN"); + } catch (IOException e) { + throw new ExceptionInInitializerError(e); + } + } private AsyncHttpClientConfigDefaults() { } + public static final String ASYNC_CLIENT_CONFIG_ROOT = "org.asynchttpclient."; + public static final String THREAD_POOL_NAME_CONFIG = "threadPoolName"; + public static final String MAX_CONNECTIONS_CONFIG = "maxConnections"; + public static final String MAX_CONNECTIONS_PER_HOST_CONFIG = "maxConnectionsPerHost"; + public static final String CONNECTION_TIMEOUT_CONFIG = "connectTimeout"; + public static final String POOLED_CONNECTION_IDLE_TIMEOUT_CONFIG = "pooledConnectionIdleTimeout"; + public static final String CONNECTION_POOL_CLEANER_PERIOD_CONFIG = "connectionPoolCleanerPeriod"; + public static final String READ_TIMEOUT_CONFIG = "readTimeout"; + public static final String REQUEST_TIMEOUT_CONFIG = "requestTimeout"; + public static final String CONNECTION_TTL_CONFIG = "connectionTtl"; + public static final String FOLLOW_REDIRECT_CONFIG = "followRedirect"; + public static final String MAX_REDIRECT_CONFIG = "maxRedirects"; + public static final String COMPRESSION_ENFORCED_CONFIG = "compressionEnforced"; + public static final String USER_AGENT_CONFIG = "userAgent"; + public static final String ENABLED_PROTOCOLS_CONFIG = "enabledProtocols"; + public static final String ENABLED_CIPHER_SUITES_CONFIG = "enabledCipherSuites"; + public static final String USE_PROXY_SELECTOR_CONFIG = "useProxySelector"; + public static final String USE_PROXY_PROPERTIES_CONFIG = "useProxyProperties"; + public static final String VALIDATE_RESPONSE_HEADERS_CONFIG = "validateResponseHeaders"; + public static final String AGGREGATE_WEB_SOCKET_FRAME_FRAGMENTS_CONFIG = "aggregateWebSocketFrameFragments"; + public static final String STRICT_302_HANDLING_CONFIG = "strict302Handling"; + public static final String KEEP_ALIVE_CONFIG = "keepAlive"; + public static final String MAX_REQUEST_RETRY_CONFIG = "maxRequestRetry"; + public static final String DISABLE_URL_ENCODING_FOR_BOUND_REQUESTS_CONFIG = "disableUrlEncodingForBoundRequests"; + public static final String USE_LAX_COOKIE_ENCODER_CONFIG = "useLaxCookieEncoder"; + public static final String USE_OPEN_SSL_CONFIG = "useOpenSsl"; + public static final String USE_INSECURE_TRUST_MANAGER_CONFIG = "useInsecureTrustManager"; + public static final String DISABLE_HTTPS_ENDPOINT_IDENTIFICATION_ALGORITHM_CONFIG = "disableHttpsEndpointIdentificationAlgorithm"; + public static final String SSL_SESSION_CACHE_SIZE_CONFIG = "sslSessionCacheSize"; + public static final String SSL_SESSION_TIMEOUT_CONFIG = "sslSessionTimeout"; + public static final String TCP_NO_DELAY_CONFIG = "tcpNoDelay"; + public static final String SO_REUSE_ADDRESS_CONFIG = "soReuseAddress"; + public static final String SO_LINGER_CONFIG = "soLinger"; + public static final String SO_SND_BUF_CONFIG = "soSndBuf"; + public static final String SO_RCV_BUF_CONFIG = "soRcvBuf"; + public static final String HTTP_CLIENT_CODEC_MAX_INITIAL_LINE_LENGTH_CONFIG = "httpClientCodecMaxInitialLineLength"; + public static final String HTTP_CLIENT_CODEC_MAX_HEADER_SIZE_CONFIG = "httpClientCodecMaxHeaderSize"; + public static final String HTTP_CLIENT_CODEC_MAX_CHUNK_SIZE_CONFIG = "httpClientCodecMaxChunkSize"; + public static final String HTTP_CLIENT_CODEC_INITIAL_BUFFER_SIZE_CONFIG = "httpClientCodecInitialBufferSize"; + public static final String DISABLE_ZERO_COPY_CONFIG = "disableZeroCopy"; + public static final String HANDSHAKE_TIMEOUT_CONFIG = "handshakeTimeout"; + public static final String CHUNKED_FILE_CHUNK_SIZE_CONFIG = "chunkedFileChunkSize"; + public static final String WEB_SOCKET_MAX_BUFFER_SIZE_CONFIG = "webSocketMaxBufferSize"; + public static final String WEB_SOCKET_MAX_FRAME_SIZE_CONFIG = "webSocketMaxFrameSize"; + public static final String KEEP_ENCODING_HEADER_CONFIG = "keepEncodingHeader"; + public static final String SHUTDOWN_QUIET_PERIOD_CONFIG = "shutdownQuietPeriod"; + public static final String SHUTDOWN_TIMEOUT_CONFIG = "shutdownTimeout"; + public static final String USE_NATIVE_TRANSPORT_CONFIG = "useNativeTransport"; + public static final String IO_THREADS_COUNT_CONFIG = "ioThreadsCount"; + public static String defaultThreadPoolName() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getString(ASYNC_CLIENT_CONFIG_ROOT + "threadPoolName"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getString(ASYNC_CLIENT_CONFIG_ROOT + THREAD_POOL_NAME_CONFIG); } public static int defaultMaxConnections() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "maxConnections"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + MAX_CONNECTIONS_CONFIG); } public static int defaultMaxConnectionsPerHost() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "maxConnectionsPerHost"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + MAX_CONNECTIONS_PER_HOST_CONFIG); } public static int defaultConnectTimeout() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "connectTimeout"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + CONNECTION_TIMEOUT_CONFIG); } public static int defaultPooledConnectionIdleTimeout() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "pooledConnectionIdleTimeout"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + POOLED_CONNECTION_IDLE_TIMEOUT_CONFIG); } public static int defaultConnectionPoolCleanerPeriod() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "connectionPoolCleanerPeriod"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + CONNECTION_POOL_CLEANER_PERIOD_CONFIG); } public static int defaultReadTimeout() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "readTimeout"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + READ_TIMEOUT_CONFIG); } public static int defaultRequestTimeout() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "requestTimeout"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + REQUEST_TIMEOUT_CONFIG); } public static int defaultConnectionTtl() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "connectionTtl"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + CONNECTION_TTL_CONFIG); } public static boolean defaultFollowRedirect() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + "followRedirect"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + FOLLOW_REDIRECT_CONFIG); } public static int defaultMaxRedirects() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "maxRedirects"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + MAX_REDIRECT_CONFIG); } public static boolean defaultCompressionEnforced() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + "compressionEnforced"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + COMPRESSION_ENFORCED_CONFIG); } public static String defaultUserAgent() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getString(ASYNC_CLIENT_CONFIG_ROOT + "userAgent"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getString(ASYNC_CLIENT_CONFIG_ROOT + USER_AGENT_CONFIG); } public static String[] defaultEnabledProtocols() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getStringArray(ASYNC_CLIENT_CONFIG_ROOT + "enabledProtocols"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getStringArray(ASYNC_CLIENT_CONFIG_ROOT + ENABLED_PROTOCOLS_CONFIG); } public static String[] defaultEnabledCipherSuites() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getStringArray(ASYNC_CLIENT_CONFIG_ROOT + "enabledCipherSuites"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getStringArray(ASYNC_CLIENT_CONFIG_ROOT + ENABLED_CIPHER_SUITES_CONFIG); } public static boolean defaultUseProxySelector() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + "useProxySelector"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + USE_PROXY_SELECTOR_CONFIG); } public static boolean defaultUseProxyProperties() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + "useProxyProperties"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + USE_PROXY_PROPERTIES_CONFIG); } public static boolean defaultValidateResponseHeaders() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + "validateResponseHeaders"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + VALIDATE_RESPONSE_HEADERS_CONFIG); } public static boolean defaultAggregateWebSocketFrameFragments() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + "aggregateWebSocketFrameFragments"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + AGGREGATE_WEB_SOCKET_FRAME_FRAGMENTS_CONFIG); } public static boolean defaultStrict302Handling() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + "strict302Handling"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + STRICT_302_HANDLING_CONFIG); } public static boolean defaultKeepAlive() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + "keepAlive"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + KEEP_ALIVE_CONFIG); } public static int defaultMaxRequestRetry() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "maxRequestRetry"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + MAX_REQUEST_RETRY_CONFIG); } public static boolean defaultDisableUrlEncodingForBoundRequests() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + "disableUrlEncodingForBoundRequests"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + DISABLE_URL_ENCODING_FOR_BOUND_REQUESTS_CONFIG); } public static boolean defaultUseLaxCookieEncoder() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + "useLaxCookieEncoder"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + USE_LAX_COOKIE_ENCODER_CONFIG); } public static boolean defaultUseOpenSsl() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + "useOpenSsl"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + USE_OPEN_SSL_CONFIG); } public static boolean defaultUseInsecureTrustManager() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + "useInsecureTrustManager"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + USE_INSECURE_TRUST_MANAGER_CONFIG); } public static boolean defaultDisableHttpsEndpointIdentificationAlgorithm() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + "disableHttpsEndpointIdentificationAlgorithm"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + DISABLE_HTTPS_ENDPOINT_IDENTIFICATION_ALGORITHM_CONFIG); } public static int defaultSslSessionCacheSize() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "sslSessionCacheSize"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + SSL_SESSION_CACHE_SIZE_CONFIG); } public static int defaultSslSessionTimeout() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "sslSessionTimeout"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + SSL_SESSION_TIMEOUT_CONFIG); } public static boolean defaultTcpNoDelay() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + "tcpNoDelay"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + TCP_NO_DELAY_CONFIG); } public static boolean defaultSoReuseAddress() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + "soReuseAddress"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + SO_REUSE_ADDRESS_CONFIG); } public static int defaultSoLinger() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "soLinger"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + SO_LINGER_CONFIG); } public static int defaultSoSndBuf() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "soSndBuf"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + SO_SND_BUF_CONFIG); } public static int defaultSoRcvBuf() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "soRcvBuf"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + SO_RCV_BUF_CONFIG); } public static int defaultHttpClientCodecMaxInitialLineLength() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "httpClientCodecMaxInitialLineLength"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + HTTP_CLIENT_CODEC_MAX_INITIAL_LINE_LENGTH_CONFIG); } public static int defaultHttpClientCodecMaxHeaderSize() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "httpClientCodecMaxHeaderSize"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + HTTP_CLIENT_CODEC_MAX_HEADER_SIZE_CONFIG); } public static int defaultHttpClientCodecMaxChunkSize() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "httpClientCodecMaxChunkSize"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + HTTP_CLIENT_CODEC_MAX_CHUNK_SIZE_CONFIG); } public static int defaultHttpClientCodecInitialBufferSize() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "httpClientCodecInitialBufferSize"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + HTTP_CLIENT_CODEC_INITIAL_BUFFER_SIZE_CONFIG); } public static boolean defaultDisableZeroCopy() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + "disableZeroCopy"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + DISABLE_ZERO_COPY_CONFIG); } public static int defaultHandshakeTimeout() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "handshakeTimeout"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + HANDSHAKE_TIMEOUT_CONFIG); } public static int defaultChunkedFileChunkSize() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "chunkedFileChunkSize"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + CHUNKED_FILE_CHUNK_SIZE_CONFIG); } public static int defaultWebSocketMaxBufferSize() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "webSocketMaxBufferSize"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + WEB_SOCKET_MAX_BUFFER_SIZE_CONFIG); } public static int defaultWebSocketMaxFrameSize() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "webSocketMaxFrameSize"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + WEB_SOCKET_MAX_FRAME_SIZE_CONFIG); } public static boolean defaultKeepEncodingHeader() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + "keepEncodingHeader"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + KEEP_ENCODING_HEADER_CONFIG); } public static int defaultShutdownQuietPeriod() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "shutdownQuietPeriod"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + SHUTDOWN_QUIET_PERIOD_CONFIG); } public static int defaultShutdownTimeout() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "shutdownTimeout"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + SHUTDOWN_TIMEOUT_CONFIG); } public static boolean defaultUseNativeTransport() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + "useNativeTransport"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getBoolean(ASYNC_CLIENT_CONFIG_ROOT + USE_NATIVE_TRANSPORT_CONFIG); } public static int defaultIoThreadsCount() { - return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + "ioThreadsCount"); + return AsyncHttpClientConfigHelper.getAsyncHttpClientConfig().getInt(ASYNC_CLIENT_CONFIG_ROOT + IO_THREADS_COUNT_CONFIG); } } diff --git a/client/src/main/java/org/asynchttpclient/config/AsyncHttpClientConfigHelper.java b/client/src/main/java/org/asynchttpclient/config/AsyncHttpClientConfigHelper.java index 50aa52e67d..2cce75d074 100644 --- a/client/src/main/java/org/asynchttpclient/config/AsyncHttpClientConfigHelper.java +++ b/client/src/main/java/org/asynchttpclient/config/AsyncHttpClientConfigHelper.java @@ -1,9 +1,23 @@ +/* + * Copyright (c) 2015 AsyncHttpClient Project. All rights reserved. + * + * This program is licensed to you under the Apache License Version 2.0, + * and you may not use this file except in compliance with the Apache License Version 2.0. + * You may obtain a copy of the Apache License Version 2.0 at + * http://www.apache.org/licenses/LICENSE-2.0. + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the Apache License Version 2.0 is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the Apache License Version 2.0 for the specific language governing permissions and limitations there under. + */ package org.asynchttpclient.config; import java.io.IOException; import java.io.InputStream; import java.util.ArrayList; import java.util.List; +import java.util.Optional; import java.util.Properties; import java.util.concurrent.ConcurrentHashMap; @@ -37,6 +51,13 @@ public static class Config { private final Properties defaultProperties = parsePropertiesFile(DEFAULT_AHC_PROPERTIES, true); private volatile Properties customProperties = parsePropertiesFile(CUSTOM_AHC_PROPERTIES, false); + public Config() { + } + + public Config(Properties properties) { + customProperties = properties; + } + public void reload() { customProperties = parsePropertiesFile(CUSTOM_AHC_PROPERTIES, false); propsCache.clear(); @@ -92,6 +113,14 @@ public String getString(String key) { }); } + public Optional getStringOpt(String key) { + try { + return Optional.ofNullable(getString(key)); + } catch (Exception ex) { + return Optional.empty(); + } + } + public String[] getStringArray(String key) { String s = getString(key); s = s.trim(); @@ -105,12 +134,49 @@ public String[] getStringArray(String key) { return array; } + public Optional getStringArrayOpt(String key) { + try { + return Optional.ofNullable(getStringArray(key)); + } catch (Exception ex) { + return Optional.empty(); + } + } + public int getInt(String key) { return Integer.parseInt(getString(key)); } + public Optional getIntOpt(String key) { + try { + return Optional.of(getInt(key)); + } catch (Exception ex) { + return Optional.empty(); + } + } + + public long getLong(String key) { + return Long.parseLong(getString(key)); + } + + public Optional getLongOpt(String key) { + try { + return Optional.of(getLong(key)); + } catch (Exception ex) { + return Optional.empty(); + } + } + + public Integer getInteger(String key) { + String s = getString(key); + return s != null ? Integer.valueOf(s) : null; + } + public boolean getBoolean(String key) { return Boolean.parseBoolean(getString(key)); } + + public Optional getBooleanOpt(String key) { + return Optional.ofNullable(getString(key)).map(Boolean::parseBoolean); + } } } diff --git a/client/src/test/java/org/asynchttpclient/PropertiesAsyncHttpClientConfigTest.java b/client/src/test/java/org/asynchttpclient/PropertiesAsyncHttpClientConfigTest.java new file mode 100644 index 0000000000..947b09c235 --- /dev/null +++ b/client/src/test/java/org/asynchttpclient/PropertiesAsyncHttpClientConfigTest.java @@ -0,0 +1,99 @@ +/* + * Copyright (c) 2015 AsyncHttpClient Project. All rights reserved. + * + * This program is licensed to you under the Apache License Version 2.0, + * and you may not use this file except in compliance with the Apache License Version 2.0. + * You may obtain a copy of the Apache License Version 2.0 at + * http://www.apache.org/licenses/LICENSE-2.0. + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the Apache License Version 2.0 is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the Apache License Version 2.0 for the specific language governing permissions and limitations there under. + */ +package org.asynchttpclient; + +import org.testng.Assert; +import org.testng.annotations.Test; + +import java.util.Properties; +import java.util.function.Function; + +@Test +public class PropertiesAsyncHttpClientConfigTest { + + public void testThreadPoolName() { + testProperty(PropertiesAsyncHttpClientConfig::getThreadPoolName, "threadPoolName", "MyHttpClient", "AsyncHttpClient"); + } + + public void testMaxTotalConnections() { + testProperty(PropertiesAsyncHttpClientConfig::getMaxConnections, "maxConnections", 100, -1); + } + + public void testMaxConnectionPerHost() { + testProperty(PropertiesAsyncHttpClientConfig::getMaxConnectionsPerHost, "maxConnectionsPerHost", 100, -1); + } + + public void testConnectTimeOut() { + testProperty(PropertiesAsyncHttpClientConfig::getConnectTimeout, "connectTimeout", 100, 5 * 1000); + } + + public void testPooledConnectionIdleTimeout() { + testProperty(PropertiesAsyncHttpClientConfig::getPooledConnectionIdleTimeout, "pooledConnectionIdleTimeout", 200, 6 * 10000); + } + + public void testReadTimeout() { + testProperty(PropertiesAsyncHttpClientConfig::getReadTimeout, "readTimeout", 100, 60 * 1000); + } + + public void testRequestTimeout() { + testProperty(PropertiesAsyncHttpClientConfig::getRequestTimeout, "requestTimeout", 200, 6 * 10000); + } + + public void testConnectionTtl() { + testProperty(PropertiesAsyncHttpClientConfig::getConnectionTtl, "connectionTtl", 100, -1); + } + + public void testFollowRedirect() { + testProperty(PropertiesAsyncHttpClientConfig::isFollowRedirect, "followRedirect", true, false); + } + + public void testMaxRedirects() { + testProperty(PropertiesAsyncHttpClientConfig::getMaxRedirects, "maxRedirects", 100, 5); + } + + public void testCompressionEnforced() { + testProperty(PropertiesAsyncHttpClientConfig::isCompressionEnforced, "compressionEnforced", true, false); + } + + public void testStrict302Handling() { + testProperty(PropertiesAsyncHttpClientConfig::isStrict302Handling, "strict302Handling", true, false); + } + + public void testAllowPoolingConnection() { + testProperty(PropertiesAsyncHttpClientConfig::isKeepAlive, "keepAlive", false, true); + } + + public void testMaxRequestRetry() { + testProperty(PropertiesAsyncHttpClientConfig::getMaxRequestRetry, "maxRequestRetry", 100, 5); + } + + public void testDisableUrlEncodingForBoundRequests() { + testProperty(PropertiesAsyncHttpClientConfig::isDisableUrlEncodingForBoundRequests, "disableUrlEncodingForBoundRequests", true, false); + } + + public void testUseInsecureTrustManager() { + testProperty(PropertiesAsyncHttpClientConfig::isUseInsecureTrustManager, "useInsecureTrustManager", true, false); + } + + private void testProperty(Function func, String propertyName, T value, T defaultValue) { + PropertiesAsyncHttpClientConfig defaultConfig = new PropertiesAsyncHttpClientConfig(new Properties()); + Assert.assertEquals(func.apply(defaultConfig), defaultValue); + + Properties properties = new Properties(); + properties.setProperty(propertyName, value.toString()); + PropertiesAsyncHttpClientConfig config = new PropertiesAsyncHttpClientConfig(properties); + Assert.assertEquals(func.apply(config), value); + } + +}