Merge pull request #332 from zhenlineo/1.2-dns-to-ips

Resolve DNS to IP & IPv6 address support

Author: Zhen Li

driver/src/main/java/org/neo4j/driver/internal/cluster/ClusterRoutingTable.java

@@ -78,9 +78,7 @@ public synchronized Set<BoltServerAddress> update( ClusterComposition cluster )
     @Override
     public synchronized void forget( BoltServerAddress address )
     {
-        // Don't remove it from the set of routers, since that might mean we lose our ability to re-discover,
-        // just remove it from the set of readers and writers, so that we don't use it for actual work without
-        // performing discovery first.
+        routers.remove( address );
         readers.remove( address );
         writers.remove( address );
     }
@@ -115,11 +113,6 @@ public void removeWriter( BoltServerAddress toRemove )
         writers.remove( toRemove );
     }
 
-    @Override
-    public void removeRouter( BoltServerAddress toRemove )
-    {
-        routers.remove( toRemove );
-    }
 
     @Override
     public String toString()

driver/src/main/java/org/neo4j/driver/internal/cluster/DnsResolver.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2002-2017 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.internal.cluster;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.neo4j.driver.internal.net.BoltServerAddress;
+import org.neo4j.driver.v1.Logger;
+
+public class DnsResolver implements HostNameResolver
+{
+    private final Logger logger;
+
+    public DnsResolver( Logger logger )
+    {
+        this.logger = logger;
+    }
+
+    @Override
+    public Set<BoltServerAddress> resolve( BoltServerAddress initialRouter )
+    {
+        Set<BoltServerAddress> addresses = new HashSet<>();
+        try
+        {
+            InetAddress[] ipAddresses = InetAddress.getAllByName( initialRouter.host() );
+
+            for ( InetAddress ipAddress : ipAddresses )
+            {
+                addresses.add( new BoltServerAddress( ipAddress.getHostAddress(), initialRouter.port() ) );
+            }
+
+            return addresses;
+        }
+        catch ( UnknownHostException e )
+        {
+            logger.error( "Failed to resolve URI `" + initialRouter + "` to IPs due to error: " + e.getMessage(), e );
+
+            addresses.add( initialRouter );
+            return addresses;
+        }
+    }
+}

driver/src/main/java/org/neo4j/driver/internal/cluster/HostNameResolver.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2002-2017 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.internal.cluster;
+
+import java.util.Set;
+
+import org.neo4j.driver.internal.net.BoltServerAddress;
+
+public interface HostNameResolver
+{
+    Set<BoltServerAddress> resolve( BoltServerAddress initialRouter );
+}

driver/src/main/java/org/neo4j/driver/internal/cluster/LoadBalancer.java

@@ -157,6 +157,6 @@ private static Rediscovery createRediscovery( BoltServerAddress initialRouter, R
             Clock clock, Logger log )
     {
         ClusterCompositionProvider clusterComposition = new GetServersProcedureClusterCompositionProvider( clock, log );
-        return new Rediscovery( initialRouter, settings, clock, log, clusterComposition );
+        return new Rediscovery( initialRouter, settings, clock, log, clusterComposition, new DnsResolver( log ) );
     }
 }

driver/src/main/java/org/neo4j/driver/internal/cluster/Rediscovery.java

@@ -18,6 +18,9 @@
  */
 package org.neo4j.driver.internal.cluster;
 
+import java.util.HashSet;
+import java.util.Set;
+
 import org.neo4j.driver.internal.net.BoltServerAddress;
 import org.neo4j.driver.internal.spi.Connection;
 import org.neo4j.driver.internal.spi.ConnectionPool;
@@ -37,15 +40,17 @@ public class Rediscovery
     private final Clock clock;
     private final Logger logger;
     private final ClusterCompositionProvider provider;
+    private final HostNameResolver hostNameResolver;
 
     public Rediscovery( BoltServerAddress initialRouter, RoutingSettings settings, Clock clock, Logger logger,
-            ClusterCompositionProvider provider )
+            ClusterCompositionProvider provider, HostNameResolver hostNameResolver )
     {
         this.initialRouter = initialRouter;
         this.settings = settings;
         this.clock = clock;
         this.logger = logger;
         this.provider = provider;
+        this.hostNameResolver = hostNameResolver;
     }
 
     // Given the current routing table and connection pool, use the connection composition provider to fetch a new
