Improved error messages on driver.

Zhen Li · Zhen Li · commit bb1c160e19c5 · 2019-11-29T14:39:10.000+01:00
When rediscovery failed, we will suppress all discovery errors together on a service unavailable error.
Also improved error message when failed to connect to server due to incompatible encryption configurations.
diff --git a/driver/src/main/java/org/neo4j/driver/exceptions/DiscoveryException.java b/driver/src/main/java/org/neo4j/driver/exceptions/DiscoveryException.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2002-2019 "Neo4j,"
+ * Neo4j Sweden AB [http://neo4j.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.exceptions;
+
+/**
+ * An error has happened while getting routing table with a remote server.
+ * While this error is not fatal and we might be able to recover if we continue trying on another server.
+ * If we fail to get a valid routing table from all routing servers known to this driver,
+ * then we will end up with a fatal error {@link ServiceUnavailableException}.
+ *
+ * If you see this error in your logs, it is safe to ignore if your cluster is temporarily changing structure during that time.
+ */
+public class DiscoveryException extends Neo4jException
+{
+    public DiscoveryException( String message, Throwable cause )
+    {
+        super( message, cause );
+    }
+}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/RediscoveryImpl.java b/driver/src/main/java/org/neo4j/driver/internal/cluster/RediscoveryImpl.java
@@ -32,6 +32,7 @@
 
 import org.neo4j.driver.Bookmark;
 import org.neo4j.driver.Logger;
+import org.neo4j.driver.exceptions.DiscoveryException;
 import org.neo4j.driver.exceptions.FatalDiscoveryException;
 import org.neo4j.driver.exceptions.SecurityException;
 import org.neo4j.driver.exceptions.ServiceUnavailableException;
@@ -55,6 +56,7 @@
 public class RediscoveryImpl implements Rediscovery
 {
     private static final String NO_ROUTERS_AVAILABLE = "Could not perform discovery for database '%s'. No routing server available.";
+    private static final String RECOVERABLE_ROUTING_ERROR = "Failed to update routing table with server '%s'.";
 
     private final BoltServerAddress initialRouter;
     private final RoutingSettings settings;
@@ -86,14 +88,16 @@ public RediscoveryImpl( BoltServerAddress initialRouter, RoutingSettings setting
     public CompletionStage<ClusterComposition> lookupClusterComposition( RoutingTable routingTable, ConnectionPool connectionPool, Bookmark bookmark )
     {
         CompletableFuture<ClusterComposition> result = new CompletableFuture<>();
-        lookupClusterComposition( routingTable, connectionPool, 0, 0, result, bookmark );
+        // if we failed discovery, we will chain all errors into this one.
+        ServiceUnavailableException baseError = new ServiceUnavailableException( NO_ROUTERS_AVAILABLE );
+        lookupClusterComposition( routingTable, connectionPool, 0, 0, result, bookmark, baseError );
         return result;
     }
 
     private void lookupClusterComposition( RoutingTable routingTable, ConnectionPool pool,
-            int failures, long previousDelay, CompletableFuture<ClusterComposition> result, Bookmark bookmark )
+            int failures, long previousDelay, CompletableFuture<ClusterComposition> result, Bookmark bookmark, Throwable baseError )
     {
-        lookup( routingTable, pool, bookmark ).whenComplete( ( composition, completionError ) ->
+        lookup( routingTable, pool, bookmark, baseError ).whenComplete( ( composition, completionError ) ->
         {
             Throwable error = Futures.completionExceptionCause( completionError );
             if ( error != null )
@@ -109,67 +113,68 @@ else if ( composition != null )
                 int newFailures = failures + 1;
                 if ( newFailures >= settings.maxRoutingFailures() )
                 {
-                    result.completeExceptionally( new ServiceUnavailableException( String.format( NO_ROUTERS_AVAILABLE, routingTable.database().description() ) ) );
+                    // now we throw our saved error out
+                    result.completeExceptionally( baseError );
                 }
                 else
                 {
                     long nextDelay = Math.max( settings.retryTimeoutDelay(), previousDelay * 2 );
                     logger.info( "Unable to fetch new routing table, will try again in " + nextDelay + "ms" );
                     eventExecutorGroup.next().schedule(
-                            () -> lookupClusterComposition( routingTable, pool, newFailures, nextDelay, result, bookmark ),
+                            () -> lookupClusterComposition( routingTable, pool, newFailures, nextDelay, result, bookmark, baseError ),
                             nextDelay, TimeUnit.MILLISECONDS
                     );
                 }
             }
         } );
     }
 
-    private CompletionStage<ClusterComposition> lookup( RoutingTable routingTable, ConnectionPool connectionPool, Bookmark bookmark )
+    private CompletionStage<ClusterComposition> lookup( RoutingTable routingTable, ConnectionPool connectionPool, Bookmark bookmark, Throwable baseError )
     {
         CompletionStage<ClusterComposition> compositionStage;
 
         if ( routingTable.preferInitialRouter() )
         {
-            compositionStage = lookupOnInitialRouterThenOnKnownRouters( routingTable, connectionPool, bookmark );
+            compositionStage = lookupOnInitialRouterThenOnKnownRouters( routingTable, connectionPool, bookmark, baseError );
         }
         else
         {
-            compositionStage = lookupOnKnownRoutersThenOnInitialRouter( routingTable, connectionPool, bookmark );
+            compositionStage = lookupOnKnownRoutersThenOnInitialRouter( routingTable, connectionPool, bookmark, baseError );
         }
 
         return compositionStage;
     }
 
-    private CompletionStage<ClusterComposition> lookupOnKnownRoutersThenOnInitialRouter( RoutingTable routingTable,
-            ConnectionPool connectionPool, Bookmark bookmark )
+    private CompletionStage<ClusterComposition> lookupOnKnownRoutersThenOnInitialRouter( RoutingTable routingTable, ConnectionPool connectionPool,
+            Bookmark bookmark, Throwable baseError )
     {
         Set<BoltServerAddress> seenServers = new HashSet<>();
-        return lookupOnKnownRouters( routingTable, connectionPool, seenServers, bookmark ).thenCompose( composition ->
+        return lookupOnKnownRouters( routingTable, connectionPool, seenServers, bookmark, baseError ).thenCompose( composition ->
         {
             if ( composition != null )
             {
                 return completedFuture( composition );
             }
-            return lookupOnInitialRouter( routingTable, connectionPool, seenServers, bookmark );
+            return lookupOnInitialRouter( routingTable, connectionPool, seenServers, bookmark, baseError );
         } );
     }
 
     private CompletionStage<ClusterComposition> lookupOnInitialRouterThenOnKnownRouters( RoutingTable routingTable,
-            ConnectionPool connectionPool, Bookmark bookmark )
+            ConnectionPool connectionPool, Bookmark bookmark, Throwable baseError )
     {
         Set<BoltServerAddress> seenServers = emptySet();
-        return lookupOnInitialRouter( routingTable, connectionPool, seenServers, bookmark ).thenCompose( composition ->
+        return lookupOnInitialRouter( routingTable, connectionPool, seenServers, bookmark, baseError ).thenCompose( composition ->
         {
             if ( composition != null )
             {
                 return completedFuture( composition );
             }
-            return lookupOnKnownRouters( routingTable, connectionPool, new HashSet<>(), bookmark );
+            return lookupOnKnownRouters( routingTable, connectionPool, new HashSet<>(), bookmark, baseError );
         } );
     }
 
-    private CompletionStage<ClusterComposition> lookupOnKnownRouters( RoutingTable routingTable,
-            ConnectionPool connectionPool, Set<BoltServerAddress> seenServers, Bookmark bookmark )
+    private CompletionStage<ClusterComposition> lookupOnKnownRouters( RoutingTable routingTable, ConnectionPool connectionPool, Set<BoltServerAddress> seenServers, Bookmark bookmark,
+            Throwable baseError )
     {
         BoltServerAddress[] addresses = routingTable.routers().toArray();
 
@@ -184,16 +189,16 @@ private CompletionStage<ClusterComposition> lookupOnKnownRouters( RoutingTable r
                 }
                 else
                 {
-                    return lookupOnRouter( address, routingTable, connectionPool, bookmark )
+                    return lookupOnRouter( address, routingTable, connectionPool, bookmark, baseError )
                             .whenComplete( ( ignore, error ) -> seenServers.add( address ) );
                 }
             } );
         }
         return result;
     }
 
