Perform writes fully in event loop

`NettyConnection` is the abstraction over netty channel that allows us
to write RUN, PULL_ALL and other messages. Currently write consists of
two steps: (1) enqueue a response handler (2) perform actual write.
Step (1) is executed in the caller thread and step (2) is always
executed in the event loop thread (guaranteed by Netty).

Step (1) involves modification of a non-synchronized `LinkedList`
which is a problem. Later event loop thread will try to pop handlers
from the same list meaning we access it from different threads.

This commit make both (1) and (2) execute in the event loop to avoid
synchronization issues. It basically makes sure
`InboundMessageDispatcher` is only accessed by the event loop.

Also removed `ConcurrentSet` implementation in favour of the one
existing in Netty.

Author: lutovich

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

@@ -45,6 +45,7 @@
 import org.neo4j.driver.v1.exceptions.Neo4jException;
 import org.neo4j.driver.v1.types.TypeSystem;
 
+import static java.util.Collections.emptyMap;
 import static java.util.concurrent.CompletableFuture.completedFuture;
 import static org.neo4j.driver.internal.async.Futures.failedFuture;
 import static org.neo4j.driver.internal.util.ErrorUtil.isRecoverable;
@@ -120,19 +121,16 @@ public void begin( Bookmark initialBookmark )
 
     public CompletionStage<ExplicitTransaction> beginAsync( Bookmark initialBookmark )
     {
-        Map<String,Value> parameters = initialBookmark.asBeginTransactionParameters();
-        asyncConnection.run( BEGIN_QUERY, parameters, NoOpResponseHandler.INSTANCE );
-
         if ( initialBookmark.isEmpty() )
         {
-            asyncConnection.pullAll( NoOpResponseHandler.INSTANCE );
+            asyncConnection.run( BEGIN_QUERY, emptyMap(), NoOpResponseHandler.INSTANCE, NoOpResponseHandler.INSTANCE );
             return completedFuture( this );
         }
         else
         {
             CompletableFuture<ExplicitTransaction> beginFuture = new CompletableFuture<>();
-            asyncConnection.pullAll( new BeginTxResponseHandler<>( beginFuture, this ) );
-            asyncConnection.flush();
+            asyncConnection.runAndFlush( BEGIN_QUERY, initialBookmark.asBeginTransactionParameters(),
+                    NoOpResponseHandler.INSTANCE, new BeginTxResponseHandler<>( beginFuture, this ) );
             return beginFuture;
         }
     }
