Throw ServiceUnavailableException when unable to connect

Driver verifies connectivity on creation. It closes the connection pool
when thread is interrupted. Previously original `IllegalStateException`
from the closed pool has been propagated to the user.

This commit makes connectivity verification always throw
`ServiceUnavailableException`.

Author: lutovich

driver/src/main/java/org/neo4j/driver/internal/DriverFactory.java

@@ -53,6 +53,7 @@
 import org.neo4j.driver.v1.Logger;
 import org.neo4j.driver.v1.Logging;
 import org.neo4j.driver.v1.exceptions.ClientException;
+import org.neo4j.driver.v1.exceptions.ServiceUnavailableException;
 
 import static java.lang.String.format;
 import static org.neo4j.driver.internal.security.SecurityPlan.insecure;
@@ -78,29 +79,12 @@ public final Driver newInstance( URI uri, AuthToken authToken, RoutingSettings r
 
         ConnectionPool connectionPool = createConnectionPool( authToken, securityPlan, bootstrap, config );
 
-        try
-        {
-            InternalDriver driver = createDriver( uri, address, connectionPool, config, newRoutingSettings,
-                    eventExecutorGroup, securityPlan, retryLogic );
+        InternalDriver driver = createDriver( uri, address, connectionPool, config, newRoutingSettings,
+                eventExecutorGroup, securityPlan, retryLogic );
 
-            // block to verify connectivity, close connection pool if thread gets interrupted
-            Futures.blockingGet( driver.verifyConnectivity(),
-                    () -> closeConnectionPoolOnThreadInterrupt( connectionPool, config.logging() ) );
-            return driver;
-        }
-        catch ( Throwable driverError )
-        {
-            // we need to close the connection pool if driver creation threw exception
-            try
-            {
-                Futures.blockingGet( connectionPool.close() );
-            }
-            catch ( Throwable closeError )
-            {
-                driverError.addSuppressed( closeError );
-            }
-            throw driverError;
-        }
+        verifyConnectivity( driver, connectionPool, config );
+
+        return driver;
     }
 
     protected ConnectionPool createConnectionPool( AuthToken authToken, SecurityPlan securityPlan,
@@ -126,17 +110,26 @@ private InternalDriver createDriver( URI uri, BoltServerAddress address,
             ConnectionPool connectionPool, Config config, RoutingSettings routingSettings,
             EventExecutorGroup eventExecutorGroup, SecurityPlan securityPlan, RetryLogic retryLogic )
     {
-        String scheme = uri.getScheme().toLowerCase();
-        switch ( scheme )
+        try
         {
-        case BOLT_URI_SCHEME:
-            assertNoRoutingContext( uri, routingSettings );
-            return createDirectDriver( address, config, securityPlan, retryLogic, connectionPool );
-        case BOLT_ROUTING_URI_SCHEME:
-            return createRoutingDriver( address, connectionPool, config, routingSettings, securityPlan, retryLogic,
-                    eventExecutorGroup );
-        default:
-            throw new ClientException( format( "Unsupported URI scheme: %s", scheme ) );
+            String scheme = uri.getScheme().toLowerCase();
+            switch ( scheme )
+            {
+            case BOLT_URI_SCHEME:
+                assertNoRoutingContext( uri, routingSettings );
+                return createDirectDriver( address, config, securityPlan, retryLogic, connectionPool );
+            case BOLT_ROUTING_URI_SCHEME:
+                return createRoutingDriver( address, connectionPool, config, routingSettings, securityPlan, retryLogic,
+                        eventExecutorGroup );
+            default:
+                throw new ClientException( format( "Unsupported URI scheme: %s", scheme ) );
+            }
+        }
+        catch ( Throwable driverError )
+        {
+            // we need to close the connection pool if driver creation threw exception
+            closeConnectionPoolAndSuppressError( connectionPool, driverError );
+            throw driverError;
         }
     }
 
@@ -317,6 +310,43 @@ private static void assertNoRoutingContext( URI uri, RoutingSettings routingSett
         }
     }
 
+    private static void verifyConnectivity( InternalDriver driver, ConnectionPool connectionPool, Config config )
+    {
+        try
+        {
+            // block to verify connectivity, close connection pool if thread gets interrupted
+            Futures.blockingGet( driver.verifyConnectivity(),
+                    () -> closeConnectionPoolOnThreadInterrupt( connectionPool, config.logging() ) );
+        }
+        catch ( Throwable connectionError )
+        {
+            // we need to close the connection pool if driver creation threw exception
+            closeConnectionPoolAndSuppressError( connectionPool, connectionError );
+
+            if ( !(connectionError instanceof ServiceUnavailableException) )
+            {
+                throw new ServiceUnavailableException( "Unable to create driver", connectionError );
+            }
+
+            throw connectionError;
+        }
+    }
+
+    private static void closeConnectionPoolAndSuppressError( ConnectionPool connectionPool, Throwable mainError )
+    {
+        try
+        {
+            Futures.blockingGet( connectionPool.close() );
+        }
+        catch ( Throwable closeError )
+        {
+            if ( mainError != closeError )
+            {
+                mainError.addSuppressed( closeError );
+            }
+        }
+    }
+
     private static void closeConnectionPoolOnThreadInterrupt( ConnectionPool pool, Logging logging )
     {
         Logger log = logging.getLog( Driver.class.getSimpleName() );

driver/src/test/java/org/neo4j/driver/v1/GraphDatabaseTest.java

@@ -171,7 +171,7 @@ public void shouldRespondToInterruptsWhenConnectingToUnresponsiveServer() throws
                 GraphDatabase.driver( "bolt://localhost:" + serverSocket.getLocalPort() );
                 fail( "Exception expected" );
             }
-            catch ( Exception ignore )
+            catch ( ServiceUnavailableException ignore )
             {
                 // expected
             }