FEAT: Add check DNS cache ttl method.

pom.xml

@@ -248,6 +248,7 @@
                         <exclude>**/RedistributeFailureModeTest.java</exclude>
                         <exclude>**/LoggingTest.java</exclude>
                     </excludes>
+                    <argLine>--illegal-access=permit</argLine>
                 </configuration>
             </plugin>
             <plugin>

src/main/java/net/spy/memcached/ArcusClient.java

@@ -21,6 +21,7 @@
 import java.io.InputStream;
 import java.net.InetSocketAddress;
 import java.net.URL;
+import java.security.Security;
 import java.util.AbstractMap;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -201,6 +202,10 @@ public class ArcusClient extends FrontCacheMemcachedClient implements ArcusClien
 
   private static final int SHUTDOWN_TIMEOUT_MILLISECONDS = 2000;
 
+  private static final String DNS_CACHE_TTL_PROP = "networkaddress.cache.ttl";
+  private static final String SUN_NET_POLICY_PROP = "sun.net.InetAddressCachePolicy";
+  private static final int MAX_DNS_CACHE_TTL = 300;
+
   private CacheManager cacheManager;
 
   public void setCacheManager(CacheManager cacheManager) {
@@ -313,6 +318,12 @@ protected static ArcusClient getInstance(ConnectionFactory cf,
   public ArcusClient(ConnectionFactory cf, String name, List<InetSocketAddress> addrs)
           throws IOException {
     super(cf, name, addrs);
+
+    if (cf.getDnsCacheTtlCheck() && !isValidDnsCacheTtl()) {
+      getLogger().warn("The minimum value for DNS cache TTL is 0 and the maximum value is " + MAX_DNS_CACHE_TTL +
+              "Invoke ConnectionFactoryBuilder.setDnsCacheTtlCheck(false) to avoid this validation.");
+      throw new RuntimeException("The value of the DNS cache TTL is less than 0 or greater than" + MAX_DNS_CACHE_TTL);
+    }
     collectionTranscoder = new CollectionTranscoder();
     smgetKeyChunkSize = cf.getDefaultMaxSMGetKeyChunkSize();
     registerMbean();
@@ -327,10 +338,47 @@ public ArcusClient(ConnectionFactory cf, String name, List<InetSocketAddress> ad
    */
   public ArcusClient(ConnectionFactory cf, List<InetSocketAddress> addrs)
           throws IOException {
-    super(cf, DEFAULT_ARCUS_CLIENT_NAME, addrs);
-    collectionTranscoder = new CollectionTranscoder();
-    smgetKeyChunkSize = cf.getDefaultMaxSMGetKeyChunkSize();
-    registerMbean();
+    this(cf, DEFAULT_ARCUS_CLIENT_NAME, addrs);
+  }
+
+  private static boolean isValidDnsCacheTtl() {
+    Integer ttl = null;
+    try {
+      ttl = (Integer) Class.forName(SUN_NET_POLICY_PROP)
+              .getMethod("get")
+              .invoke(null);
+    } catch (Throwable t) {
+      arcusLogger.error("Can not access to " + SUN_NET_POLICY_PROP);
+    }
+    if (ttl != null) {
+      if (ttl < 0 || ttl > MAX_DNS_CACHE_TTL) {
+        return false;
+      }
+    }
+
+    String security = null;
+    String system = null;
+    // Get DNS cache TTL from System property.
+    try {
+      security = Security.getProperty(DNS_CACHE_TTL_PROP);
+      system = System.getProperty(DNS_CACHE_TTL_PROP);
+    } catch (NumberFormatException e) {
+      arcusLogger.error("Can not get DNS cache TTL value by {}", e.getCause());
+    }
+
+    if (security != null) {
+      int securityTtl = Integer.parseInt(security);
+      if (securityTtl < 0 || securityTtl > MAX_DNS_CACHE_TTL) {
+        return false;
+      }
+    }
+    if (system != null) {
+      int systemTtl = Integer.parseInt(system);
+      if (systemTtl < 0 || systemTtl > MAX_DNS_CACHE_TTL) {
+        return false;
+      }
+    }
+    return System.getSecurityManager() == null;
   }
 
   /**

src/main/java/net/spy/memcached/ConnectionFactory.java

@@ -116,6 +116,11 @@ MemcachedNode createMemcachedNode(String name,
    */
   boolean getKeepAlive();
 
+  /**
+   * If true, check DNS cache TTL when invoking ArcusClient constructor.
+   */
+  boolean getDnsCacheTtlCheck();
+
   /**
    * Observers that should be established at the time of connection
    * instantiation.

src/main/java/net/spy/memcached/ConnectionFactoryBuilder.java

@@ -60,6 +60,7 @@ public class ConnectionFactoryBuilder {
   private boolean shouldOptimize = false;
   private boolean useNagle = false;
   private boolean keepAlive = false;
+  private boolean dnsCacheTtlCheck = true;
   //private long maxReconnectDelay =
   //DefaultConnectionFactory.DEFAULT_MAX_RECONNECT_DELAY;
   private long maxReconnectDelay = 1;
@@ -448,6 +449,12 @@ public ConnectionFactoryBuilder setKeepAlive(boolean on) {
     keepAlive = on;
     return this;
   }
+
+  public ConnectionFactoryBuilder setDnsCacheTtlCheck(boolean dnsCacheTtlCheck) {
+    this.dnsCacheTtlCheck = dnsCacheTtlCheck;
+    return this;
+  }
+
   /**
    * Get the ConnectionFactory set up with the provided parameters.
    */
@@ -577,6 +584,11 @@ public boolean getKeepAlive() {
         return keepAlive;
       }
 
+      @Override
+      public boolean getDnsCacheTtlCheck() {
+        return dnsCacheTtlCheck;
+      }
+
       @Override
       public long getMaxReconnectDelay() {
         return maxReconnectDelay;

src/main/java/net/spy/memcached/DefaultConnectionFactory.java

@@ -303,6 +303,12 @@ public boolean useNagleAlgorithm() {
   public boolean getKeepAlive() {
     return false;
   }
+
+  @Override
+  public boolean getDnsCacheTtlCheck() {
+    return true;
+  }
+
   public boolean shouldOptimize() {
     return true;
   }

src/test/java/net/spy/memcached/ClientBaseCase.java

@@ -157,6 +157,11 @@ public boolean getKeepAlive() {
           return inner.getKeepAlive();
         }
 
+        @Override
+        public boolean getDnsCacheTtlCheck() {
+          return inner.getDnsCacheTtlCheck();
+        }
+
         @Override
         public Collection<ConnectionObserver> getInitialObservers() {
           return observers;

src/test/java/net/spy/memcached/ConnectionFactoryBuilderTest.java

@@ -94,6 +94,7 @@ public void testDefaults() throws Exception {
     assertFalse(f.shouldOptimize());
     assertFalse(f.useNagleAlgorithm());
     assertFalse(f.getKeepAlive());
+    assertTrue(f.getDnsCacheTtlCheck());
     assertEquals(f.getOpQueueMaxBlockTime(),
             DefaultConnectionFactory.DEFAULT_OP_QUEUE_MAX_BLOCK_TIME);
   }
@@ -132,6 +133,7 @@ public void connectionEstablished(SocketAddress sa, int reconnectCount) {
             .setTranscoder(new WhalinTranscoder())
             .setUseNagleAlgorithm(true)
             .setKeepAlive(true)
+            .setDnsCacheTtlCheck(false)
             .setLocatorType(Locator.CONSISTENT)
             .setOpQueueMaxBlockTime(19)
             .setAuthDescriptor(anAuthDescriptor)
@@ -152,6 +154,7 @@ public void connectionEstablished(SocketAddress sa, int reconnectCount) {
     assertFalse(f.shouldOptimize());
     assertTrue(f.useNagleAlgorithm());
     assertTrue(f.getKeepAlive());
+    assertFalse(f.getDnsCacheTtlCheck());
     assertEquals(f.getOpQueueMaxBlockTime(), 19);
     assertSame(anAuthDescriptor, f.getAuthDescriptor());