@@ -258,10 +256,8 @@ private BiConsumer<Void,Throwable> releaseConnectionAndNotifySession()
     private CompletionStage<Void> doCommitAsync()
     {
         CompletableFuture<Void> commitFuture = new CompletableFuture<>();
-
-        asyncConnection.run( COMMIT_QUERY, Collections.emptyMap(), NoOpResponseHandler.INSTANCE );
-        asyncConnection.pullAll( new CommitTxResponseHandler( commitFuture, this ) );
-        asyncConnection.flush();
+        asyncConnection.runAndFlush( COMMIT_QUERY, emptyMap(), NoOpResponseHandler.INSTANCE,
+                new CommitTxResponseHandler( commitFuture, this ) );
 
         return commitFuture.thenApply( ignore ->
         {
@@ -273,9 +269,8 @@ private CompletionStage<Void> doCommitAsync()
     private CompletionStage<Void> doRollbackAsync()
     {
         CompletableFuture<Void> rollbackFuture = new CompletableFuture<>();
-        asyncConnection.run( ROLLBACK_QUERY, Collections.emptyMap(), NoOpResponseHandler.INSTANCE );
-        asyncConnection.pullAll( new RollbackTxResponseHandler( rollbackFuture ) );
-        asyncConnection.flush();
+        asyncConnection.runAndFlush( ROLLBACK_QUERY, emptyMap(), NoOpResponseHandler.INSTANCE,
+                new RollbackTxResponseHandler( rollbackFuture ) );
 
         return rollbackFuture.thenApply( ignore ->
         {

driver/src/main/java/org/neo4j/driver/internal/async/AsyncConnection.java

@@ -33,11 +33,11 @@ public interface AsyncConnection
 
     void disableAutoRead();
 
-    void run( String statement, Map<String,Value> parameters, ResponseHandler handler );
+    void run( String statement, Map<String,Value> parameters, ResponseHandler runHandler,
+            ResponseHandler pullAllHandler );
 
-    void pullAll( ResponseHandler handler );
-
-    void flush();
+    void runAndFlush( String statement, Map<String,Value> parameters, ResponseHandler runHandler,
+            ResponseHandler pullAllHandler );
 
     void release();
 

driver/src/main/java/org/neo4j/driver/internal/async/NettyConnection.java

@@ -19,6 +19,7 @@
 package org.neo4j.driver.internal.async;
 
 import io.netty.channel.Channel;
+import io.netty.channel.EventLoop;
 import io.netty.channel.pool.ChannelPool;
 import io.netty.util.concurrent.Promise;
 
@@ -74,7 +75,6 @@ public void enableAutoRead()
     {
         if ( autoReadEnabled.compareAndSet( false, true ) )
         {
-            System.out.println( "=== enableAutoRead" );
             setAutoRead( true );
         }
     }
@@ -84,35 +84,30 @@ public void disableAutoRead()
     {
         if ( autoReadEnabled.compareAndSet( true, false ) )
         {
-            System.out.println( "=== disableAutoRead" );
             setAutoRead( false );
         }
     }
 
     @Override
-    public void run( String statement, Map<String,Value> parameters, ResponseHandler handler )
+    public void run( String statement, Map<String,Value> parameters, ResponseHandler runHandler,
+            ResponseHandler pullAllHandler )
     {
-        write( new RunMessage( statement, parameters ), handler, false );
+        run( statement, parameters, runHandler, pullAllHandler, false );
     }
 
     @Override
-    public void pullAll( ResponseHandler handler )
+    public void runAndFlush( String statement, Map<String,Value> parameters, ResponseHandler runHandler,
+            ResponseHandler pullAllHandler )
     {
-        write( PullAllMessage.PULL_ALL, handler, false );
-    }
-
-    @Override
-    public void flush()
-    {
-        channel.flush();
+        run( statement, parameters, runHandler, pullAllHandler, true );
     }
 
     @Override
     public void release()
     {
         if ( state.release() )
         {
-            write( ResetMessage.RESET, new ReleaseChannelHandler( channel, channelPool, clock ), true );
+            reset( new ReleaseChannelHandler( channel, channelPool, clock ) );
         }
     }
 
@@ -122,7 +117,7 @@ public CompletionStage<Void> forceRelease()
         if ( state.forceRelease() )
         {
             Promise<Void> releasePromise = channel.eventLoop().newPromise();
-            write( ResetMessage.RESET, new ReleaseChannelHandler( channel, channelPool, clock, releasePromise ), true );
+            reset( new ReleaseChannelHandler( channel, channelPool, clock, releasePromise ) );
             return asCompletionStage( releasePromise );
         }
         else
@@ -137,19 +132,71 @@ public ServerInfo serverInfo()
         return new InternalServerInfo( address( channel ), serverVersion( channel ) );
     }
 
-    private void write( Message message, ResponseHandler handler, boolean flush )
+    private void run( String statement, Map<String,Value> parameters, ResponseHandler runHandler,
+            ResponseHandler pullAllHandler, boolean flush )
     {
-        messageDispatcher.queue( handler );
+        writeMessagesInEventLoop( new RunMessage( statement, parameters ), runHandler, PullAllMessage.PULL_ALL,
+                pullAllHandler, flush );
+    }
+
+    private void reset( ResponseHandler resetHandler )
+    {
+        writeAndFlushMessageInEventLoop( ResetMessage.RESET, resetHandler );
+    }
+
+    private void writeMessagesInEventLoop( Message message1, ResponseHandler handler1, Message message2,
+            ResponseHandler handler2, boolean flush )
+    {
+        EventLoop eventLoop = channel.eventLoop();
+
+        if ( eventLoop.inEventLoop() )
+        {
+            writeMessages( message1, handler1, message2, handler2, flush );
+        }
+        else
+        {
+            eventLoop.execute( () -> writeMessages( message1, handler1, message2, handler2, flush ) );
+        }
+    }
+
+    private void writeAndFlushMessageInEventLoop( Message message, ResponseHandler handler )
+    {
+        EventLoop eventLoop = channel.eventLoop();
+
+        if ( eventLoop.inEventLoop() )
+        {
+            writeAndFlushMessage( message, handler );
+        }
+        else
+        {
+            eventLoop.execute( () -> writeAndFlushMessage( message, handler ) );
+        }
+    }
+
+    private void writeMessages( Message message1, ResponseHandler handler1, Message message2, ResponseHandler handler2,
+            boolean flush )
+    {
+        messageDispatcher.queue( handler1 );
+        messageDispatcher.queue( handler2 );
+
+        channel.write( message1 );
+
         if ( flush )
         {
-            channel.writeAndFlush( message );
+            channel.writeAndFlush( message2 );
         }
         else
         {
-            channel.write( message );
+            channel.write( message2 );
         }
     }
 
+    private void writeAndFlushMessage( Message message, ResponseHandler handler )
+    {
+        messageDispatcher.queue( handler );
+        channel.writeAndFlush( message );
+    }
+
     private void setAutoRead( boolean value )
     {
         channel.config().setAutoRead( value );

driver/src/main/java/org/neo4j/driver/internal/async/QueryRunner.java

@@ -54,9 +54,7 @@ public static CompletionStage<StatementResultCursor> runAsync( AsyncConnection c
         RunResponseHandler runHandler = new RunResponseHandler( runCompletedFuture, tx );
         PullAllResponseHandler pullAllHandler = newPullAllHandler( statement, runHandler, connection, tx );
 
-        connection.run( query, params, runHandler );
-        connection.pullAll( pullAllHandler );
-        connection.flush();
+        connection.runAndFlush( query, params, runHandler, pullAllHandler );
 
         return runCompletedFuture.thenApply( ignore ->
                 new InternalStatementResultCursor( runHandler, pullAllHandler ) );

driver/src/main/java/org/neo4j/driver/internal/async/pool/ActiveChannelTracker.java

@@ -20,12 +20,12 @@
 
 import io.netty.channel.Channel;
 import io.netty.channel.pool.ChannelPoolHandler;
+import io.netty.util.internal.ConcurrentSet;
 
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 
 import org.neo4j.driver.internal.net.BoltServerAddress;
-import org.neo4j.driver.internal.util.ConcurrentSet;
 import org.neo4j.driver.v1.Logger;
 import org.neo4j.driver.v1.Logging;