Add config to enable/disable deferred locks

Also simplified StatementLocks creation in KTI - now it only requires
StatementLocksFactory and does not require Locks.

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

@@ -99,7 +99,6 @@
 import org.neo4j.kernel.impl.index.IndexConfigStore;
 import org.neo4j.kernel.impl.index.LegacyIndexStore;
 import org.neo4j.kernel.impl.locking.LockService;
-import org.neo4j.kernel.impl.locking.Locks;
 import org.neo4j.kernel.impl.locking.ReentrantLockService;
 import org.neo4j.kernel.impl.locking.StatementLocksFactory;
 import org.neo4j.kernel.impl.store.MetaDataStore;
@@ -359,7 +358,6 @@ boolean applicable( DiagnosticsPhase phase )
     private final PropertyKeyTokenHolder propertyKeyTokenHolder;
     private final LabelTokenHolder labelTokens;
     private final RelationshipTypeTokenHolder relationshipTypeTokens;
-    private final Locks locks;
     private final StatementLocksFactory statementLocksFactory;
     private final SchemaWriteGuard schemaWriteGuard;
     private final TransactionEventHandlers transactionEventHandlers;
@@ -425,7 +423,7 @@ public NeoStoreDataSource( File storeDir, Config config, StoreFactory sf, LogPro
             JobScheduler scheduler, TokenNameLookup tokenNameLookup, DependencyResolver dependencyResolver,
             PropertyKeyTokenHolder propertyKeyTokens, LabelTokenHolder labelTokens,
             RelationshipTypeTokenHolder relationshipTypeTokens,
-            Locks locks, StatementLocksFactory statementLocksFactory,
+            StatementLocksFactory statementLocksFactory,
             SchemaWriteGuard schemaWriteGuard, TransactionEventHandlers transactionEventHandlers,
             IndexingService.Monitor indexingServiceMonitor, FileSystemAbstraction fs,
             StoreUpgrader storeMigrationProcess, TransactionMonitor transactionMonitor,
@@ -451,7 +449,6 @@ public NeoStoreDataSource( File storeDir, Config config, StoreFactory sf, LogPro
         this.propertyKeyTokenHolder = propertyKeyTokens;
         this.labelTokens = labelTokens;
         this.relationshipTypeTokens = relationshipTypeTokens;
-        this.locks = locks;
         this.statementLocksFactory = statementLocksFactory;
         this.schemaWriteGuard = schemaWriteGuard;
         this.transactionEventHandlers = transactionEventHandlers;
@@ -1101,7 +1098,7 @@ public KernelAPI get()
         final TransactionHooks hooks = new TransactionHooks();
         final KernelTransactions kernelTransactions =
                 life.add( new KernelTransactions( neoStoreTxContextFactory,
-                        neoStores, locks, statementLocksFactory, integrityValidator, constraintIndexCreator,
+                        neoStores, statementLocksFactory, integrityValidator, constraintIndexCreator,
                         indexingService, labelScanStore, statementOperations, updateableSchemaState,
                         schemaWriteGuard, schemaIndexProviderMap, transactionHeaderInformationFactory, storeLayer,
                         transactionCommitProcess, indexConfigStore, legacyIndexProviderLookup, hooks,

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

@@ -70,7 +70,6 @@
 import org.neo4j.kernel.impl.constraints.ConstraintSemantics;
 import org.neo4j.kernel.impl.index.IndexEntityType;
 import org.neo4j.kernel.impl.locking.LockGroup;
-import org.neo4j.kernel.impl.locking.Locks;
 import org.neo4j.kernel.impl.locking.StatementLocks;
 import org.neo4j.kernel.impl.locking.StatementLocksFactory;
 import org.neo4j.kernel.impl.store.NeoStores;
@@ -160,7 +159,6 @@ TransactionType upgradeToSchemaTransaction() throws InvalidTransactionTypeKernel
     private final TransactionMonitor transactionMonitor;
     private final StoreReadLayer storeLayer;
     private final ProcedureCache procedureCache;
-    private final Locks locks;
     private final StatementLocksFactory statementLocksFactory;
     private final Clock clock;
     private final TransactionToRecordStateVisitor txStateToRecordStateVisitor = new TransactionToRecordStateVisitor();
@@ -221,7 +219,6 @@ public KernelTransactionImplementation( StatementOperationParts operations,
                                             Clock clock,
                                             TransactionTracer tracer,
                                             ProcedureCache procedureCache,
-                                            Locks locks,
                                             StatementLocksFactory statementLocksFactory,
                                             NeoStoreTransactionContext context,
                                             boolean txTerminationAwareLocks )
@@ -241,7 +238,6 @@ public KernelTransactionImplementation( StatementOperationParts operations,
         this.transactionMonitor = transactionMonitor;
         this.storeLayer = storeLayer;
         this.procedureCache = procedureCache;
-        this.locks = locks;
         this.statementLocksFactory = statementLocksFactory;
         this.context = context;
         this.legacyIndexTransactionState = new CachingLegacyIndexTransactionState( legacyIndexTransactionState );
@@ -257,7 +253,7 @@ public KernelTransactionImplementation( StatementOperationParts operations,
      */
     public KernelTransactionImplementation initialize( long lastCommittedTx, long lastTimeStamp )
     {
-        this.statementLocks = statementLocksFactory.newInstance( locks.newClient() );
+        this.statementLocks = statementLocksFactory.newInstance();
         this.terminationReason = null;
         this.closing = closed = failure = success = false;
         this.transactionType = TransactionType.ANY;

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

@@ -46,7 +46,6 @@
 import org.neo4j.kernel.impl.api.store.StoreReadLayer;
 import org.neo4j.kernel.impl.constraints.ConstraintSemantics;
 import org.neo4j.kernel.impl.index.IndexConfigStore;
-import org.neo4j.kernel.impl.locking.Locks;
 import org.neo4j.kernel.impl.locking.StatementLocksFactory;
 import org.neo4j.kernel.impl.store.NeoStores;
 import org.neo4j.kernel.impl.store.TransactionId;
@@ -83,7 +82,6 @@ public class KernelTransactions extends LifecycleAdapter
     private final NeoStoreTransactionContextFactory neoStoreTransactionContextFactory;
     private final NeoStores neoStores;
     private final StatementLocksFactory statementLocksFactory;
-    private final Locks locks;
     private final boolean txTerminationAwareLocks;
     private final IntegrityValidator integrityValidator;
     private final ConstraintIndexCreator constraintIndexCreator;
@@ -125,7 +123,7 @@ public class KernelTransactions extends LifecycleAdapter
 
     public KernelTransactions( NeoStoreTransactionContextFactory neoStoreTransactionContextFactory,
                                NeoStores neoStores,
-                               Locks locks, StatementLocksFactory statementLocksFactory,
+                               StatementLocksFactory statementLocksFactory,
                                IntegrityValidator integrityValidator,
                                ConstraintIndexCreator constraintIndexCreator,
                                IndexingService indexingService, LabelScanStore labelScanStore,
@@ -146,7 +144,6 @@ public KernelTransactions( NeoStoreTransactionContextFactory neoStoreTransaction
     {
         this.neoStoreTransactionContextFactory = neoStoreTransactionContextFactory;
         this.neoStores = neoStores;
-        this.locks = locks;
         this.statementLocksFactory = statementLocksFactory;
         this.txTerminationAwareLocks = config.get( tx_termination_aware_locks );
         this.integrityValidator = integrityValidator;
@@ -189,7 +186,7 @@ public KernelTransactionImplementation newInstance()
                     labelScanStore, indexingService, updateableSchemaState, recordState, providerMap,
                     neoStores, hooks, constraintIndexCreator, transactionHeaderInformationFactory,
                     transactionCommitProcess, transactionMonitor, storeLayer, legacyIndexTransactionState,
-                    localTxPool, constraintSemantics, clock, tracers.transactionTracer, procedureCache, locks,
+                    localTxPool, constraintSemantics, clock, tracers.transactionTracer, procedureCache,
                     statementLocksFactory, context, txTerminationAwareLocks );
 
             allTransactions.add( tx );

community/kernel/src/main/java/org/neo4j/kernel/impl/factory/DataSourceModule.java

@@ -66,6 +66,7 @@
 import org.neo4j.kernel.impl.coreapi.RelationshipAutoIndexerImpl;
 import org.neo4j.kernel.impl.coreapi.schema.SchemaImpl;
 import org.neo4j.kernel.impl.index.IndexConfigStore;
+import org.neo4j.kernel.impl.locking.Locks;
 import org.neo4j.kernel.impl.locking.SimpleStatementLocksFactory;
 import org.neo4j.kernel.impl.locking.StatementLocksFactory;
 import org.neo4j.kernel.impl.logging.LogService;
@@ -81,6 +82,7 @@
 import org.neo4j.kernel.info.DiagnosticsManager;
 import org.neo4j.kernel.lifecycle.LifeSupport;
 import org.neo4j.kernel.lifecycle.LifecycleAdapter;
+import org.neo4j.logging.Log;
 
 import static org.neo4j.kernel.impl.factory.GraphDatabaseFacadeFactory.Configuration.execution_guard_enabled;
 
@@ -113,12 +115,15 @@ public class DataSourceModule
 
     public final Supplier<StoreId> storeId;
 
+    private final Log log;
+
     public DataSourceModule( final GraphDatabaseFacadeFactory.Dependencies dependencies,
             final PlatformModule platformModule, EditionModule editionModule )
     {
         final org.neo4j.kernel.impl.util.Dependencies deps = platformModule.dependencies;
         Config config = platformModule.config;
         LogService logging = platformModule.logging;
+        this.log = logging.getInternalLog( DataSourceModule.class );
         FileSystemAbstraction fileSystem = platformModule.fileSystem;
         DataSourceManager dataSourceManager = platformModule.dataSourceManager;
         LifeSupport life = platformModule.life;
@@ -195,14 +200,14 @@ public GraphDatabaseService getGraphDatabaseService()
         KernelHealth kernelHealth = deps.satisfyDependency( new KernelHealth( kernelPanicEventGenerator,
                 logging.getInternalLog( KernelHealth.class ) ) );
 
-        StatementLocksFactory statementLocksFactory = createStatementLocksFactory();
+        StatementLocksFactory locksFactory = createStatementLocksFactory( editionModule.lockManager, config, log );
 
         neoStoreDataSource = deps.satisfyDependency( new NeoStoreDataSource( storeDir, config,
                 storeFactory, logging.getInternalLogProvider(), platformModule.jobScheduler,
                 new NonTransactionalTokenNameLookup( editionModule.labelTokenHolder,
                         editionModule.relationshipTypeTokenHolder, editionModule.propertyKeyTokenHolder ),
                 deps, editionModule.propertyKeyTokenHolder, editionModule.labelTokenHolder, relationshipTypeTokenHolder,
-                editionModule.lockManager, statementLocksFactory, schemaWriteGuard, transactionEventHandlers,
+                locksFactory, schemaWriteGuard, transactionEventHandlers,
                 platformModule.monitors.newMonitor( IndexingService.Monitor.class ), fileSystem,
                 storeMigrationProcess, platformModule.transactionMonitor, kernelHealth,
                 platformModule.monitors.newMonitor( PhysicalLogFile.Monitor.class ),
@@ -384,21 +389,35 @@ public Relationship newRelationshipProxy( long id, long startNodeId, int typeId,
         };
     }
 
-    private static StatementLocksFactory createStatementLocksFactory()
+    private static StatementLocksFactory createStatementLocksFactory( Locks locks, Config config, Log log )
     {
+        StatementLocksFactory statementLocksFactory;
+
+        String serviceName = StatementLocksFactory.class.getSimpleName();
         List<StatementLocksFactory> factories = Iterables.toList( Service.load( StatementLocksFactory.class ) );
         if ( factories.isEmpty() )
         {
-            return new SimpleStatementLocksFactory();
+            statementLocksFactory = new SimpleStatementLocksFactory( locks );
+
+            log.info( "No services implementing " + serviceName + " found. " +
+                      "Using " + SimpleStatementLocksFactory.class.getSimpleName() );
         }
         else if ( factories.size() == 1 )
         {
-            return factories.get( 0 );
+            statementLocksFactory = factories.get( 0 );
+
+            log.info( "Found single implementation of " + serviceName +
+                      ". Namely " + statementLocksFactory.getClass().getSimpleName() );
         }
         else
         {
-            throw new IllegalStateException( "Found more than one implementation: " + factories );
+            throw new IllegalStateException(
+                    "Found more than one implementation of " + serviceName + ": " + factories );
         }
+
+        statementLocksFactory.initialize( locks, config );
+
+        return statementLocksFactory;
     }
 
     /**

community/kernel/src/main/java/org/neo4j/kernel/impl/locking/SimpleStatementLocksFactory.java

@@ -19,11 +19,36 @@
  */
 package org.neo4j.kernel.impl.locking;
 
+import org.neo4j.kernel.configuration.Config;
+
+import static java.util.Objects.requireNonNull;
+
+/**
+ * A {@link StatementLocksFactory} that creates {@link SimpleStatementLocks}.
+ */
 public class SimpleStatementLocksFactory implements StatementLocksFactory
 {
+    private final Locks locks;
+
+    public SimpleStatementLocksFactory( Locks locks )
+    {
+        this.locks = requireNonNull( locks );
+    }
+
+    /**
+     * Inherited from the {@link StatementLocksFactory} interface but does nothing for this factory.
+     *
+     * @param locks will not be used.
+     * @param config will not be used.
+     */
+    @Override
+    public void initialize( Locks locks, Config config )
+    {
+    }
+
     @Override
-    public StatementLocks newInstance( Locks.Client locksClient )
+    public StatementLocks newInstance()
     {
-        return new SimpleStatementLocks( locksClient );
+        return new SimpleStatementLocks( locks.newClient() );
     }
 }

community/kernel/src/main/java/org/neo4j/kernel/impl/locking/StatementLocksFactory.java

@@ -19,7 +19,26 @@
  */
 package org.neo4j.kernel.impl.locking;
 
+import org.neo4j.kernel.configuration.Config;
+
+/**
+ * Factory to create {@link StatementLocks} instances.
+ */
 public interface StatementLocksFactory
 {
-    StatementLocks newInstance( Locks.Client locksClient );
+    /**
+     * Initialize this factory with the given {@code locks} and {@code config}. Callers should ensure this method
+     * is called once during database startup.
+     *
+     * @param locks the locks to use.
+     * @param config the database config that can contain settings interesting for factory implementations.
+     */
+    void initialize( Locks locks, Config config );
+
+    /**
+     * Create new {@link StatementLocks} instance.
+     *
+     * @return new statement locks.
+     */
+    StatementLocks newInstance();
 }

community/kernel/src/test/java/org/neo4j/kernel/api/KernelTransactionFactory.java

@@ -65,7 +65,7 @@ null, mock( NeoStores.class ),
                 Clock.SYSTEM_CLOCK,
                 TransactionTracer.NULL,
                 new ProcedureCache(),
-                new NoOpLocks(), new SimpleStatementLocksFactory(),
+                new SimpleStatementLocksFactory( new NoOpLocks() ),
                 mock( NeoStoreTransactionContext.class ),
                 false );
     }

community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionImplementationTest.java

@@ -635,7 +635,7 @@ private KernelTransactionImplementation newTransaction( boolean txTerminationAwa
         return new KernelTransactionImplementation( null, null, null, null, null, recordState, null, neoStores,
                 hooks, null, headerInformationFactory, commitProcess,
                 transactionMonitor, storeReadLayer, legacyIndexState, pool, new StandardConstraintSemantics(), clock,
-                TransactionTracer.NULL, new ProcedureCache(), locks, new SimpleStatementLocksFactory(),
+                TransactionTracer.NULL, new ProcedureCache(), new SimpleStatementLocksFactory( locks ),
                 mock( NeoStoreTransactionContext.class ), txTerminationAware );
     }
 

community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionTerminationTest.java

@@ -397,7 +397,7 @@ private static class TestKernelTransaction extends KernelTransactionImplementati
                     mock( TransactionCommitProcess.class ), monitor,
                     mock( StoreReadLayer.class, RETURNS_MOCKS ), mock( LegacyIndexTransactionState.class ),
                     mock( Pool.class ), new StandardConstraintSemantics(), new FakeClock(), TransactionTracer.NULL,
-                    new ProcedureCache(), new NoOpLocks(), new SimpleStatementLocksFactory(),
+                    new ProcedureCache(), new SimpleStatementLocksFactory( new NoOpLocks() ),
                     mock( NeoStoreTransactionContext.class ), true );
 
             this.monitor = monitor;

community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionsTest.java

@@ -339,7 +339,7 @@ private static KernelTransactions newKernelTransactions( TransactionCommitProces
         MetaDataStore metaDataStore = mock( MetaDataStore.class );
         when( metaDataStore.getLastCommittedTransaction() ).thenReturn( new TransactionId( 2, 3, 4 ) );
         when( neoStores.getMetaDataStore() ).thenReturn( metaDataStore );
-        return new KernelTransactions( contextSupplier, neoStores, locks, new SimpleStatementLocksFactory(),
+        return new KernelTransactions( contextSupplier, neoStores, new SimpleStatementLocksFactory( locks ),
                 mock( IntegrityValidator.class ), null, null, null, null, null, null, null,
                 TransactionHeaderInformationFactory.DEFAULT, readLayer, commitProcess, null,
                 null, new TransactionHooks(), mock( ConstraintSemantics.class ), mock( TransactionMonitor.class ),

community/kernel/src/test/java/org/neo4j/kernel/impl/locking/SimpleStatementLocksFactoryTest.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2002-2016 "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.impl.locking;
+
+import org.junit.Test;
+
+import static org.hamcrest.Matchers.instanceOf;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class SimpleStatementLocksFactoryTest
+{
+    @Test
+    public void throwsForNullLocks()
+    {
+        try
+        {
+            new SimpleStatementLocksFactory( null );
+            fail( "Exception expected" );
+        }
+        catch ( Exception e )
+        {
+            assertThat( e, instanceOf( NullPointerException.class ) );
+        }
+    }
+
+    @Test
+    public void createSimpleStatementLocks()
+    {
+        Locks locks = mock( Locks.class );
+        Locks.Client client = mock( Locks.Client.class );
+        when( locks.newClient() ).thenReturn( client );
+
+        SimpleStatementLocksFactory factory = new SimpleStatementLocksFactory( locks );
+
+        StatementLocks statementLocks = factory.newInstance();
+
+        assertThat( statementLocks, instanceOf( SimpleStatementLocks.class ) );
+        assertSame( client, statementLocks.optimistic() );
+        assertSame( client, statementLocks.pessimistic() );
+    }
+}

community/kernel/src/test/java/org/neo4j/test/NeoStoreDataSourceRule.java

@@ -102,8 +102,8 @@ public NeoStoreDataSource getDataSource( File storeDir, FileSystemAbstraction fs
         dataSource = new NeoStoreDataSource( storeDir, config, storeFactory, logProvider,
                 mock( JobScheduler.class, RETURNS_MOCKS ), mock( TokenNameLookup.class ),
                 dependencyResolverForNoIndexProvider(), mock( PropertyKeyTokenHolder.class ),
-                mock( LabelTokenHolder.class ), mock( RelationshipTypeTokenHolder.class ), locks,
-                new SimpleStatementLocksFactory(),
+                mock( LabelTokenHolder.class ), mock( RelationshipTypeTokenHolder.class ),
+                new SimpleStatementLocksFactory( locks ),
                 mock( SchemaWriteGuard.class ), mock( TransactionEventHandlers.class ), IndexingService.NO_MONITOR,
                 fs, mock( StoreUpgrader.class ), mock( TransactionMonitor.class ), kernelHealth,
                 mock( PhysicalLogFile.Monitor.class ), TransactionHeaderInformationFactory.DEFAULT,