@@ -76,8 +81,8 @@ public ClusterComposition lookupClusterComposition( ConnectionPool connections,
     private ClusterComposition lookupClusterCompositionOnKnownRouters( ConnectionPool connections,
             RoutingTable routingTable )
     {
-        boolean triedInitialRouter = false;
         int size = routingTable.routerSize();
+        Set<BoltServerAddress> triedServers = new HashSet<>();
         for ( int i = 0; i < size; i++ )
         {
             BoltServerAddress address = routingTable.nextRouter();
@@ -86,23 +91,29 @@ private ClusterComposition lookupClusterCompositionOnKnownRouters( ConnectionPoo
                 break;
             }
 
-            if ( address.equals( initialRouter ) )
+            ClusterComposition composition = lookupClusterCompositionOnRouter( address, connections, routingTable );
+            if ( composition != null )
+            {
+                return composition;
+            }
+            else
             {
-                triedInitialRouter = true;
+                triedServers.add( address );
             }
+        }
 
+        Set<BoltServerAddress> ips = hostNameResolver.resolve( initialRouter );
+        ips.removeAll( triedServers );
+        for ( BoltServerAddress address : ips )
+        {
             ClusterComposition composition = lookupClusterCompositionOnRouter( address, connections, routingTable );
             if ( composition != null )
             {
                 return composition;
             }
         }
 
-        if ( triedInitialRouter )
-        {
-            return null;
-        }
-        return lookupClusterCompositionOnRouter( initialRouter, connections, routingTable );
+        return null;
     }
 
     private ClusterComposition lookupClusterCompositionOnRouter( BoltServerAddress routerAddress,
@@ -122,7 +133,7 @@ private ClusterComposition lookupClusterCompositionOnRouter( BoltServerAddress r
         {
             // connection turned out to be broken
             logger.error( format( "Failed to connect to routing server '%s'.", routerAddress ), t );
-            routingTable.removeRouter( routerAddress );
+            routingTable.forget( routerAddress );
             return null;
         }
 

driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingTable.java

@@ -39,6 +39,4 @@ public interface RoutingTable
     int routerSize();
 
     void removeWriter( BoltServerAddress toRemove );
-
-    void removeRouter( BoltServerAddress toRemove );
 }

driver/src/main/java/org/neo4j/driver/internal/net/BoltServerAddress.java

@@ -41,6 +41,12 @@ public static BoltServerAddress from( URI uri )
         {
             port = DEFAULT_PORT;
         }
+
+        if( uri.getHost() == null )
+        {
+            throw new IllegalArgumentException( "Invalid URI format `" + uri.toString() + "`");
+        }
+
         return new BoltServerAddress( uri.getHost(), port );
     }
 

driver/src/test/java/org/neo4j/driver/internal/DirectDriverTest.java

@@ -32,6 +32,7 @@
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.core.IsEqual.equalTo;
 import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
 import static org.neo4j.driver.internal.net.BoltServerAddress.LOCAL_DEFAULT;
 import static org.neo4j.driver.internal.util.Matchers.directDriverWithAddress;
 import static org.neo4j.driver.v1.Values.parameters;
@@ -52,6 +53,38 @@ public void shouldUseDefaultPortIfMissing()
         assertThat( driver, is( directDriverWithAddress( LOCAL_DEFAULT ) ) );
     }
 
+    @Test
+    public void shouldAllowIPv6Address()
+    {
+        // Given
+        URI uri = URI.create( "bolt://[::1]" );
+        BoltServerAddress address = BoltServerAddress.from( uri );
+
+        // When
+        Driver driver = GraphDatabase.driver( uri );
+
+        // Then
+        assertThat( driver, is( directDriverWithAddress( address ) ) );
+    }
+
+    @Test
+    public void shouldRejectInvalidAddress()
+    {
+        // Given
+        URI uri = URI.create( "*" );
+
+        // When & Then
+        try
+        {
+            Driver driver = GraphDatabase.driver( uri );
+            fail("Expecting error for wrong uri");
+        }
+        catch( IllegalArgumentException e )
+        {
+            assertThat( e.getMessage(), equalTo( "Invalid URI format `*`" ) );
+        }
+    }
+
     @Test
     public void shouldRegisterSingleServer()
     {

driver/src/test/java/org/neo4j/driver/internal/cluster/DnsResolverTest.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2002-2017 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.internal.cluster;
+
+import org.junit.Test;
+
+import java.net.UnknownHostException;
+import java.util.Set;
+
+import org.neo4j.driver.internal.net.BoltServerAddress;
+import org.neo4j.driver.v1.Logger;
+
+import static org.hamcrest.Matchers.greaterThanOrEqualTo;
+import static org.junit.Assert.assertThat;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+public class DnsResolverTest
+{
+    private DnsResolver resolver = new DnsResolver( mock( Logger.class ) );
+
+    @Test
+    public void shouldResolveDNSToIPs()
+    {
+        Set<BoltServerAddress> resolve = resolver.resolve( new BoltServerAddress( "google.com", 80 ) );
+        assertThat( resolve.size(), greaterThanOrEqualTo( 1 ) );
+    }
+
+    @Test
+    public void shouldResolveLocalhostIPDNSToIPs()
+    {
+        Set<BoltServerAddress> resolve = resolver.resolve( new BoltServerAddress( "127.0.0.1", 80 ) );
+        assertThat( resolve.size(), greaterThanOrEqualTo( 1 ) );
+    }
+
+    @Test
+    public void shouldResolveLocalhostDNSToIPs()
+    {
+        Set<BoltServerAddress> resolve = resolver.resolve( new BoltServerAddress( "localhost", 80 ) );
+        assertThat( resolve.size(), greaterThanOrEqualTo( 1 ) );
+    }
+
+    @Test
+    public void shouldResolveIPv6LocalhostDNSToIPs()
+    {
+        Set<BoltServerAddress> resolve = resolver.resolve( new BoltServerAddress( "[::1]", 80 ) );
+        assertThat( resolve.size(), greaterThanOrEqualTo( 1 ) );
+    }
+
+    @Test
+    public void shouldExceptionAndGiveDefaultValue()
+    {
+        Logger logger = mock( Logger.class );
+        DnsResolver resolver = new DnsResolver( logger );
+        Set<BoltServerAddress> resolve = resolver.resolve( new BoltServerAddress( "[/]", 80 ) );
+        verify( logger ).error( any( String.class ), any( UnknownHostException.class ) );
+        assertThat( resolve.size(), greaterThanOrEqualTo( 1 ) );
+    }
+}