Upgrade to Netty 4.1.36, support native compilation

driver/pom.xml

@@ -78,6 +78,10 @@
       <groupId>io.projectreactor</groupId>
       <artifactId>reactor-test</artifactId>
     </dependency>
+    <dependency>
+      <groupId>com.oracle.substratevm</groupId>
+      <artifactId>svm</artifactId>
+    </dependency>
   </dependencies>
 
   <build>
@@ -229,6 +233,9 @@
                   <shadedPattern>org.neo4j.driver.internal.shaded.reactor</shadedPattern>
                 </relocation>
               </relocations>
+              <transformers>
+                  <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
+              </transformers>
               <shadeTestJar>true</shadeTestJar>
               <createSourcesJar>true</createSourcesJar>
             </configuration>

driver/src/main/java/org/neo4j/driver/Config.java

@@ -285,6 +285,9 @@ RetrySettings retrySettings()
         return retrySettings;
     }
 
+    /**
+     * @return if the metrics is enabled or not on this driver.
+     */
     public boolean isMetricsEnabled()
     {
         return isMetricsEnabled;

driver/src/main/java/org/neo4j/driver/ConnectionPoolMetrics.java

@@ -102,7 +102,7 @@ enum PoolStatus
     /**
      * The total acquisition time in milliseconds of all connection acquisition requests since the pool is created.
      * See {@link ConnectionPoolMetrics#acquired()} for the total amount of connection acquired since the driver is created.
-     * The average acquisition time can be calculated using the code bellow:
+     * The average acquisition time can be calculated using the code below:
      * <h2>Example</h2>
      * <pre>
      * {@code
@@ -126,7 +126,7 @@ enum PoolStatus
     /**
      * The total time in milliseconds spent to establishing new socket connections since the pool is created.
      * See {@link ConnectionPoolMetrics#created()} for the total amount of connections established since the pool is created.
-     * The average connection time can be calculated using the code bellow:
+     * The average connection time can be calculated using the code below:
      * <h2>Example</h2>
      * <pre>
      * {@code
@@ -150,7 +150,7 @@ enum PoolStatus
     /**
      * The total time in milliseconds connections are borrowed out of the pool, such as the time spent in user's application code to run cypher queries.
      * See {@link ConnectionPoolMetrics#totalInUseCount()} for the total amount of connections that are borrowed out of the pool.
-     * The average in-use time can be calculated using the code bellow:
+     * The average in-use time can be calculated using the code below:
      * <h2>Example</h2>
      * <pre>
      * {@code

driver/src/main/java/org/neo4j/driver/Driver.java

@@ -19,11 +19,10 @@
 package org.neo4j.driver;
 
 import java.util.concurrent.CompletionStage;
-import java.util.function.Consumer;
 
 import org.neo4j.driver.async.AsyncSession;
 import org.neo4j.driver.exceptions.ClientException;
-import org.neo4j.driver.internal.SessionParameters;
+import org.neo4j.driver.internal.SessionConfig;
 import org.neo4j.driver.reactive.RxSession;
 import org.neo4j.driver.types.TypeSystem;
 import org.neo4j.driver.util.Experimental;
@@ -74,21 +73,62 @@ public interface Driver extends AutoCloseable
     boolean isEncrypted();
 
     /**
-     * Create a new general purpose {@link Session} with default {@link SessionParameters session parameters}.
+     * Create a new general purpose {@link Session} with default {@link SessionConfig session configuration}.
      * <p>
-     * Alias to {@link #session(Consumer)}}.
+     * Alias to {@link #session(SessionConfig)}}.
      *
      * @return a new {@link Session} object.
      */
     Session session();
 
     /**
-     * Create a new {@link Session} with a specified {@link SessionParametersTemplate}.
-     * @param templateConsumer specifies how the session parameter shall be built for this session.
+     * Create a new {@link Session} with a specified {@link SessionConfig session configuration}.
+     * Use {@link SessionConfig#forDatabase(String)} to obtain a general purpose session configuration for the specified database.
+     * @param sessionConfig specifies session configurations for this session.
      * @return a new {@link Session} object.
-     * @see SessionParameters
+     * @see SessionConfig
      */
-    Session session( Consumer<SessionParametersTemplate> templateConsumer );
+    Session session( SessionConfig sessionConfig );
+
+    /**
+     * Create a new general purpose {@link RxSession} with default {@link SessionConfig session configuration}.
+     * The {@link RxSession} provides a reactive way to run queries and process results.
+     * <p>
+     * Alias to {@link #rxSession(SessionConfig)}}.
+     *
+     * @return @return a new {@link RxSession} object.
+     */
+    RxSession rxSession();
+
+    /**
+     * Create a new {@link RxSession} with a specified {@link SessionConfig session configuration}.
+     * Use {@link SessionConfig#forDatabase(String)} to obtain a general purpose session configuration for the specified database.
+     * The {@link RxSession} provides a reactive way to run queries and process results.
+     * @param sessionConfig used to customize the session.
+     * @return @return a new {@link RxSession} object.
+     */
+    RxSession rxSession( SessionConfig sessionConfig );
+
+    /**
+     * Create a new general purpose {@link AsyncSession} with default {@link SessionConfig session configuration}.
+     * The {@link AsyncSession} provides an asynchronous way to run queries and process results.
+     * <p>
+     * Alias to {@link #asyncSession(SessionConfig)}}.
+     *
+     * @return @return a new {@link AsyncSession} object.
+     */
+    AsyncSession asyncSession();
+
+    /**
+     * Create a new {@link AsyncSession} with a specified {@link SessionConfig session configuration}.
+     * Use {@link SessionConfig#forDatabase(String)} to obtain a general purpose session configuration for the specified database.
+     * The {@link AsyncSession} provides an asynchronous way to run queries and process results.
+     *
+     * @param sessionConfig used to customize the session.
+     * @return a new {@link AsyncSession} object.
+     */
+    AsyncSession asyncSession( SessionConfig sessionConfig );
+
     /**
      * Close all the resources assigned to this driver, including open connections and IO threads.
      * <p>
@@ -113,51 +153,38 @@ public interface Driver extends AutoCloseable
      * @return the driver metrics if enabled.
      * @throws ClientException if the driver metrics reporting is not enabled.
      */
+    @Experimental
     Metrics metrics();
 
     /**
-     * Create a new general purpose {@link RxSession} with default {@link SessionParameters session parameters}.
-     * The {@link RxSession} provides a reactive way to run queries and process results.
-     * <p>
-     * Alias to {@link #rxSession(Consumer)}}.
+     * This will return the type system supported by the driver.
+     * The types supported on a particular server a session is connected against might not contain all of the types defined here.
      *
-     * @return @return a new {@link RxSession} object.
-     */
-    RxSession rxSession();
-
-    /**
-     * Create a new {@link RxSession} with a specified {@link SessionParametersTemplate}.
-     * The {@link RxSession} provides a reactive way to run queries and process results.
-     * @param templateConsumer used to customize the session parameters.
-     * @return @return a new {@link RxSession} object.
+     * @return type system used by this statement runner for classifying values
      */
-    RxSession rxSession( Consumer<SessionParametersTemplate> templateConsumer );
+    @Experimental
+    TypeSystem defaultTypeSystem();
 
     /**
-     * Create a new general purpose {@link AsyncSession} with default {@link SessionParameters session parameters}.
-     * The {@link AsyncSession} provides an asynchronous way to run queries and process results.
-     * <p>
-     * Alias to {@link #asyncSession(Consumer)}}.
+     * This verifies if the driver can connect to a remote server or a cluster
+     * by establishing a network connection with the remote and possibly exchanging a few data before closing the connection.
      *
-     * @return @return a new {@link AsyncSession} object.
+     * It throws exception if fails to connect. Use the exception to further understand the cause of the connectivity problem.
+     * Note: Even if this method throws an exception, the driver still need to be closed via {@link #close()} to free up all resources.
      */
-    AsyncSession asyncSession();
+    void verifyConnectivity();
 
     /**
-     * Create a new {@link AsyncSession} with a specified {@link SessionParametersTemplate}.
-     * The {@link AsyncSession} provides an asynchronous way to run queries and process results.
+     * This verifies if the driver can connect to a remote server or cluster
+     * by establishing a network connection with the remote and possibly exchanging a few data before closing the connection.
      *
-     * @param templateConsumer used to customize the session parameters.
-     * @return a new {@link AsyncSession} object.
-     */
-    AsyncSession asyncSession( Consumer<SessionParametersTemplate> templateConsumer );
-
-    /**
-     * This will return the type system supported by the driver.
-     * The types supported on a particular server a session is connected against might not contain all of the types defined here.
+     * This operation is asynchronous and returns a {@link CompletionStage}. This stage is completed with
+     * {@code null} when the driver connects to the remote server or cluster successfully.
+     * It is completed exceptionally if the driver failed to connect the remote server or cluster.
+     * This exception can be used to further understand the cause of the connectivity problem.
+     * Note: Even if this method complete exceptionally, the driver still need to be closed via {@link #closeAsync()} to free up all resources.
      *
-     * @return type system used by this statement runner for classifying values
+     * @return a {@link CompletionStage completion stage} that represents the asynchronous verification.
      */
-    @Experimental
-    TypeSystem defaultTypeSystem();
+    CompletionStage<Void> verifyConnectivityAsync();
 }