-    private CompletionStage<ClusterComposition> lookupOnInitialRouter( RoutingTable routingTable,
-            ConnectionPool connectionPool, Set<BoltServerAddress> seenServers, Bookmark bookmark )
+    private CompletionStage<ClusterComposition> lookupOnInitialRouter( RoutingTable routingTable, ConnectionPool connectionPool, Set<BoltServerAddress> seenServers, Bookmark bookmark,
+            Throwable baseError )
     {
         List<BoltServerAddress> addresses;
         try
@@ -215,14 +220,14 @@ private CompletionStage<ClusterComposition> lookupOnInitialRouter( RoutingTable
                 {
                     return completedFuture( composition );
                 }
-                return lookupOnRouter( address, routingTable, connectionPool, bookmark );
+                return lookupOnRouter( address, routingTable, connectionPool, bookmark, baseError );
             } );
         }
         return result;
     }
 
     private CompletionStage<ClusterComposition> lookupOnRouter( BoltServerAddress routerAddress,
-            RoutingTable routingTable, ConnectionPool connectionPool, Bookmark bookmark )
+            RoutingTable routingTable, ConnectionPool connectionPool, Bookmark bookmark, Throwable baseError )
     {
         CompletionStage<Connection> connectionStage = connectionPool.acquire( routerAddress );
 
@@ -232,7 +237,7 @@ private CompletionStage<ClusterComposition> lookupOnRouter( BoltServerAddress ro
                     Throwable cause = Futures.completionExceptionCause( error );
                     if ( cause != null )
                     {
-                        return handleRoutingProcedureError( cause, routingTable, routerAddress );
+                        return handleRoutingProcedureError( cause, routingTable, routerAddress, baseError );
                     }
                     else
                     {
@@ -242,7 +247,7 @@ private CompletionStage<ClusterComposition> lookupOnRouter( BoltServerAddress ro
     }
 
     private ClusterComposition handleRoutingProcedureError( Throwable error, RoutingTable routingTable,
-            BoltServerAddress routerAddress )
+            BoltServerAddress routerAddress, Throwable baseError )
     {
         if ( error instanceof SecurityException || error instanceof FatalDiscoveryException )
         {
@@ -251,7 +256,10 @@ private ClusterComposition handleRoutingProcedureError( Throwable error, Routing
         }
 
         // Retriable error happened during discovery.
-        logger.warn( format( "Failed to update routing table with server '%s'.", routerAddress ), error );
+        DiscoveryException discoveryError = new DiscoveryException( format( RECOVERABLE_ROUTING_ERROR, routerAddress ), error );
+        Futures.combineErrors( baseError, discoveryError ); // we record each failure here
+        logger.warn( format( "Received a recoverable discovery error with server '%s', will continue discovery with other routing servers if available.",
+                routerAddress ), discoveryError );
         routingTable.forget( routerAddress );
         return null;
     }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/util/ErrorUtil.java b/driver/src/main/java/org/neo4j/driver/internal/util/ErrorUtil.java
@@ -50,8 +50,8 @@ public static ServiceUnavailableException newConnectionTerminatedError( String r
     public static ServiceUnavailableException newConnectionTerminatedError()
     {
         return new ServiceUnavailableException( "Connection to the database terminated. " +
-                                                "This can happen due to network instabilities, " +
-                                                "or due to restarts of the database" );
+                "Please ensure that your database is listening on the correct host and port and that you have compatible encryption settings both on Neo4j server and driver. " +
+                "Note that the default encryption setting has changed in Neo4j 4.0." );
     }
 
     public static ResultConsumedException newResultConsumedError()
diff --git a/driver/src/test/java/org/neo4j/driver/integration/EncryptionIT.java b/driver/src/test/java/org/neo4j/driver/integration/EncryptionIT.java
@@ -25,8 +25,8 @@
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.GraphDatabase;
 import org.neo4j.driver.Record;
-import org.neo4j.driver.Session;
 import org.neo4j.driver.Result;
+import org.neo4j.driver.Session;
 import org.neo4j.driver.exceptions.ServiceUnavailableException;
 import org.neo4j.driver.util.DatabaseExtension;
 import org.neo4j.driver.util.Neo4jSettings;
@@ -35,7 +35,6 @@
 
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.startsWith;
-import static org.hamcrest.Matchers.instanceOf;
 import static org.hamcrest.junit.MatcherAssert.assertThat;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.neo4j.driver.Config.TrustStrategy.trustAllCertificates;
@@ -107,10 +106,9 @@ private void testMismatchingEncryption( BoltTlsLevel tlsLevel, boolean driverEnc
         neo4j.restartDb( Neo4jSettings.TEST_SETTINGS.updateWith( Neo4jSettings.BOLT_TLS_LEVEL, tlsLevel.toString() ) );
         Config config = newConfig( driverEncrypted );
 
-        RuntimeException e = assertThrows( RuntimeException.class,
+        ServiceUnavailableException e = assertThrows( ServiceUnavailableException.class,
                 () -> GraphDatabase.driver( neo4j.uri(), neo4j.authToken(), config ).verifyConnectivity() );
 
-        assertThat( e, instanceOf( ServiceUnavailableException.class ) );
         assertThat( e.getMessage(), startsWith( "Connection to the database terminated" ) );
     }
 
diff --git a/driver/src/test/java/org/neo4j/driver/internal/cluster/RediscoveryTest.java b/driver/src/test/java/org/neo4j/driver/internal/cluster/RediscoveryTest.java
@@ -20,13 +20,15 @@
 
 import io.netty.util.concurrent.GlobalEventExecutor;
 import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
 
 import java.io.IOException;
 import java.util.HashMap;
 import java.util.Map;
 
 import org.neo4j.driver.Logger;
 import org.neo4j.driver.exceptions.AuthenticationException;
+import org.neo4j.driver.exceptions.DiscoveryException;
 import org.neo4j.driver.exceptions.ProtocolException;
 import org.neo4j.driver.exceptions.ServiceUnavailableException;
 import org.neo4j.driver.exceptions.SessionExpiredException;
@@ -44,11 +46,13 @@
 import static java.util.Collections.singletonMap;
 import static java.util.concurrent.CompletableFuture.completedFuture;
 import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assert.assertThat;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.startsWith;
@@ -178,7 +182,9 @@ void shouldFailImmediatelyWhenClusterCompositionProviderReturnsFailure()
         ClusterComposition composition = await( rediscovery.lookupClusterComposition( table, pool, empty() ) );
         assertEquals( validComposition, composition );
 
-        verify( logger ).warn( String.format( "Failed to update routing table with server '%s'.", B ), protocolError );
+        ArgumentCaptor<DiscoveryException> argument = ArgumentCaptor.forClass( DiscoveryException.class );
+        verify( logger ).warn( anyString(), argument.capture() );
+        assertThat( argument.getValue().getCause(), equalTo( protocolError ) );
     }
 
     @Test
@@ -260,19 +266,26 @@ void shouldPropagateFailureWhenResolverFails()
     }
 
     @Test
-    void shouldFailWhenNoRoutersRespond()
+    void shouldRecordAllErrorsWhenNoRouterRespond()
     {
         Map<BoltServerAddress,Object> responsesByAddress = new HashMap<>();
-        responsesByAddress.put( A, new ServiceUnavailableException( "Hi!" ) ); // first -> non-fatal failure
-        responsesByAddress.put( B, new SessionExpiredException( "Hi!" ) ); // second -> non-fatal failure
-        responsesByAddress.put( C, new IOException( "Hi!" ) ); // third -> non-fatal failure
+        ServiceUnavailableException first = new ServiceUnavailableException( "Hi!" );
+        responsesByAddress.put( A, first ); // first -> non-fatal failure
+        SessionExpiredException second = new SessionExpiredException( "Hi!" );
+        responsesByAddress.put( B, second ); // second -> non-fatal failure
+        IOException third = new IOException( "Hi!" );
+        responsesByAddress.put( C, third ); // third -> non-fatal failure
 
         ClusterCompositionProvider compositionProvider = compositionProviderMock( responsesByAddress );
         Rediscovery rediscovery = newRediscovery( A, compositionProvider, mock( ServerAddressResolver.class ) );
         RoutingTable table = routingTableMock( A, B, C );
 
         ServiceUnavailableException e = assertThrows( ServiceUnavailableException.class, () -> await( rediscovery.lookupClusterComposition( table, pool, empty() ) ) );
         assertThat( e.getMessage(), containsString( "Could not perform discovery" ) );
+        assertThat( e.getSuppressed().length, equalTo( 3 ) );
+        assertThat( e.getSuppressed()[0].getCause(), equalTo( first ) );
+        assertThat( e.getSuppressed()[1].getCause(), equalTo( second ) );
+        assertThat( e.getSuppressed()[2].getCause(), equalTo( third ) );
     }
 
     @Test

Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,7 @@`
`32`	`32`
`33`	`33`	`import org.neo4j.driver.Bookmark;`
`34`	`34`	`import org.neo4j.driver.Logger;`
	`35`	`+import org.neo4j.driver.exceptions.DiscoveryException;`
`35`	`36`	`import org.neo4j.driver.exceptions.FatalDiscoveryException;`
`36`	`37`	`import org.neo4j.driver.exceptions.SecurityException;`
`37`	`38`	`import org.neo4j.driver.exceptions.ServiceUnavailableException;`
`@@ -55,6 +56,7 @@`
`55`	`56`	`public class RediscoveryImpl implements Rediscovery`
`56`	`57`	`{`
`57`	`58`	`private static final String NO_ROUTERS_AVAILABLE = "Could not perform discovery for database '%s'. No routing server available.";`
	`59`	`+ private static final String RECOVERABLE_ROUTING_ERROR = "Failed to update routing table with server '%s'.";`
`58`	`60`
`59`	`61`	`private final BoltServerAddress initialRouter;`
`60`	`62`	`private final RoutingSettings settings;`
`@@ -86,14 +88,16 @@ public RediscoveryImpl( BoltServerAddress initialRouter, RoutingSettings setting`
`86`	`88`	`public CompletionStage<ClusterComposition> lookupClusterComposition( RoutingTable routingTable, ConnectionPool connectionPool, Bookmark bookmark )`
`87`	`89`	`{`
`88`	`90`	`CompletableFuture<ClusterComposition> result = new CompletableFuture<>();`
`89`		`- lookupClusterComposition( routingTable, connectionPool, 0, 0, result, bookmark );`
	`91`	`+ // if we failed discovery, we will chain all errors into this one.`
	`92`	`+ ServiceUnavailableException baseError = new ServiceUnavailableException( NO_ROUTERS_AVAILABLE );`
	`93`	`+ lookupClusterComposition( routingTable, connectionPool, 0, 0, result, bookmark, baseError );`
`90`	`94`	`return result;`
`91`	`95`	`}`
`92`	`96`
`93`	`97`	`private void lookupClusterComposition( RoutingTable routingTable, ConnectionPool pool,`
`94`		`- int failures, long previousDelay, CompletableFuture<ClusterComposition> result, Bookmark bookmark )`
	`98`	`+ int failures, long previousDelay, CompletableFuture<ClusterComposition> result, Bookmark bookmark, Throwable baseError )`
`95`	`99`	`{`
`96`		`- lookup( routingTable, pool, bookmark ).whenComplete( ( composition, completionError ) ->`
	`100`	`+ lookup( routingTable, pool, bookmark, baseError ).whenComplete( ( composition, completionError ) ->`
`97`	`101`	`{`
`98`	`102`	`Throwable error = Futures.completionExceptionCause( completionError );`
`99`	`103`	`if ( error != null )`
`@@ -109,67 +113,68 @@ else if ( composition != null )`
`109`	`113`	`int newFailures = failures + 1;`
`110`	`114`	`if ( newFailures >= settings.maxRoutingFailures() )`
`111`	`115`	`{`
`112`		`- result.completeExceptionally( new ServiceUnavailableException( String.format( NO_ROUTERS_AVAILABLE, routingTable.database().description() ) ) );`
	`116`	`+ // now we throw our saved error out`
	`117`	`+ result.completeExceptionally( baseError );`
`113`	`118`	`}`
`114`	`119`	`else`
`115`	`120`	`{`
`116`	`121`	`long nextDelay = Math.max( settings.retryTimeoutDelay(), previousDelay * 2 );`
`117`	`122`	`logger.info( "Unable to fetch new routing table, will try again in " + nextDelay + "ms" );`
`118`	`123`	`eventExecutorGroup.next().schedule(`
`119`		`- () -> lookupClusterComposition( routingTable, pool, newFailures, nextDelay, result, bookmark ),`
	`124`	`+ () -> lookupClusterComposition( routingTable, pool, newFailures, nextDelay, result, bookmark, baseError ),`
`120`	`125`	`nextDelay, TimeUnit.MILLISECONDS`
`121`	`126`	`);`
`122`	`127`	`}`
`123`	`128`	`}`
`124`	`129`	`} );`
`125`	`130`	`}`
`126`	`131`
`127`		`- private CompletionStage<ClusterComposition> lookup( RoutingTable routingTable, ConnectionPool connectionPool, Bookmark bookmark )`
	`132`	`+ private CompletionStage<ClusterComposition> lookup( RoutingTable routingTable, ConnectionPool connectionPool, Bookmark bookmark, Throwable baseError )`
`128`	`133`	`{`
`129`	`134`	`CompletionStage<ClusterComposition> compositionStage;`
`130`	`135`
`131`	`136`	`if ( routingTable.preferInitialRouter() )`
`132`	`137`	`{`
`133`		`- compositionStage = lookupOnInitialRouterThenOnKnownRouters( routingTable, connectionPool, bookmark );`
	`138`	`+ compositionStage = lookupOnInitialRouterThenOnKnownRouters( routingTable, connectionPool, bookmark, baseError );`
`134`	`139`	`}`
`135`	`140`	`else`
`136`	`141`	`{`
`137`		`- compositionStage = lookupOnKnownRoutersThenOnInitialRouter( routingTable, connectionPool, bookmark );`
	`142`	`+ compositionStage = lookupOnKnownRoutersThenOnInitialRouter( routingTable, connectionPool, bookmark, baseError );`
`138`	`143`	`}`
`139`	`144`
`140`	`145`	`return compositionStage;`
`141`	`146`	`}`
`142`	`147`
`143`		`- private CompletionStage<ClusterComposition> lookupOnKnownRoutersThenOnInitialRouter( RoutingTable routingTable,`
`144`		`- ConnectionPool connectionPool, Bookmark bookmark )`
	`148`	`+ private CompletionStage<ClusterComposition> lookupOnKnownRoutersThenOnInitialRouter( RoutingTable routingTable, ConnectionPool connectionPool,`
	`149`	`+ Bookmark bookmark, Throwable baseError )`
`145`	`150`	`{`
`146`	`151`	`Set<BoltServerAddress> seenServers = new HashSet<>();`
`147`		`- return lookupOnKnownRouters( routingTable, connectionPool, seenServers, bookmark ).thenCompose( composition ->`
	`152`	`+ return lookupOnKnownRouters( routingTable, connectionPool, seenServers, bookmark, baseError ).thenCompose( composition ->`
`148`	`153`	`{`
`149`	`154`	`if ( composition != null )`
`150`	`155`	`{`
`151`	`156`	`return completedFuture( composition );`
`152`	`157`	`}`
`153`		`- return lookupOnInitialRouter( routingTable, connectionPool, seenServers, bookmark );`
	`158`	`+ return lookupOnInitialRouter( routingTable, connectionPool, seenServers, bookmark, baseError );`
`154`	`159`	`} );`
`155`	`160`	`}`
`156`	`161`
`157`	`162`	`private CompletionStage<ClusterComposition> lookupOnInitialRouterThenOnKnownRouters( RoutingTable routingTable,`
`158`		`- ConnectionPool connectionPool, Bookmark bookmark )`
	`163`	`+ ConnectionPool connectionPool, Bookmark bookmark, Throwable baseError )`
`159`	`164`	`{`
`160`	`165`	`Set<BoltServerAddress> seenServers = emptySet();`
`161`		`- return lookupOnInitialRouter( routingTable, connectionPool, seenServers, bookmark ).thenCompose( composition ->`
	`166`	`+ return lookupOnInitialRouter( routingTable, connectionPool, seenServers, bookmark, baseError ).thenCompose( composition ->`
`162`	`167`	`{`
`163`	`168`	`if ( composition != null )`
`164`	`169`	`{`
`165`	`170`	`return completedFuture( composition );`
`166`	`171`	`}`
`167`		`- return lookupOnKnownRouters( routingTable, connectionPool, new HashSet<>(), bookmark );`
	`172`	`+ return lookupOnKnownRouters( routingTable, connectionPool, new HashSet<>(), bookmark, baseError );`
`168`	`173`	`} );`
`169`	`174`	`}`
`170`	`175`
`171`		`- private CompletionStage<ClusterComposition> lookupOnKnownRouters( RoutingTable routingTable,`
`172`		`- ConnectionPool connectionPool, Set<BoltServerAddress> seenServers, Bookmark bookmark )`
	`176`	`+ private CompletionStage<ClusterComposition> lookupOnKnownRouters( RoutingTable routingTable, ConnectionPool connectionPool, Set<BoltServerAddress> seenServers, Bookmark bookmark,`
	`177`	`+ Throwable baseError )`
`173`	`178`	`{`
`174`	`179`	`BoltServerAddress[] addresses = routingTable.routers().toArray();`
`175`	`180`
`@@ -184,16 +189,16 @@ private CompletionStage<ClusterComposition> lookupOnKnownRouters( RoutingTable r`
`184`	`189`	`}`
`185`	`190`	`else`
`186`	`191`	`{`
`187`		`- return lookupOnRouter( address, routingTable, connectionPool, bookmark )`
	`192`	`+ return lookupOnRouter( address, routingTable, connectionPool, bookmark, baseError )`
`188`	`193`	`.whenComplete( ( ignore, error ) -> seenServers.add( address ) );`
`189`	`194`	`}`
`190`	`195`	`} );`
`191`	`196`	`}`
`192`	`197`	`return result;`
`193`	`198`	`}`
`194`	`199`
`195`		`- private CompletionStage<ClusterComposition> lookupOnInitialRouter( RoutingTable routingTable,`
`196`		`- ConnectionPool connectionPool, Set<BoltServerAddress> seenServers, Bookmark bookmark )`
	`200`	`+ private CompletionStage<ClusterComposition> lookupOnInitialRouter( RoutingTable routingTable, ConnectionPool connectionPool, Set<BoltServerAddress> seenServers, Bookmark bookmark,`
	`201`	`+ Throwable baseError )`
`197`	`202`	`{`
`198`	`203`	`List<BoltServerAddress> addresses;`
`199`	`204`	`try`
`@@ -215,14 +220,14 @@ private CompletionStage<ClusterComposition> lookupOnInitialRouter( RoutingTable`
`215`	`220`	`{`
`216`	`221`	`return completedFuture( composition );`
`217`	`222`	`}`
`218`		`- return lookupOnRouter( address, routingTable, connectionPool, bookmark );`
	`223`	`+ return lookupOnRouter( address, routingTable, connectionPool, bookmark, baseError );`
`219`	`224`	`} );`
`220`	`225`	`}`
`221`	`226`	`return result;`
`222`	`227`	`}`
`223`	`228`
`224`	`229`	`private CompletionStage<ClusterComposition> lookupOnRouter( BoltServerAddress routerAddress,`
`225`		`- RoutingTable routingTable, ConnectionPool connectionPool, Bookmark bookmark )`
	`230`	`+ RoutingTable routingTable, ConnectionPool connectionPool, Bookmark bookmark, Throwable baseError )`
`226`	`231`	`{`
`227`	`232`	`CompletionStage<Connection> connectionStage = connectionPool.acquire( routerAddress );`
`228`	`233`
`@@ -232,7 +237,7 @@ private CompletionStage<ClusterComposition> lookupOnRouter( BoltServerAddress ro`
`232`	`237`	`Throwable cause = Futures.completionExceptionCause( error );`
`233`	`238`	`if ( cause != null )`
`234`	`239`	`{`
`235`		`- return handleRoutingProcedureError( cause, routingTable, routerAddress );`
	`240`	`+ return handleRoutingProcedureError( cause, routingTable, routerAddress, baseError );`
`236`	`241`	`}`
`237`	`242`	`else`
`238`	`243`	`{`
`@@ -242,7 +247,7 @@ private CompletionStage<ClusterComposition> lookupOnRouter( BoltServerAddress ro`
`242`	`247`	`}`
`243`	`248`
`244`	`249`	`private ClusterComposition handleRoutingProcedureError( Throwable error, RoutingTable routingTable,`
`245`		`- BoltServerAddress routerAddress )`
	`250`	`+ BoltServerAddress routerAddress, Throwable baseError )`
`246`	`251`	`{`
`247`	`252`	`if ( error instanceof SecurityException \|\| error instanceof FatalDiscoveryException )`
`248`	`253`	`{`
`@@ -251,7 +256,10 @@ private ClusterComposition handleRoutingProcedureError( Throwable error, Routing`
`251`	`256`	`}`
`252`	`257`
`253`	`258`	`// Retriable error happened during discovery.`
`254`		`- logger.warn( format( "Failed to update routing table with server '%s'.", routerAddress ), error );`
	`259`	`+ DiscoveryException discoveryError = new DiscoveryException( format( RECOVERABLE_ROUTING_ERROR, routerAddress ), error );`
	`260`	`+ Futures.combineErrors( baseError, discoveryError ); // we record each failure here`
	`261`	`+ logger.warn( format( "Received a recoverable discovery error with server '%s', will continue discovery with other routing servers if available.",`
	`262`	`+ routerAddress ), discoveryError );`
`255`	`263`	`routingTable.forget( routerAddress );`
`256`	`264`	`return null;`
`257`	`265`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,8 +50,8 @@ public static ServiceUnavailableException newConnectionTerminatedError( String r`
`50`	`50`	`public static ServiceUnavailableException newConnectionTerminatedError()`
`51`	`51`	`{`
`52`	`52`	`return new ServiceUnavailableException( "Connection to the database terminated. " +`
`53`		`- "This can happen due to network instabilities, " +`
`54`		`- "or due to restarts of the database" );`
	`53`	`+ "Please ensure that your database is listening on the correct host and port and that you have compatible encryption settings both on Neo4j server and driver. " +`
	`54`	`+ "Note that the default encryption setting has changed in Neo4j 4.0." );`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`public static ResultConsumedException newResultConsumedError()`