More friendly error when user tries to WRITE in a READ session.

Common error codes returned by the server indicate that the user
attempted (and failed) to write. If the user was using a READ
session we can give tell them directly that the problem is their fault.

Author: apcj

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

@@ -286,7 +286,7 @@ public Session session()
     @Override
     public Session session( final AccessMode mode )
     {
-        return new ClusteredNetworkSession( acquireConnection( mode ),
+        return new ClusteredNetworkSession( mode, acquireConnection( mode ),
                 new ClusteredErrorHandler()
                 {
                     @Override
@@ -357,4 +357,4 @@ ConnectionPool connectionPool()
         return connections;
     }
 
-}
+}

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

@@ -21,21 +21,27 @@
 
 import org.neo4j.driver.internal.net.BoltServerAddress;
 import org.neo4j.driver.internal.spi.Connection;
+import org.neo4j.driver.v1.AccessMode;
 import org.neo4j.driver.v1.Logger;
 import org.neo4j.driver.v1.Statement;
 import org.neo4j.driver.v1.StatementResult;
 import org.neo4j.driver.v1.exceptions.ClientException;
 import org.neo4j.driver.v1.exceptions.ConnectionFailureException;
+import org.neo4j.driver.v1.exceptions.Neo4jException;
 import org.neo4j.driver.v1.exceptions.SessionExpiredException;
 
+import static java.lang.String.format;
+
 public class ClusteredNetworkSession extends NetworkSession
 {
+    private final AccessMode mode;
     private final ClusteredErrorHandler onError;
 
-    ClusteredNetworkSession( Connection connection,
+    ClusteredNetworkSession( AccessMode mode, Connection connection,
             ClusteredErrorHandler onError, Logger logger )
     {
         super( connection, logger );
+        this.mode = mode;
         this.onError = onError;
     }
 
@@ -44,25 +50,15 @@ public StatementResult run( Statement statement )
     {
         try
         {
-            return new ClusteredStatementResult( super.run( statement ), connection.address(), onError );
+            return new ClusteredStatementResult( super.run( statement ), mode, connection.address(), onError );
         }
         catch ( ConnectionFailureException e )
         {
-            onError.onConnectionFailure( connection.address() );
-            throw new SessionExpiredException( "Failed to perform write load to server", e );
+            throw sessionExpired( e, onError, connection.address() );
         }
         catch ( ClientException e )
         {
-            if ( e.code().equals( "Neo.ClientError.Cluster.NotALeader" ) )
-            {
-                onError.onWriteFailure( connection.address() );
-                throw new SessionExpiredException(
-                        String.format( "Server at %s no longer accepts writes", connection.address().toString() ) );
-            }
-            else
-            {
-                throw e;
-            }
+            throw filterFailureToWrite( e, mode, onError, connection.address() );
         }
     }
 
@@ -75,10 +71,44 @@ public void close()
         }
         catch ( ConnectionFailureException e )
         {
-            BoltServerAddress address = connection.address();
-            onError.onConnectionFailure( address );
-            throw new SessionExpiredException(
-                    String.format( "Server at %s is no longer available", address.toString() ), e );
+            throw sessionExpired(e, onError, connection.address());
+        }
+    }
+
+    static Neo4jException filterFailureToWrite( ClientException e, AccessMode mode, ClusteredErrorHandler onError,
+            BoltServerAddress address )
+    {
+        if ( isFailedToWrite( e ) )
+        {
+            // The server is unaware of the session mode, so we have to implement this logic in the driver.
+            // In the future, we might be able to move this logic to the server.
+            switch ( mode )
+            {
+                case READ:
+                    return new ClientException( "Write queries cannot be performed in READ access mode." );
+                case WRITE:
+                    onError.onWriteFailure( address );
+                    return new SessionExpiredException( format( "Server at %s no longer accepts writes", address ) );
+                default:
+                    throw new IllegalArgumentException( mode + " not supported." );
+            }
         }
+        else
+        {
+            return e;
+        }
+    }
+
+    static SessionExpiredException sessionExpired( ConnectionFailureException e, ClusteredErrorHandler onError,
+                                                   BoltServerAddress address )
+    {
+        onError.onConnectionFailure( address );
+        return new SessionExpiredException( format( "Server at %s is no longer available", address.toString() ), e );
+    }
+
+    private static boolean isFailedToWrite( ClientException e )
+    {
+        return e.code().equals( "Neo.ClientError.Cluster.NotALeader" ) ||
+                e.code().equals( "Neo.ClientError.General.ForbiddenOnReadOnlyDatabase" );
     }
 }

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

@@ -21,24 +21,32 @@
 import java.util.List;
 
 import org.neo4j.driver.internal.net.BoltServerAddress;
+import org.neo4j.driver.v1.AccessMode;
 import org.neo4j.driver.v1.Record;
 import org.neo4j.driver.v1.StatementResult;
 import org.neo4j.driver.v1.exceptions.ClientException;
 import org.neo4j.driver.v1.exceptions.ConnectionFailureException;
 import org.neo4j.driver.v1.exceptions.NoSuchRecordException;
-import org.neo4j.driver.v1.exceptions.SessionExpiredException;
 import org.neo4j.driver.v1.summary.ResultSummary;
 import org.neo4j.driver.v1.util.Function;
 