driver/src/main/java/org/neo4j/driver/GraphDatabase.java

@@ -154,19 +154,40 @@ public static Driver routingDriver( Iterable<URI> routingUris, AuthToken authTok
 
         for ( URI uri : routingUris )
         {
+            final Driver driver = driver( uri, authToken, config );
             try
             {
-                return driver( uri, authToken, config );
+                driver.verifyConnectivity();
+                return driver;
             }
             catch ( ServiceUnavailableException e )
             {
                 log.warn( "Unable to create routing driver for URI: " + uri, e );
+                closeDriver( driver, uri, log );
+            }
+            catch ( Throwable e )
+            {
+                // for any other errors, we first close the driver and then rethrow the original error out.
+                closeDriver( driver, uri, log );
+                throw e;
             }
         }
 
         throw new ServiceUnavailableException( "Failed to discover an available server" );
     }
 
+    private static void closeDriver( Driver driver, URI uri, Logger log )
+    {
+        try
+        {
+            driver.close();
+        }
+        catch ( Throwable closeError )
+        {
+            log.warn( "Unable to close driver towards URI: " + uri, closeError );
+        }
+    }
+
     private static void assertRoutingUris( Iterable<URI> uris )
     {
         for ( URI uri : uris )

driver/src/main/java/org/neo4j/driver/exceptions/FatalDiscoveryException.java

@@ -0,0 +1,37 @@
+/*
+ * 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;
+
+/**
+ * This error indicate a fatal problem to obtain routing tables such as the routing table for a specified database does not exist.
+ * This exception should not be retried.
+ * @since 2.0
+ */
+public class FatalDiscoveryException extends ClientException
+{
+    public FatalDiscoveryException( String message )
+    {
+        super( message );
+    }
+
+    public FatalDiscoveryException( String code, String message )
+    {
+        super( code, message );
+    }
+}

driver/src/main/java/org/neo4j/driver/exceptions/SecurityException.java

@@ -24,7 +24,7 @@
  * Restart of server/driver/cluster might be required to recover from this error.
  * @since 1.1
  */
-public class SecurityException extends Neo4jException
+public class SecurityException extends ClientException
 {
     public SecurityException( String code, String message )
     {

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

@@ -21,7 +21,7 @@
 import java.util.concurrent.CompletionStage;
 
 import org.neo4j.driver.AccessMode;
-import org.neo4j.driver.internal.async.connection.DecoratedConnection;
+import org.neo4j.driver.internal.async.connection.DirectConnection;
 import org.neo4j.driver.internal.spi.Connection;
 import org.neo4j.driver.internal.spi.ConnectionPool;
 import org.neo4j.driver.internal.spi.ConnectionProvider;
@@ -47,13 +47,14 @@ public class DirectConnectionProvider implements ConnectionProvider
     @Override
     public CompletionStage<Connection> acquireConnection( String databaseName, AccessMode mode )
     {
-        return connectionPool.acquire( address ).thenApply( connection -> new DecoratedConnection( connection, databaseName, mode ) );
+        return connectionPool.acquire( address ).thenApply( connection -> new DirectConnection( connection, databaseName, mode ) );
     }
 
     @Override
     public CompletionStage<Void> verifyConnectivity()
     {
-        // we verify the connection by establishing the connection to the default database
+        // We verify the connection by establishing a connection with the remote server specified by the address.
+        // Database name will be ignored as no query is run in this connection and the connection is released immediately.
         return acquireConnection( ABSENT_DB_NAME, READ ).thenCompose( Connection::release );
     }