Use interface 'AssertOpen' instead of Runnable to assert transaction …

…is open

This makes the 'assertOpen' more explicit by avoiding the indirection of a runnable.

community/kernel/src/main/java/org/neo4j/kernel/api/AssertOpen.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2002-2017 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.kernel.api;
+
+/**
+ * Used to verify that some source of operation is still open when operation is performed.
+ * E.g. verify that transaction is still open when lazily reading property values from store.
+ */
+public interface AssertOpen
+{
+    /**
+     * Assert that source tied to instance is open.
+     * Should throw exception with reason if source is not open.
+     */
+    void assertOpen();
+
+    AssertOpen ALWAYS_OPEN = AlwaysOpen.INSTANCE;
+
+    enum AlwaysOpen implements AssertOpen
+    {
+        INSTANCE
+        {
+            @Override
+            public void assertOpen()
+            {   // no-op
+            }
+        }
+    }
+}

community/kernel/src/main/java/org/neo4j/kernel/api/txstate/TransactionCountingStateVisitor.java

@@ -24,6 +24,7 @@
 import org.neo4j.collection.primitive.PrimitiveIntCollections;
 import org.neo4j.collection.primitive.PrimitiveIntIterator;
 import org.neo4j.cursor.Cursor;
+import org.neo4j.kernel.api.AssertOpen;
 import org.neo4j.kernel.api.exceptions.EntityNotFoundException;
 import org.neo4j.kernel.api.exceptions.schema.ConstraintValidationKernelException;
 import org.neo4j.kernel.impl.api.CountsRecordState;
