Remove timeout execution guard

Remove timeout execution guard and guarding statement operations.
Now transaction timeout will be checked only by KernelTransactionTimeoutMonitor.
which will update termination status that will be checked by assertOpen in
OperationsFacade only.
Now KernelTransactionTimeoutMonitor will by default each 2 seconds.
Keep Guard implementations to have an ability to properly check transaction
status in any additional places.

community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/spi/v3_3/TransactionBoundQueryContextTest.scala

@@ -65,8 +65,9 @@ class TransactionBoundQueryContextTest extends CypherFunSuite {
     when(kernelTransaction.securityContext()).thenReturn(AUTH_DISABLED)
     val storeStatement = mock[StorageStatement]
     val operations = mock[StatementOperationParts](RETURNS_DEEP_STUBS)
-    statement = new KernelStatement(kernelTransaction, null, storeStatement, new Procedures(), new CanWrite(), LockTracer.NONE)
-    statement.initialize(null, operations, PageCursorTracerSupplier.NULL.get())
+    statement = new KernelStatement(kernelTransaction, null, storeStatement, new Procedures(), new CanWrite(),
+      LockTracer.NONE, operations)
+    statement.initialize(null, PageCursorTracerSupplier.NULL.get())
     statement.acquire()
   }
 

community/kernel/src/main/java/org/neo4j/graphdb/factory/GraphDatabaseSettings.java

@@ -273,7 +273,7 @@ public class GraphDatabaseSettings implements LoadableConfig
     @Description( "Configures the time interval between transaction monitor checks. Determines how often " +
             "monitor thread will check transaction for timeout." )
     public static final Setting<Duration> transaction_monitor_check_interval =
-            setting( "dbms.transaction.monitor.check.interval", DURATION, "5s" );
+            setting( "dbms.transaction.monitor.check.interval", DURATION, "2s" );
 
     @Description( "The maximum amount of time to wait for running transactions to complete before allowing "
                   + "initiated database shutdown to continue" )

community/kernel/src/main/java/org/neo4j/kernel/NeoStoreDataSource.java

@@ -51,7 +51,6 @@
 import org.neo4j.kernel.impl.api.ConstraintEnforcingEntityOperations;
 import org.neo4j.kernel.impl.api.DataIntegrityValidatingStatementOperations;
 import org.neo4j.kernel.impl.api.DatabaseSchemaState;
-import org.neo4j.kernel.impl.api.GuardingStatementOperations;
 import org.neo4j.kernel.impl.api.Kernel;
 import org.neo4j.kernel.impl.api.KernelTransactionMonitorScheduler;
 import org.neo4j.kernel.impl.api.KernelTransactionTimeoutMonitor;
@@ -64,7 +63,6 @@
 import org.neo4j.kernel.impl.api.SchemaWriteGuard;
 import org.neo4j.kernel.impl.api.StackingQueryRegistrationOperations;
 import org.neo4j.kernel.impl.api.StateHandlingStatementOperations;
-import org.neo4j.kernel.impl.api.StatementOperationContainer;
 import org.neo4j.kernel.impl.api.StatementOperationParts;
 import org.neo4j.kernel.impl.api.TransactionCommitProcess;
 import org.neo4j.kernel.impl.api.TransactionHooks;
