Revert "Pick up default config values from asynchttpclient.properties file"

Author: Stephane Landelle

api/src/main/java/org/asynchttpclient/AsyncHttpClientConfigDefaults.java

@@ -12,131 +12,126 @@
  */
 package org.asynchttpclient;
 
+import static org.asynchttpclient.util.MiscUtil.getBoolean;
 
-
-import static org.asynchttpclient.util.MiscUtil.getBooleanValue;
-import static org.asynchttpclient.util.MiscUtil.getIntValue;
 import org.asynchttpclient.util.DefaultHostnameVerifier;
 
 import javax.net.ssl.HostnameVerifier;
 
-
-
 public final class AsyncHttpClientConfigDefaults {
 
-
     private AsyncHttpClientConfigDefaults() {
     }
 
     public static final String ASYNC_CLIENT = AsyncHttpClientConfig.class.getName() + ".";
 
     public static int defaultMaxTotalConnections() {
-        return getIntValue(ASYNC_CLIENT + "maxTotalConnections", -1);
+        return Integer.getInteger(ASYNC_CLIENT + "maxTotalConnections", -1);
     }
 
     public static int defaultMaxConnectionPerHost() {
-        return getIntValue(ASYNC_CLIENT + "maxConnectionsPerHost", -1);
+        return Integer.getInteger(ASYNC_CLIENT + "maxConnectionsPerHost", -1);
     }
 
     public static int defaultConnectionTimeOutInMs() {
-        return getIntValue(ASYNC_CLIENT + "connectionTimeoutInMs", 60 * 1000);
+        return Integer.getInteger(ASYNC_CLIENT + "connectionTimeoutInMs", 60 * 1000);
     }
 
     public static int defaultIdleConnectionInPoolTimeoutInMs() {
-        return getIntValue(ASYNC_CLIENT + "idleConnectionInPoolTimeoutInMs", 60 * 1000);
+        return Integer.getInteger(ASYNC_CLIENT + "idleConnectionInPoolTimeoutInMs", 60 * 1000);
     }
 
     public static int defaultIdleConnectionTimeoutInMs() {
-        return getIntValue(ASYNC_CLIENT + "idleConnectionTimeoutInMs", 60 * 1000);
+        return Integer.getInteger(ASYNC_CLIENT + "idleConnectionTimeoutInMs", 60 * 1000);
     }
 
     public static int defaultRequestTimeoutInMs() {
-        return getIntValue(ASYNC_CLIENT + "requestTimeoutInMs", 60 * 1000);
+        return Integer.getInteger(ASYNC_CLIENT + "requestTimeoutInMs", 60 * 1000);
     }
 
     public static int defaultWebSocketIdleTimeoutInMs() {
-        return getIntValue(ASYNC_CLIENT + "webSocketTimoutInMS", 15 * 60 * 1000);
+        return Integer.getInteger(ASYNC_CLIENT + "webSocketTimoutInMS", 15 * 60 * 1000);
     }
 
     public static int defaultMaxConnectionLifeTimeInMs() {
-        return getIntValue(ASYNC_CLIENT + "maxConnectionLifeTimeInMs", -1);
+        return Integer.getInteger(ASYNC_CLIENT + "maxConnectionLifeTimeInMs", -1);
     }
 
     public static boolean defaultRedirectEnabled() {
-        return getBooleanValue(ASYNC_CLIENT + "redirectsEnabled",false);
+        return Boolean.getBoolean(ASYNC_CLIENT + "redirectsEnabled");
     }
 
     public static int defaultMaxRedirects() {
-        return getIntValue(ASYNC_CLIENT + "maxRedirects", 5);
+        return Integer.getInteger(ASYNC_CLIENT + "maxRedirects", 5);
     }
 
     public static boolean defaultCompressionEnabled() {
-        return getBooleanValue(ASYNC_CLIENT + "compressionEnabled",false);
+        return Boolean.getBoolean(ASYNC_CLIENT + "compressionEnabled");
     }
 
     public static String defaultUserAgent() {
         return System.getProperty(ASYNC_CLIENT + "userAgent", "NING/1.0");
     }
 
     public static int defaultIoThreadMultiplier() {
-        return getIntValue(ASYNC_CLIENT + "ioThreadMultiplier", 2);
+        return Integer.getInteger(ASYNC_CLIENT + "ioThreadMultiplier", 2);
     }
 
     public static boolean defaultUseProxySelector() {
-        return getBooleanValue(ASYNC_CLIENT + "useProxySelector",false);
+        return Boolean.getBoolean(ASYNC_CLIENT + "useProxySelector");
     }
 
     public static boolean defaultUseProxyProperties() {
-        return getBooleanValue(ASYNC_CLIENT + "useProxyProperties",false);
+        return Boolean.getBoolean(ASYNC_CLIENT + "useProxyProperties");
     }
 
     public static boolean defaultStrict302Handling() {
-        return getBooleanValue(ASYNC_CLIENT + "strict302Handling",false);
+        return Boolean.getBoolean(ASYNC_CLIENT + "strict302Handling");
     }
 
     public static boolean defaultAllowPoolingConnection() {
-        return getBooleanValue(ASYNC_CLIENT + "allowPoolingConnection", true);
+        return getBoolean(ASYNC_CLIENT + "allowPoolingConnection", true);
     }
 
     public static boolean defaultUseRelativeURIsWithSSLProxies() {
-        return getBooleanValue(ASYNC_CLIENT + "useRelativeURIsWithSSLProxies", true);
+        return getBoolean(ASYNC_CLIENT + "useRelativeURIsWithSSLProxies", true);
     }
 
     // unused/broken, left there for compatibility, fixed in Netty 4
     public static int defaultRequestCompressionLevel() {
-        return getIntValue(ASYNC_CLIENT + "requestCompressionLevel", -1);
+        return Integer.getInteger(ASYNC_CLIENT + "requestCompressionLevel", -1);
     }
 
     public static int defaultMaxRequestRetry() {
-        return getIntValue(ASYNC_CLIENT + "maxRequestRetry", 5);
+        return Integer.getInteger(ASYNC_CLIENT + "maxRequestRetry", 5);
     }
 
     public static boolean defaultAllowSslConnectionPool() {
-        return getBooleanValue(ASYNC_CLIENT + "allowSslConnectionPool", true);
+        return getBoolean(ASYNC_CLIENT + "allowSslConnectionPool", true);
     }
 
     public static boolean defaultUseRawUrl() {
-        return getBooleanValue(ASYNC_CLIENT + "useRawUrl",false);
+        return Boolean.getBoolean(ASYNC_CLIENT + "useRawUrl");
     }
 
     public static boolean defaultRemoveQueryParamOnRedirect() {
-        return getBooleanValue(ASYNC_CLIENT + "removeQueryParamOnRedirect", true);
+        return getBoolean(ASYNC_CLIENT + "removeQueryParamOnRedirect", true);
     }
 
     public static HostnameVerifier defaultHostnameVerifier() {
         return new DefaultHostnameVerifier();
     }
 
     public static boolean defaultSpdyEnabled() {
-        return getBooleanValue(ASYNC_CLIENT + "spdyEnabled",false);
+        return Boolean.getBoolean(ASYNC_CLIENT + "spdyEnabled");
     }
 
     public static int defaultSpdyInitialWindowSize() {
-        return getIntValue(ASYNC_CLIENT + "spdyInitialWindowSize", 10 * 1024 * 1024);
+        return Integer.getInteger(ASYNC_CLIENT + "spdyInitialWindowSize", 10 * 1024 * 1024);
     }
 
     public static int defaultSpdyMaxConcurrentStreams() {
-        return getIntValue(ASYNC_CLIENT + "spdyMaxConcurrentStreams", 100);
+        return Integer.getInteger(ASYNC_CLIENT + "spdyMaxConcurrentStreams", 100);
     }
 
     public static boolean defaultAcceptAnyCertificate() {

api/src/main/java/org/asynchttpclient/util/AsyncImplHelper.java

@@ -59,7 +59,7 @@ public static Class<AsyncHttpClient> getAsyncImplClass(String propertyName) {
         return asyncHttpClientImplClass;
     }
 
-    public static Properties getAsyncImplProperties() {
+    private static Properties getAsyncImplProperties() {
         try {
             return AccessController.doPrivileged(new PrivilegedExceptionAction<Properties>() {
                 public Properties run() throws IOException {

api/src/main/java/org/asynchttpclient/util/MiscUtil.java

@@ -12,16 +12,11 @@
  */
 package org.asynchttpclient.util;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 import java.util.Collection;
 import java.util.Map;
-import java.util.Properties;
 
 public class MiscUtil {
 
-    public final static Logger logger = LoggerFactory.getLogger(MiscUtil.class);
-
     private MiscUtil() {
     }
 
@@ -45,69 +40,12 @@ public static boolean isNonEmpty(Map<?, ?> map) {
         return map != null && !map.isEmpty();
     }
 
-    // The getBooleanValue() method replaces this and reads the property from
-    // properties file
-    // too. Plus has a better check for invalid boolean values.
-    /*
-     * public static boolean getBoolean(String systemPropName, boolean
-     * defaultValue) { String systemPropValue =
-     * System.getProperty(systemPropName); return systemPropValue != null ?
-     * systemPropValue.equalsIgnoreCase("true") : defaultValue; }
-     */
-
-    public static Integer getIntValue(String property, int defaultValue) {
-        // Read system property and if not null return that.
-        Integer value = Integer.getInteger(property);
-        if (value != null)
-            return value;
-        Properties asyncHttpClientConfigProperties = AsyncImplHelper.getAsyncImplProperties();
-        if (asyncHttpClientConfigProperties != null) {
-            String valueString = asyncHttpClientConfigProperties.getProperty(property);
-            try {
-                // If property is present and is non null parse it.
-                if (valueString != null)
-                    return Integer.parseInt(valueString);
-            } catch (NumberFormatException e) {
-                // If property couldn't be parsed log the error message and
-                // return default value.
-                logger.error("Property : " + property + " has value = " + valueString
-                                + " which couldn't be parsed to an int value. Returning default value: " + defaultValue, e);
-            }
-        }
-        return defaultValue;
-    }
-
-    private static boolean isValidBooleanValue(String value) {
-        return value != null && ("true".equalsIgnoreCase(value) || "false".equalsIgnoreCase(value));
+    public static boolean getBoolean(String systemPropName, boolean defaultValue) {
+        String systemPropValue = System.getProperty(systemPropName);
+        return systemPropValue != null ? systemPropValue.equalsIgnoreCase("true") : defaultValue;
     }
 
-
-    public static Boolean getBooleanValue(String property, boolean defaultValue) {
-
-        // get from System property first
-        String value = System.getProperty(property);
-        if (isValidBooleanValue(value))
-            return Boolean.parseBoolean(value);
-
-        // get from property file
-        Properties asyncHttpClientConfigProperties = AsyncImplHelper.getAsyncImplProperties();
-        if (asyncHttpClientConfigProperties != null) {
-            value = asyncHttpClientConfigProperties.getProperty(property);
-            if (isValidBooleanValue(value))
-                return Boolean.parseBoolean(value);
-        }
-
-        // have to use the default value now
-        if (value != null)
-            logger.error("Property : " + property + " has value = " + value
-                            + " which couldn't be parsed to an boolean value. Returning default value: " + defaultValue);
-
-        return defaultValue;
-    }
-
-
     public static <T> T withDefault(T value, T defaults) {
         return value != null? value : value;
     }
-
 }