+import static java.lang.String.format;
+
+import static org.neo4j.driver.internal.ClusteredNetworkSession.filterFailureToWrite;
+import static org.neo4j.driver.internal.ClusteredNetworkSession.sessionExpired;
+
 public class ClusteredStatementResult implements StatementResult
 {
     private final StatementResult delegate;
+    private final AccessMode mode;
     private final BoltServerAddress address;
     private final ClusteredErrorHandler onError;
 
-    ClusteredStatementResult( StatementResult delegate, BoltServerAddress address, ClusteredErrorHandler onError )
+    ClusteredStatementResult( StatementResult delegate, AccessMode mode, BoltServerAddress address,
+            ClusteredErrorHandler onError )
     {
         this.delegate = delegate;
+        this.mode = mode;
         this.address = address;
         this.onError = onError;
     }
@@ -52,18 +60,11 @@ public List<String> keys()
         }
         catch ( ConnectionFailureException e )
         {
-            throw sessionExpired( e );
+            throw sessionExpired( e, onError, address );
         }
         catch ( ClientException e )
         {
-            if ( isFailedToWrite( e ) )
-            {
-                throw failedWrite();
-            }
-            else
-            {
-                throw e;
-            }
+            throw filterFailureToWrite( e, mode, onError, address );
         }
     }
 
@@ -76,18 +77,11 @@ public boolean hasNext()
         }
         catch ( ConnectionFailureException e )
         {
-            throw sessionExpired( e );
+            throw sessionExpired( e, onError, address );
         }
         catch ( ClientException e )
         {
-            if ( isFailedToWrite( e ) )
-            {
-                throw failedWrite();
-            }
-            else
-            {
-                throw e;
-            }
+            throw filterFailureToWrite( e, mode, onError, address );
         }
     }
 
@@ -100,18 +94,11 @@ public Record next()
         }
         catch ( ConnectionFailureException e )
         {
-            throw sessionExpired( e );
+            throw sessionExpired( e, onError, address );
         }
         catch ( ClientException e )
         {
-            if ( isFailedToWrite( e ) )
-            {
-                throw failedWrite();
-            }
-            else
-            {
-                throw e;
-            }
+            throw filterFailureToWrite( e, mode, onError, address );
         }
     }
 
@@ -125,18 +112,11 @@ public Record single() throws NoSuchRecordException
         }
         catch ( ConnectionFailureException e )
         {
-            throw sessionExpired( e );
+            throw sessionExpired( e, onError, address );
         }
         catch ( ClientException e )
         {
-            if ( isFailedToWrite( e ) )
-            {
-               throw failedWrite();
-            }
-            else
-            {
-                throw e;
-            }
+            throw filterFailureToWrite( e, mode, onError, address );
         }
     }
 
@@ -149,18 +129,11 @@ public Record peek()
         }
         catch ( ConnectionFailureException e )
         {
-            throw sessionExpired( e );
+            throw sessionExpired( e, onError, address );
         }
         catch ( ClientException e )
         {
-            if ( isFailedToWrite( e ) )
-            {
-                throw failedWrite();
-            }
-            else
-            {
-                throw e;
-            }
+            throw filterFailureToWrite( e, mode, onError, address );
         }
     }
 
@@ -173,42 +146,28 @@ public List<Record> list()
         }
         catch ( ConnectionFailureException e )
         {
-            throw sessionExpired( e );
+            throw sessionExpired( e, onError, address );
         }
         catch ( ClientException e )
         {
-            if ( isFailedToWrite( e ) )
-            {
-                throw failedWrite();
-            }
-            else
-            {
-                throw e;
-            }
+            throw filterFailureToWrite( e, mode, onError, address );
         }
     }
 
     @Override
-    public <T> List<T> list( Function<Record,T> mapFunction )
+    public <T> List<T> list( Function<Record, T> mapFunction )
     {
         try
         {
-            return delegate.list(mapFunction);
+            return delegate.list( mapFunction );
         }
         catch ( ConnectionFailureException e )
         {
-            throw sessionExpired( e );
+            throw sessionExpired( e, onError, address );
         }
         catch ( ClientException e )
         {
-            if ( isFailedToWrite( e ) )
-            {
-                throw failedWrite();
-            }
-            else
-            {
-                throw e;
-            }
+            throw filterFailureToWrite( e, mode, onError, address );
         }
     }
 
@@ -227,35 +186,12 @@ public ResultSummary consume()
         }
         catch ( ConnectionFailureException e )
         {
-            throw sessionExpired( e );
+            throw sessionExpired( e, onError, address );
         }
         catch ( ClientException e )
         {
-            if ( isFailedToWrite( e ) )
-            {
-                throw failedWrite();
-            }
-            else
-            {
-                throw e;
-            }
+            throw filterFailureToWrite( e, mode, onError, address );
         }
     }
 
-    private SessionExpiredException sessionExpired( ConnectionFailureException e )
-    {
-        onError.onConnectionFailure( address );
-        return new SessionExpiredException( String.format( "Server at %s is no longer available", address.toString()), e);
-    }
-
-    private SessionExpiredException failedWrite()
-    {
-        onError.onWriteFailure( address );
-        return new SessionExpiredException( String.format( "Server at %s no longer accepts writes", address.toString()));
-    }
-
-    private boolean isFailedToWrite( ClientException e )
-    {
-        return e.code().equals( "Neo.ClientError.Cluster.NotALeader" );
-    }
 }