@@ -736,13 +734,13 @@ private NeoStoreKernelModule buildKernel( TransactionAppender appender,
         LegacyIndexStore legacyIndexStore = new LegacyIndexStore( config,
                 indexConfigStore, kernelProvider, legacyIndexProviderLookup );
 
-        StatementOperationContainer statementOperationContainer = dependencies.satisfyDependency(
+        StatementOperationParts statementOperationParts = dependencies.satisfyDependency(
                 buildStatementOperations( storeLayer, autoIndexing,
                         constraintIndexCreator, databaseSchemaState, guard, legacyIndexStore ) );
 
         TransactionHooks hooks = new TransactionHooks();
         KernelTransactions kernelTransactions = life.add( new KernelTransactions( statementLocksFactory,
-                constraintIndexCreator, statementOperationContainer, schemaWriteGuard, transactionHeaderInformationFactory,
+                constraintIndexCreator, statementOperationParts, schemaWriteGuard, transactionHeaderInformationFactory,
                 transactionCommitProcess, indexConfigStore, legacyIndexProviderLookup, hooks, transactionMonitor,
                 availabilityGuard, tracers, storageEngine, procedures, transactionIdStore, clock, accessCapability ) );
 
@@ -763,6 +761,7 @@ private void buildTransactionMonitor( KernelTransactions kernelTransactions, Clo
     {
         KernelTransactionTimeoutMonitor kernelTransactionTimeoutMonitor =
                 new KernelTransactionTimeoutMonitor( kernelTransactions, clock, logService );
+        dependencies.satisfyDependency( kernelTransactionTimeoutMonitor );
         KernelTransactionMonitorScheduler transactionMonitorScheduler =
                 new KernelTransactionMonitorScheduler( kernelTransactionTimeoutMonitor, scheduler,
                         config.get( GraphDatabaseSettings.transaction_monitor_check_interval ).toMillis() );
@@ -863,7 +862,7 @@ public DependencyResolver getDependencyResolver()
         return dependencies;
     }
 
-    private StatementOperationContainer buildStatementOperations(
+    private StatementOperationParts buildStatementOperations(
             StoreReadLayer storeReadLayer, AutoIndexing autoIndexing,
             ConstraintIndexCreator constraintIndexCreator, DatabaseSchemaState databaseSchemaState,
             Guard guard, LegacyIndexStore legacyIndexStore )
@@ -908,14 +907,8 @@ private StatementOperationContainer buildStatementOperations(
                 parts.schemaStateOperations() );
         parts = parts.override( null, null, null, lockingContext, lockingContext, lockingContext, lockingContext,
                 lockingContext, null, null, null, null );
-        // + Guard
-        GuardingStatementOperations guardingOperations = new GuardingStatementOperations(
-                parts.entityWriteOperations(), parts.entityReadOperations(), guard );
-        StatementOperationParts guardedParts = parts.override( null, null, guardingOperations,
-                guardingOperations, null, null, null, null,
-                null, null, null, null );
-
-        return new StatementOperationContainer( guardedParts, parts );
+
+        return parts;
     }
 
     @Override

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

@@ -153,6 +153,11 @@ default void close() throws TransactionFailureException
      */
     Optional<Status> getReasonIfTerminated();
 
+    /**
+     * @return true if transaction was terminated, otherwise false
+     */
+    boolean isTerminated();
+
     /**
      * Marks this transaction for termination, such that it cannot commit successfully and will try to be
      * terminated by having other methods throw a specific termination exception, as to sooner reach the assumed

community/kernel/src/main/java/org/neo4j/kernel/guard/Guard.java

@@ -19,15 +19,16 @@
  */
 package org.neo4j.kernel.guard;
 
+import org.neo4j.graphdb.TransactionTerminatedException;
+import org.neo4j.kernel.api.KernelTransaction;
 import org.neo4j.kernel.impl.api.KernelStatement;
-import org.neo4j.kernel.impl.api.KernelTransactionImplementation;
 
 /**
  * Guard that check entities for compatibility with some kind of guard criteria.
- * As soon as entity do not satisfy that criteria {@link GuardException } will be thrown.
+ * As soon as entity do not satisfy that criteria {@link TransactionTerminatedException } will be thrown.
  */
 public interface Guard
 {
-    void check( KernelTransactionImplementation transaction );
+    void check( KernelTransaction transaction );
     void check( KernelStatement statement );
 }

community/kernel/src/main/java/org/neo4j/kernel/guard/GuardTimeoutException.java → community/kernel/src/main/java/org/neo4j/kernel/guard/TerminationGuard.java

@@ -19,26 +19,29 @@
  */
 package org.neo4j.kernel.guard;
 
-import org.neo4j.kernel.api.exceptions.Status;
+import org.neo4j.graphdb.TransactionTerminatedException;
+import org.neo4j.kernel.api.KernelTransaction;
+import org.neo4j.kernel.impl.api.KernelStatement;
 
-public class GuardTimeoutException extends GuardException
+/**
+ * Guard that checks kernel transaction for termination.
+ * As soon as transaction timeout time reached {@link TransactionTerminatedException } will be thrown.
+ */
+public class TerminationGuard implements Guard
 {
-    private final long overtime;
 
-    public GuardTimeoutException( String message, final long overtime )
-    {
-        super( message );
-        this.overtime = overtime;
-    }
-
-    public long getOvertime()
+    @Override
+    public void check( KernelStatement statement )
     {
-        return overtime;
+        statement.assertOpen();
     }
 
     @Override
-    public Status status()
+    public void check( KernelTransaction transaction )
     {
-        return Status.Transaction.TransactionTimedOut;
+        if ( transaction.isTerminated() )
+        {
+            throw new TransactionTerminatedException( transaction.getReasonIfTerminated().get() );
+        }
     }
 }