@@ -68,7 +69,7 @@ public void visitCreatedNode( long id )
     public void visitDeletedNode( long id )
     {
         counts.incrementNodeCount( ANY_LABEL, -1 );
-        try ( Cursor<NodeItem> node = statement.acquireSingleNodeCursor( id, () -> {} ) )
+        try ( Cursor<NodeItem> node = statement.acquireSingleNodeCursor( id, AssertOpen.ALWAYS_OPEN ) )
         {
             if ( node.next() )
             {
@@ -141,7 +142,7 @@ public void visitNodeLabelChanges( long id, final Set<Integer> added, final Set<
             }
             // get the relationship counts from *before* this transaction,
             // the relationship changes will compensate for what happens during the transaction
-            try ( Cursor<NodeItem> node = statement.acquireSingleNodeCursor( id, () -> {} ) )
+            try ( Cursor<NodeItem> node = statement.acquireSingleNodeCursor( id, AssertOpen.ALWAYS_OPEN ) )
             {
                 if ( node.next() )
                 {
@@ -206,7 +207,7 @@ private PrimitiveIntIterator labelsOf( long nodeId )
 
     private Cursor<NodeItem> nodeCursor( StorageStatement statement, long nodeId )
     {
-        Cursor<NodeItem> cursor = statement.acquireSingleNodeCursor( nodeId, () -> {} );
+        Cursor<NodeItem> cursor = statement.acquireSingleNodeCursor( nodeId, AssertOpen.ALWAYS_OPEN );
         return txState.augmentSingleNodeCursor( cursor, nodeId );
     }
 }

community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelStatement.java

@@ -25,6 +25,7 @@
 import org.neo4j.graphdb.TransactionTerminatedException;
 import org.neo4j.kernel.api.DataWriteOperations;
 import org.neo4j.kernel.api.ExecutingQuery;
+import org.neo4j.kernel.api.AssertOpen;
 import org.neo4j.kernel.api.ProcedureCallOperations;
 import org.neo4j.kernel.api.QueryRegistryOperations;
 import org.neo4j.kernel.api.ReadOperations;
@@ -61,7 +62,7 @@
  * instance again, when it's initialized.</li>
  * </ol>
  */
-public class KernelStatement implements TxStateHolder, Statement
+public class KernelStatement implements TxStateHolder, Statement, AssertOpen
 {
     private final TxStateHolder txStateHolder;
     private final StorageStatement storeStatement;
@@ -164,7 +165,8 @@ public void close()
         }
     }
 
-    void assertOpen()
+    @Override
+    public void assertOpen()
     {
         if ( referenceCount == 0 )
         {

community/kernel/src/main/java/org/neo4j/kernel/impl/api/StateHandlingStatementOperations.java

@@ -147,7 +147,7 @@ public Cursor<NodeItem> nodeCursorById( KernelStatement statement, long nodeId )
     @Override
     public Cursor<NodeItem> nodeCursor( KernelStatement statement, long nodeId )
     {
-        Cursor<NodeItem> cursor = statement.getStoreStatement().acquireSingleNodeCursor( nodeId, statement::assertOpen );
+        Cursor<NodeItem> cursor = statement.getStoreStatement().acquireSingleNodeCursor( nodeId, statement );
         if ( statement.hasTxStateWithChanges() )
         {
             return statement.txState().augmentSingleNodeCursor( cursor, nodeId );
@@ -172,7 +172,7 @@ public Cursor<RelationshipItem> relationshipCursorById( KernelStatement statemen
     public Cursor<RelationshipItem> relationshipCursor( KernelStatement statement, long relationshipId )
     {
         Cursor<RelationshipItem> cursor = statement.getStoreStatement().acquireSingleRelationshipCursor(
-                relationshipId, statement::assertOpen );
+                relationshipId, statement );
         if ( statement.hasTxStateWithChanges() )
         {
             return statement.txState().augmentSingleRelationshipCursor( cursor, relationshipId );
@@ -183,7 +183,7 @@ public Cursor<RelationshipItem> relationshipCursor( KernelStatement statement, l
     @Override
     public Cursor<NodeItem> nodeCursorGetAll( KernelStatement statement )
     {
-        Cursor<NodeItem> cursor = statement.getStoreStatement().nodesGetAllCursor( statement::assertOpen );
+        Cursor<NodeItem> cursor = statement.getStoreStatement().nodesGetAllCursor( statement );
         if ( statement.hasTxStateWithChanges() )
         {
             return statement.txState().augmentNodesGetAllCursor( cursor );
@@ -195,7 +195,7 @@ public Cursor<NodeItem> nodeCursorGetAll( KernelStatement statement )
     public Cursor<RelationshipItem> relationshipCursorGetAll( KernelStatement statement )
     {
         Cursor<RelationshipItem> cursor =
-                statement.getStoreStatement().relationshipsGetAllCursor( statement::assertOpen );
+                statement.getStoreStatement().relationshipsGetAllCursor( statement );
         if ( statement.hasTxStateWithChanges() )
         {
             return statement.txState().augmentRelationshipsGetAllCursor( cursor );
@@ -209,7 +209,7 @@ public Cursor<NodeItem> nodeCursorGetForLabel( KernelStatement statement, int la
         // TODO Filter this properly
         StorageStatement storeStatement = statement.getStoreStatement();
         return storeStatement.acquireIteratorNodeCursor(
-                storeLayer.nodesGetForLabel( storeStatement, labelId ), statement::assertOpen );
+                storeLayer.nodesGetForLabel( storeStatement, labelId ), statement );
     }
 
     @Override
@@ -219,7 +219,7 @@ public Cursor<NodeItem> nodeCursorGetFromIndexSeek( KernelStatement statement, I
         // TODO Filter this properly
         StorageStatement storeStatement = statement.getStoreStatement();
         IndexReader reader = storeStatement.getIndexReader( index );
-        return storeStatement.acquireIteratorNodeCursor( reader.seek( value ), statement::assertOpen );
+        return storeStatement.acquireIteratorNodeCursor( reader.seek( value ), statement );
     }
 
     @Override
@@ -229,7 +229,7 @@ public Cursor<NodeItem> nodeCursorGetFromIndexScan( KernelStatement statement, I
         // TODO Filter this properly
         StorageStatement storeStatement = statement.getStoreStatement();
         IndexReader reader = storeStatement.getIndexReader( index );
-        return storeStatement.acquireIteratorNodeCursor( reader.scan(), statement::assertOpen );
+        return storeStatement.acquireIteratorNodeCursor( reader.scan(), statement );
     }
 
     @Override
@@ -240,7 +240,7 @@ public Cursor<NodeItem> nodeCursorGetFromIndexSeekByPrefix( KernelStatement stat
         // TODO Filter this properly
         StorageStatement storeStatement = statement.getStoreStatement();
         IndexReader reader = storeStatement.getIndexReader( index );
-        return storeStatement.acquireIteratorNodeCursor( reader.rangeSeekByPrefix( prefix ), statement::assertOpen );
+        return storeStatement.acquireIteratorNodeCursor( reader.rangeSeekByPrefix( prefix ), statement );
     }
 
     @Override
@@ -256,7 +256,7 @@ public Cursor<NodeItem> nodeCursorGetFromIndexRangeSeekByNumber( KernelStatement
         IndexReader reader = storeStatement.getIndexReader( index );
         return COMPARE_NUMBERS.isEmptyRange( lower, includeLower, upper, includeUpper ) ? Cursors.<NodeItem>empty() :
                storeStatement.acquireIteratorNodeCursor(
-                       reader.rangeSeekByNumberInclusive( lower, upper ), statement::assertOpen );
+                       reader.rangeSeekByNumberInclusive( lower, upper ), statement );
     }
 
     @Override
@@ -271,7 +271,7 @@ public Cursor<NodeItem> nodeCursorGetFromIndexRangeSeekByString( KernelStatement
         StorageStatement storeStatement = statement.getStoreStatement();
         IndexReader reader = storeStatement.getIndexReader( index );
         return storeStatement.acquireIteratorNodeCursor(
-                reader.rangeSeekByString( lower, includeLower, upper, includeUpper ), statement::assertOpen );
+                reader.rangeSeekByString( lower, includeLower, upper, includeUpper ), statement );
     }
 
     @Override
@@ -282,7 +282,7 @@ public Cursor<NodeItem> nodeCursorGetFromIndexRangeSeekByPrefix( KernelStatement
         // TODO Filter this properly
         StorageStatement storeStatement = statement.getStoreStatement();
         IndexReader reader = storeStatement.getIndexReader( index );
-        return storeStatement.acquireIteratorNodeCursor( reader.rangeSeekByPrefix( prefix ), statement::assertOpen );
+        return storeStatement.acquireIteratorNodeCursor( reader.rangeSeekByPrefix( prefix ), statement );
     }
 
     @Override
@@ -294,7 +294,7 @@ public Cursor<NodeItem> nodeCursorGetFromUniqueIndexSeek( KernelStatement statem
         StorageStatement storeStatement = statement.getStoreStatement();
         IndexReader reader = storeStatement.getFreshIndexReader( index );
         PrimitiveLongIterator seekResult = PrimitiveLongCollections.resourceIterator( reader.seek( value ), reader );
-        return storeStatement.acquireIteratorNodeCursor( seekResult, statement::assertOpen );
+        return storeStatement.acquireIteratorNodeCursor( seekResult, statement );
     }
 
     // </Cursors>

community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreAbstractNodeCursor.java

@@ -27,6 +27,7 @@
 import org.neo4j.collection.primitive.PrimitiveIntSet;
 import org.neo4j.cursor.Cursor;
 import org.neo4j.cursor.IntValue;
+import org.neo4j.kernel.api.AssertOpen;
 import org.neo4j.kernel.api.cursor.NodeItemHelper;
 import org.neo4j.kernel.impl.locking.Lock;
 import org.neo4j.kernel.impl.locking.LockService;
@@ -71,7 +72,7 @@ public abstract class StoreAbstractNodeCursor extends NodeItemHelper implements
     private final InstanceCache<StoreSinglePropertyCursor> singlePropertyCursor;
     private final InstanceCache<StorePropertyCursor> allPropertyCursor;
     protected final RecordCursors cursors;
-    private Runnable assertOnPropertyValueFetch;
+    private AssertOpen assertOpen;
 
     public StoreAbstractNodeCursor( NodeRecord nodeRecord,
             final NeoStores neoStores,
@@ -130,9 +131,9 @@ protected StorePropertyCursor create()
         };
     }
 
-    protected void initialize( Runnable assertOnPropertyValueFetch )
+    protected void initialize( AssertOpen assertOpen )
     {
-        this.assertOnPropertyValueFetch = assertOnPropertyValueFetch;
+        this.assertOpen = assertOpen;
     }
 
     @Override
@@ -193,29 +194,28 @@ private Lock shortLivedReadLock()
     @Override
     public Cursor<PropertyItem> properties()
     {
-        return allPropertyCursor.get().init( nodeRecord.getNextProp(), shortLivedReadLock(),
-                assertOnPropertyValueFetch );
+        return allPropertyCursor.get().init( nodeRecord.getNextProp(), shortLivedReadLock(), assertOpen );
     }
 
     @Override
     public Cursor<PropertyItem> property( int propertyKeyId )
     {
         return singlePropertyCursor.get().init( nodeRecord.getNextProp(), propertyKeyId, shortLivedReadLock(),
-                assertOnPropertyValueFetch );
+                assertOpen );
     }
 
     @Override
     public Cursor<RelationshipItem> relationships( Direction direction )
     {
         return nodeRelationshipCursor.get().init( nodeRecord.isDense(), nodeRecord.getNextRel(), nodeRecord.getId(),
-                direction, assertOnPropertyValueFetch );
+                direction, assertOpen );
     }
 
     @Override
     public Cursor<RelationshipItem> relationships( Direction direction, int... relTypes )
     {
         return nodeRelationshipCursor.get().init( nodeRecord.isDense(), nodeRecord.getNextRel(), nodeRecord.getId(),
-                direction, assertOnPropertyValueFetch, relTypes );
+                direction, assertOpen, relTypes );
     }
 
     @Override

community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreAbstractRelationshipCursor.java

@@ -20,6 +20,7 @@
 package org.neo4j.kernel.impl.api.store;
 
 import org.neo4j.cursor.Cursor;
+import org.neo4j.kernel.api.AssertOpen;
 import org.neo4j.kernel.api.cursor.EntityItemHelper;
 import org.neo4j.kernel.impl.locking.Lock;
 import org.neo4j.kernel.impl.locking.LockService;
@@ -46,7 +47,7 @@ public abstract class StoreAbstractRelationshipCursor extends EntityItemHelper
 
     private final InstanceCache<StoreSinglePropertyCursor> singlePropertyCursor;
     private final InstanceCache<StorePropertyCursor> allPropertyCursor;
-    private Runnable assertOnPropertyValueFetch;
+    private AssertOpen assertOpen;
 
     public StoreAbstractRelationshipCursor( RelationshipRecord relationshipRecord, RecordCursors cursors,
             LockService lockService )
@@ -73,9 +74,9 @@ protected StorePropertyCursor create()
         };
     }
 
-    protected void initialize( Runnable assertOnPropertyValueFetch )
+    protected void initialize( AssertOpen assertOpen )
     {
-        this.assertOnPropertyValueFetch = assertOnPropertyValueFetch;
+        this.assertOpen = assertOpen;
     }
 
     @Override
@@ -150,14 +151,13 @@ private Lock shortLivedReadLock()
     public Cursor<PropertyItem> properties()
     {
         return allPropertyCursor.get()
-                .init( relationshipRecord.getNextProp(), shortLivedReadLock(), assertOnPropertyValueFetch );
+                .init( relationshipRecord.getNextProp(), shortLivedReadLock(), assertOpen );
     }
 
     @Override
     public Cursor<PropertyItem> property( int propertyKeyId )
     {
         return singlePropertyCursor.get()
-                .init( relationshipRecord.getNextProp(), propertyKeyId, shortLivedReadLock(),
-                        assertOnPropertyValueFetch );
+                .init( relationshipRecord.getNextProp(), propertyKeyId, shortLivedReadLock(), assertOpen );
     }
 }

community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreIteratorNodeCursor.java

@@ -23,6 +23,7 @@
 
 import org.neo4j.collection.primitive.PrimitiveLongIterator;
 import org.neo4j.graphdb.Resource;
+import org.neo4j.kernel.api.AssertOpen;
 import org.neo4j.kernel.impl.locking.LockService;
 import org.neo4j.kernel.impl.store.NeoStores;
 import org.neo4j.kernel.impl.store.RecordCursors;
@@ -50,9 +51,9 @@ public StoreIteratorNodeCursor( NodeRecord nodeRecord,
         this.instanceCache = instanceCache;
     }
 
-    public StoreIteratorNodeCursor init( PrimitiveLongIterator iterator, Runnable assertOnPropertyValueFetch )
+    public StoreIteratorNodeCursor init( PrimitiveLongIterator iterator, AssertOpen assertOpen )
     {
-        initialize( assertOnPropertyValueFetch );
+        initialize( assertOpen );
         this.iterator = iterator;
         return this;
     }

community/kernel/src/main/java/org/neo4j/kernel/impl/api/store/StoreIteratorRelationshipCursor.java

@@ -21,6 +21,7 @@
 
 import org.neo4j.collection.primitive.PrimitiveLongIterator;
 import org.neo4j.graphdb.Resource;
+import org.neo4j.kernel.api.AssertOpen;
 import org.neo4j.kernel.impl.locking.LockService;
 import org.neo4j.kernel.impl.store.RecordCursors;
 import org.neo4j.kernel.impl.store.record.RelationshipRecord;
@@ -45,9 +46,9 @@ public StoreIteratorRelationshipCursor( RelationshipRecord relationshipRecord,
         this.instanceCache = instanceCache;
     }
 
-    public StoreIteratorRelationshipCursor init( PrimitiveLongIterator iterator, Runnable assertOnPropertyValueFetch )
+    public StoreIteratorRelationshipCursor init( PrimitiveLongIterator iterator, AssertOpen assertOpen )
     {
-        initialize( assertOnPropertyValueFetch );
+        initialize( assertOpen );
         this.iterator = iterator;
         return this;
     }