New IP discovery through DNS doesn't work for cluster mode. #1419

redisson/src/main/java/org/redisson/client/RedisClient.java

@@ -15,8 +15,10 @@
  */
 package org.redisson.client;
 
+import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.URI;
+import java.net.UnknownHostException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
@@ -45,6 +47,7 @@ import io.netty.resolver.AddressResolver;
 import io.netty.resolver.dns.DnsAddressResolverGroup;
 import io.netty.resolver.dns.DnsServerAddressStreamProviders;
 import io.netty.util.HashedWheelTimer;
+import io.netty.util.NetUtil;
 import io.netty.util.Timer;
 import io.netty.util.concurrent.Future;
 import io.netty.util.concurrent.FutureListener;
@@ -166,6 +169,17 @@ public class RedisClient {
             return resolvedAddrFuture.get();
         }
         
+        byte[] addr = NetUtil.createByteArrayFromIpAddressString(uri.getHost());
+        if (addr != null) {
+            try {
+                resolvedAddr = new InetSocketAddress(InetAddress.getByAddress(uri.getHost(), addr), uri.getPort());
+            } catch (UnknownHostException e) {
+                // skip
+            }
+            promise.trySuccess(resolvedAddr);
+            return promise;
+        }
+        
         AddressResolver<InetSocketAddress> resolver = (AddressResolver<InetSocketAddress>) bootstrap.config().resolver().getResolver(bootstrap.config().group().next());
         Future<InetSocketAddress> resolveFuture = resolver.resolve(InetSocketAddress.createUnresolved(uri.getHost(), uri.getPort()));
         resolveFuture.addListener(new FutureListener<InetSocketAddress>() {
@@ -176,12 +190,23 @@ public class RedisClient {
                     return;
                 }
                 
-                resolvedAddr = future.getNow();
-                promise.trySuccess(future.getNow());
+                InetSocketAddress resolved = future.getNow();
+                resolvedAddr = createInetSocketAddress(resolved, uri.getHost());
+                promise.trySuccess(resolvedAddr);
             }
+
         });
         return promise;
     }
+
+    private InetSocketAddress createInetSocketAddress(InetSocketAddress resolved, String host) {
+        byte[] addr = NetUtil.createByteArrayFromIpAddressString(resolved.getAddress().getHostAddress());
+        try {
+            return new InetSocketAddress(InetAddress.getByAddress(host, addr), resolved.getPort());
+        } catch (UnknownHostException e) {
+            throw new RuntimeException(e);
+        }
+    }
     
     public RFuture<RedisConnection> connectAsync() {
         final RPromise<RedisConnection> f = new RedissonPromise<RedisConnection>();

redisson/src/main/java/org/redisson/client/handler/RedisChannelInitializer.java

@@ -33,7 +33,6 @@ import org.redisson.client.RedisClient;
 import org.redisson.client.RedisClientConfig;
 import org.redisson.client.RedisConnection;
 import org.redisson.config.SslProvider;
-import org.redisson.misc.URIBuilder;
 
 import io.netty.bootstrap.Bootstrap;
 import io.netty.channel.Channel;
@@ -46,6 +45,7 @@ import io.netty.handler.ssl.SslContextBuilder;
 import io.netty.handler.ssl.SslHandler;
 import io.netty.handler.ssl.SslHandshakeCompletionEvent;
 import io.netty.handler.ssl.util.InsecureTrustManagerFactory;
+import io.netty.util.NetUtil;
 
 /**
  * 
@@ -164,7 +164,7 @@ public class RedisChannelInitializer extends ChannelInitializer<Channel> {
 
         SslContext sslContext = sslContextBuilder.build();
         String hostname = config.getSslHostname();
-        if (hostname == null || URIBuilder.isValidIP(hostname)) {
+        if (hostname == null || NetUtil.createByteArrayFromIpAddressString(hostname) != null) {
             hostname = config.getAddress().getHost();
         }
         

redisson/src/main/java/org/redisson/misc/URIBuilder.java

@@ -18,9 +18,12 @@ package org.redisson.misc;
 import java.io.IOException;
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
+import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.URI;
-import java.util.regex.Pattern;
+import java.net.UnknownHostException;
+
+import io.netty.util.NetUtil;
 
 /**
  *
@@ -28,9 +31,6 @@ import java.util.regex.Pattern;
  */
 public class URIBuilder {
 
-    private static final Pattern ipv4Pattern = Pattern.compile("(([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.){3}([01]?\\d\\d?|2[0-4]\\d|25[0-5])", Pattern.CASE_INSENSITIVE);
-    private static final Pattern ipv6Pattern = Pattern.compile("([0-9a-f]{1,4}:){7}([0-9a-f]){1,4}", Pattern.CASE_INSENSITIVE);
-
     public static URI create(String uri) {
         URI u = URI.create(uri);
         // Let's assuming most of the time it is OK.
@@ -68,15 +68,11 @@ public class URIBuilder {
         }
     }
     
-    public static boolean isValidIP(String host) {
-        if (ipv4Pattern.matcher(host).matches()) {
-            return true;
+    public static boolean compare(InetSocketAddress entryAddr, URI addr) {
+        if (addr.getHost().equals("localhost")) {
+            System.out.println("host to compare: " + addr.getHost());
         }
         
-        return ipv6Pattern.matcher(host).matches();
-    }
-
-    public static boolean compare(InetSocketAddress entryAddr, URI addr) {
         if (((entryAddr.getHostName() != null && entryAddr.getHostName().equals(addr.getHost()))
                 || entryAddr.getAddress().getHostAddress().equals(addr.getHost()))
                 && entryAddr.getPort() == addr.getPort()) {