Casual Clustering id reuse

Back-porting from 3.3 id reuse for causal clustering

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

@@ -86,14 +86,13 @@
 import org.neo4j.kernel.impl.logging.LogService;
 import org.neo4j.kernel.impl.proc.Procedures;
 import org.neo4j.kernel.impl.storageengine.impl.recordstorage.RecordStorageEngine;
+import org.neo4j.kernel.impl.storageengine.impl.recordstorage.id.IdController;
 import org.neo4j.kernel.impl.store.MetaDataStore;
 import org.neo4j.kernel.impl.store.StoreId;
 import org.neo4j.kernel.impl.store.format.RecordFormatPropertyConfigurator;
 import org.neo4j.kernel.impl.store.format.RecordFormatSelector;
 import org.neo4j.kernel.impl.store.format.RecordFormats;
 import org.neo4j.kernel.impl.store.id.IdGeneratorFactory;
-import org.neo4j.kernel.impl.store.id.IdReuseEligibility;
-import org.neo4j.kernel.impl.store.id.configuration.IdTypeConfigurationProvider;
 import org.neo4j.kernel.impl.storemigration.DatabaseMigrator;
 import org.neo4j.kernel.impl.storemigration.monitoring.VisibleMigrationProgressMonitor;
 import org.neo4j.kernel.impl.storemigration.participant.StoreMigrator;
@@ -244,8 +243,6 @@ boolean applicable( DiagnosticsPhase phase )
     private final SchemaWriteGuard schemaWriteGuard;
     private final TransactionEventHandlers transactionEventHandlers;
     private final IdGeneratorFactory idGeneratorFactory;
-    private final IdReuseEligibility eligibleForReuse;
-    private final IdTypeConfigurationProvider idTypeConfigurationProvider;
     private final JobScheduler scheduler;
     private final Config config;
     private final LockService lockService;
@@ -274,6 +271,7 @@ boolean applicable( DiagnosticsPhase phase )
     private LabelScanStoreProvider labelScanStoreProvider;
     private File storeDir;
     private boolean readOnly;
+    private final IdController idController;
     private final AccessCapability accessCapability;
 
     private StorageEngine storageEngine;
@@ -290,8 +288,6 @@ public NeoStoreDataSource(
             File storeDir,
             Config config,
             IdGeneratorFactory idGeneratorFactory,
-            IdReuseEligibility eligibleForReuse,
-            IdTypeConfigurationProvider idTypeConfigurationProvider,
             LogService logService,
             JobScheduler scheduler,
             TokenNameLookup tokenNameLookup,
@@ -321,13 +317,12 @@ public NeoStoreDataSource(
             AvailabilityGuard availabilityGuard,
             SystemNanoClock clock,
             AccessCapability accessCapability,
-            StoreCopyCheckPointMutex storeCopyCheckPointMutex )
+            StoreCopyCheckPointMutex storeCopyCheckPointMutex,
+            IdController idController )
     {
         this.storeDir = storeDir;
         this.config = config;
         this.idGeneratorFactory = idGeneratorFactory;
-        this.eligibleForReuse = eligibleForReuse;
-        this.idTypeConfigurationProvider = idTypeConfigurationProvider;
         this.tokenNameLookup = tokenNameLookup;
         this.dependencyResolver = dependencyResolver;
         this.scheduler = scheduler;
@@ -359,6 +354,7 @@ public NeoStoreDataSource(
         this.accessCapability = accessCapability;
 
         readOnly = config.get( Configuration.read_only );
+        this.idController = idController;
         msgLog = logProvider.getLog( getClass() );
         this.lockService = new ReentrantLockService();
         this.legacyIndexProviderLookup = new LegacyIndexProviderLookup()
@@ -431,6 +427,9 @@ public void start() throws IOException
 
             SynchronizedArrayIdOrderingQueue legacyIndexTransactionOrdering = new SynchronizedArrayIdOrderingQueue( 20 );
 
+            Supplier<KernelTransactionsSnapshot> transactionsSnapshotSupplier = () -> kernelModule.kernelTransactions().get();
+            idController.initialize( transactionsSnapshotSupplier );
+
             storageEngine = buildStorageEngine(
                     propertyKeyTokenHolder, labelTokens, relationshipTypeTokens, legacyIndexProviderLookup,
                     indexConfigStore, updateableSchemaState::clear, legacyIndexTransactionOrdering );
@@ -567,17 +566,12 @@ private StorageEngine buildStorageEngine(
             LegacyIndexProviderLookup legacyIndexProviderLookup, IndexConfigStore indexConfigStore,
             Runnable schemaStateChangeCallback, SynchronizedArrayIdOrderingQueue legacyIndexTransactionOrdering )
     {
-        // TODO we should break this dependency on the kernelModule (which has not yet been created at this point in
-        // TODO the code) and instead let information about generations of transactions flow through the StorageEngine
-        // TODO API
-        Supplier<KernelTransactionsSnapshot> transactionSnapshotSupplier =
-                () -> kernelModule.kernelTransactions().get();
-        RecordStorageEngine storageEngine = new RecordStorageEngine( storeDir, config, idGeneratorFactory,
-                eligibleForReuse, idTypeConfigurationProvider, pageCache, fs, logProvider, propertyKeyTokenHolder,
-                labelTokens, relationshipTypeTokens, schemaStateChangeCallback, constraintSemantics, scheduler,
-                tokenNameLookup, lockService, schemaIndexProvider, indexingServiceMonitor, databaseHealth,
-                labelScanStoreProvider, legacyIndexProviderLookup, indexConfigStore, legacyIndexTransactionOrdering,
-                transactionSnapshotSupplier );
+        RecordStorageEngine storageEngine = new RecordStorageEngine( storeDir, config,
+                pageCache, fs, logProvider, propertyKeyTokenHolder, labelTokens, relationshipTypeTokens,
+                schemaStateChangeCallback, constraintSemantics, scheduler, tokenNameLookup, lockService,
+                schemaIndexProvider, indexingServiceMonitor, databaseHealth, labelScanStoreProvider,
+                legacyIndexProviderLookup, indexConfigStore, legacyIndexTransactionOrdering, idGeneratorFactory,
+                idController );
 
         // We pretend that the storage engine abstract hides all details within it. Whereas that's mostly
         // true it's not entirely true for the time being. As long as we need this call below, which

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

@@ -106,7 +106,11 @@ public CommunityEditionModule( PlatformModule platformModule )
         statementLocksFactory = createStatementLocksFactory( lockManager, config, logging );
 
         idTypeConfigurationProvider = createIdTypeConfigurationProvider( config );
-        idGeneratorFactory = dependencies.satisfyDependency( createIdGeneratorFactory( fileSystem, idTypeConfigurationProvider ) );
+        eligibleForIdReuse = IdReuseEligibility.ALWAYS;
+
+        createIdComponents( platformModule, dependencies, createIdGeneratorFactory( fileSystem, idTypeConfigurationProvider ) );
+        dependencies.satisfyDependency( idGeneratorFactory );
+        dependencies.satisfyDependency( idController );
 
         propertyKeyTokenHolder = life.add( dependencies.satisfyDependency( new DelegatingPropertyKeyTokenHolder(
                 createPropertyKeyCreator( config, dataSourceManager, idGeneratorFactory ) ) ) );
@@ -132,8 +136,6 @@ public CommunityEditionModule( PlatformModule platformModule )
 
         ioLimiter = IOLimiter.unlimited();
 
-        eligibleForIdReuse = IdReuseEligibility.ALWAYS;
-
         registerRecovery( platformModule.databaseInfo, life, dependencies );
 
         publishEditionInfo( dependencies.resolveDependency( UsageData.class ), platformModule.databaseInfo, config );

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

@@ -63,9 +63,9 @@
 import org.neo4j.kernel.impl.core.ThreadToStatementContextBridge;
 import org.neo4j.kernel.impl.core.TokenNotFoundException;
 import org.neo4j.kernel.impl.logging.LogService;
-import org.neo4j.kernel.impl.proc.ProcedureTransactionProvider;
 import org.neo4j.kernel.impl.proc.ProcedureConfig;
 import org.neo4j.kernel.impl.proc.ProcedureGDSFactory;
+import org.neo4j.kernel.impl.proc.ProcedureTransactionProvider;
 import org.neo4j.kernel.impl.proc.Procedures;
 import org.neo4j.kernel.impl.proc.TerminationGuardProvider;
 import org.neo4j.kernel.impl.proc.TypeMappers.SimpleConverter;
@@ -189,8 +189,6 @@ public DataSourceModule( final PlatformModule platformModule, EditionModule edit
                 storeDir,
                 config,
                 editionModule.idGeneratorFactory,
-                editionModule.eligibleForIdReuse,
-                editionModule.idTypeConfigurationProvider,
                 logging,
                 platformModule.jobScheduler,
                 tokenNameLookup,
@@ -219,7 +217,8 @@ public DataSourceModule( final PlatformModule platformModule, EditionModule edit
                 editionModule.ioLimiter,
                 platformModule.availabilityGuard,
                 platformModule.clock, editionModule.accessCapability,
-                platformModule.storeCopyCheckPointMutex ) );
+                platformModule.storeCopyCheckPointMutex,
+                editionModule.idController) );
 
         dataSourceManager.register( neoStoreDataSource );
 

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

@@ -44,10 +44,15 @@
 import org.neo4j.kernel.impl.locking.StatementLocksFactory;
 import org.neo4j.kernel.impl.logging.LogService;
 import org.neo4j.kernel.impl.proc.Procedures;
+import org.neo4j.kernel.impl.storageengine.impl.recordstorage.id.BufferedIdController;
+import org.neo4j.kernel.impl.storageengine.impl.recordstorage.id.DefaultIdController;
+import org.neo4j.kernel.impl.storageengine.impl.recordstorage.id.IdController;
+import org.neo4j.kernel.impl.store.id.BufferingIdGeneratorFactory;
 import org.neo4j.kernel.impl.store.id.IdGeneratorFactory;
 import org.neo4j.kernel.impl.store.id.IdReuseEligibility;
 import org.neo4j.kernel.impl.store.id.configuration.IdTypeConfigurationProvider;
 import org.neo4j.kernel.impl.transaction.TransactionHeaderInformationFactory;
+import org.neo4j.kernel.impl.util.Dependencies;
 import org.neo4j.kernel.impl.util.DependencySatisfier;
 import org.neo4j.kernel.impl.util.JobScheduler;
 import org.neo4j.kernel.impl.util.watcher.DefaultFileDeletionEventListener;
@@ -59,6 +64,7 @@
 import org.neo4j.logging.Log;
 import org.neo4j.udc.UsageData;
 import org.neo4j.udc.UsageDataKeys;
+import org.neo4j.unsafe.impl.internal.dragons.FeatureToggles;
 
 import static java.util.Collections.singletonMap;
 
@@ -68,6 +74,10 @@
  */
 public abstract class EditionModule
 {
+    // This resided in RecordStorageEngine before
+    private static final boolean safeIdBuffering = FeatureToggles.flag(
+            EditionModule.class, "safeIdBuffering", true );
+
     void registerProcedures( Procedures procedures ) throws KernelException
     {
         procedures.registerProcedure( org.neo4j.kernel.builtinprocs.BuiltInProcedures.class );
@@ -112,6 +122,8 @@ void registerProcedures( Procedures procedures ) throws KernelException
 
     public FileSystemWatcherService watcherService;
 
+    public IdController idController;
+
     protected FileSystemWatcherService createFileSystemWatcherService( FileSystemAbstraction fileSystem, File storeDir,
             LogService logging, JobScheduler jobScheduler, Predicate<String> fileNameFilter )
     {
@@ -225,4 +237,33 @@ protected BoltConnectionTracker createSessionTracker()
     {
         return BoltConnectionTracker.NOOP;
     }
+
+    protected void createIdComponents( PlatformModule platformModule, Dependencies dependencies, IdGeneratorFactory
+            editionIdGeneratorFactory )
+    {
+        IdGeneratorFactory factory = editionIdGeneratorFactory;
+        if ( safeIdBuffering )
+        {
+            BufferingIdGeneratorFactory bufferingIdGeneratorFactory =
+                    new BufferingIdGeneratorFactory( factory, eligibleForIdReuse, idTypeConfigurationProvider );
+            idController = createBufferedIdController( bufferingIdGeneratorFactory, platformModule.jobScheduler );
+            factory = bufferingIdGeneratorFactory;
+        }
+        else
+        {
+            idController = createDefaultIdController();
+        }
+        this.idGeneratorFactory = factory;
+    }
+
+    private BufferedIdController createBufferedIdController( BufferingIdGeneratorFactory idGeneratorFactory,
+            JobScheduler scheduler )
+    {
+        return new BufferedIdController( idGeneratorFactory, scheduler );
+    }
+
+    protected DefaultIdController createDefaultIdController()
+    {
+        return new DefaultIdController();
+    }
 }

community/kernel/src/main/java/org/neo4j/kernel/impl/storageengine/impl/recordstorage/RecordStorageEngine.java

@@ -48,7 +48,6 @@
 import org.neo4j.kernel.impl.api.CountsRecordState;
 import org.neo4j.kernel.impl.api.CountsStoreBatchTransactionApplier;
 import org.neo4j.kernel.impl.api.IndexReaderFactory;
-import org.neo4j.kernel.impl.api.KernelTransactionsSnapshot;
 import org.neo4j.kernel.impl.api.LegacyBatchIndexApplier;
 import org.neo4j.kernel.impl.api.LegacyIndexApplierLookup;
 import org.neo4j.kernel.impl.api.LegacyIndexProviderLookup;
@@ -59,8 +58,8 @@
 import org.neo4j.kernel.impl.api.index.IndexingUpdateService;
 import org.neo4j.kernel.impl.api.index.PropertyPhysicalToLogicalConverter;
 import org.neo4j.kernel.impl.api.scan.LabelScanStoreProvider;
-import org.neo4j.kernel.impl.api.store.StorageLayer;
 import org.neo4j.kernel.impl.api.store.SchemaCache;
+import org.neo4j.kernel.impl.api.store.StorageLayer;
 import org.neo4j.kernel.impl.api.store.StoreStatement;
 import org.neo4j.kernel.impl.cache.BridgingCacheAccess;
 import org.neo4j.kernel.impl.constraints.ConstraintSemantics;
@@ -71,8 +70,6 @@
 import org.neo4j.kernel.impl.index.IndexConfigStore;
 import org.neo4j.kernel.impl.locking.LockGroup;
 import org.neo4j.kernel.impl.locking.LockService;
-import org.neo4j.kernel.impl.storageengine.impl.recordstorage.id.BufferedIdController;
-import org.neo4j.kernel.impl.storageengine.impl.recordstorage.id.DefaultIdController;
 import org.neo4j.kernel.impl.storageengine.impl.recordstorage.id.IdController;
 import org.neo4j.kernel.impl.store.NeoStores;
 import org.neo4j.kernel.impl.store.RecordStore;
@@ -81,8 +78,6 @@
 import org.neo4j.kernel.impl.store.StoreType;
 import org.neo4j.kernel.impl.store.format.RecordFormat;
 import org.neo4j.kernel.impl.store.id.IdGeneratorFactory;
-import org.neo4j.kernel.impl.store.id.IdReuseEligibility;
-import org.neo4j.kernel.impl.store.id.configuration.IdTypeConfigurationProvider;
 import org.neo4j.kernel.impl.store.record.AbstractBaseRecord;
 import org.neo4j.kernel.impl.transaction.command.CacheInvalidationBatchTransactionApplier;
 import org.neo4j.kernel.impl.transaction.command.HighIdBatchTransactionApplier;
@@ -131,8 +126,6 @@ public class RecordStorageEngine implements StorageEngine, Lifecycle
 {
     private static final boolean takePropertyReadLocks = FeatureToggles.flag(
             RecordStorageEngine.class, "propertyReadLocks", false );
-    private static final boolean safeIdBuffering = FeatureToggles.flag(
-            RecordStorageEngine.class, "safeIdBuffering", true );
 
     private final StoreReadLayer storeLayer;
     private final IndexingService indexingService;
@@ -152,7 +145,6 @@ public class RecordStorageEngine implements StorageEngine, Lifecycle
     private final SchemaStorage schemaStorage;
     private final ConstraintSemantics constraintSemantics;
     private final IdOrderingQueue legacyIndexTransactionOrdering;
-    private final JobScheduler scheduler;
     private final LockService lockService;
     private final WorkSync<Supplier<LabelScanWriter>,LabelUpdateWork> labelScanStoreSync;
     private final CommandReaderFactory commandReaderFactory;
@@ -173,9 +165,6 @@ public class RecordStorageEngine implements StorageEngine, Lifecycle
     public RecordStorageEngine(
             File storeDir,
             Config config,
-            IdGeneratorFactory idGeneratorFactory,
-            IdReuseEligibility eligibleForReuse,
-            IdTypeConfigurationProvider idTypeConfigurationProvider,
             PageCache pageCache,
             FileSystemAbstraction fs,
             LogProvider logProvider,
@@ -194,23 +183,22 @@ public RecordStorageEngine(
             LegacyIndexProviderLookup legacyIndexProviderLookup,
             IndexConfigStore indexConfigStore,
             IdOrderingQueue legacyIndexTransactionOrdering,
-            Supplier<KernelTransactionsSnapshot> transactionsSnapshotSupplier )
+            IdGeneratorFactory idGeneratorFactory,
+            IdController idController )
     {
         this.propertyKeyTokenHolder = propertyKeyTokenHolder;
         this.relationshipTypeTokenHolder = relationshipTypeTokens;
         this.labelTokenHolder = labelTokens;
         this.schemaStateChangeCallback = schemaStateChangeCallback;
-        this.scheduler = scheduler;
         this.lockService = lockService;
         this.databaseHealth = databaseHealth;
         this.legacyIndexProviderLookup = legacyIndexProviderLookup;
         this.indexConfigStore = indexConfigStore;
         this.constraintSemantics = constraintSemantics;
         this.legacyIndexTransactionOrdering = legacyIndexTransactionOrdering;
 
-        this.idController = createStorageIdController( idGeneratorFactory, eligibleForReuse,
-            idTypeConfigurationProvider, transactionsSnapshotSupplier );
-        StoreFactory factory = new StoreFactory( storeDir, config, idController.getIdGeneratorFactory(), pageCache, fs, logProvider );
+        this.idController = idController;
+        StoreFactory factory = new StoreFactory( storeDir, config, idGeneratorFactory, pageCache, fs, logProvider );
         neoStores = factory.openAllNeoStores( true );
 
         try
@@ -263,17 +251,6 @@ public RecordStorageEngine(
         }
     }
 
-    private IdController createStorageIdController( IdGeneratorFactory idGeneratorFactory,
-            IdReuseEligibility eligibleForReuse,
-            IdTypeConfigurationProvider idTypeConfigurationProvider,
-            Supplier<KernelTransactionsSnapshot> transactionsSnapshotSupplier )
-    {
-        return safeIdBuffering ?
-               new BufferedIdController( idGeneratorFactory, transactionsSnapshotSupplier,
-                       eligibleForReuse, idTypeConfigurationProvider, scheduler ) :
-               new DefaultIdController( idGeneratorFactory );
-    }
-
     private Supplier<StorageStatement> storeStatementSupplier( NeoStores neoStores )
     {
         Supplier<IndexReaderFactory> indexReaderFactory = () -> new IndexReaderFactory.Caching( indexingService );
@@ -410,7 +387,6 @@ public void satisfyDependencies( DependencySatisfier satisfier )
         // providing TransactionIdStore, LogVersionRepository
         satisfier.satisfyDependency( neoStores.getMetaDataStore() );
         satisfier.satisfyDependency( indexStoreView );
-        satisfier.satisfyDependency( idController );
     }
 
     @Override

community/kernel/src/main/java/org/neo4j/kernel/impl/storageengine/impl/recordstorage/id/BufferedIdController.java

@@ -25,8 +25,6 @@
 import org.neo4j.kernel.impl.api.KernelTransactionsSnapshot;
 import org.neo4j.kernel.impl.store.id.BufferingIdGeneratorFactory;
 import org.neo4j.kernel.impl.store.id.IdGeneratorFactory;
-import org.neo4j.kernel.impl.store.id.IdReuseEligibility;
-import org.neo4j.kernel.impl.store.id.configuration.IdTypeConfigurationProvider;
 import org.neo4j.kernel.impl.util.JobScheduler;
 import org.neo4j.kernel.lifecycle.LifecycleAdapter;
 
@@ -42,13 +40,10 @@ public class BufferedIdController extends LifecycleAdapter implements IdControll
     private final JobScheduler scheduler;
     private JobScheduler.JobHandle jobHandle;
 
-    public BufferedIdController( IdGeneratorFactory idGeneratorFactory,
-            Supplier<KernelTransactionsSnapshot> transactionsSnapshotSupplier, IdReuseEligibility eligibleForReuse,
-            IdTypeConfigurationProvider idTypeConfigurationProvider, JobScheduler scheduler )
+    public BufferedIdController( BufferingIdGeneratorFactory bufferingIdGeneratorFactory, JobScheduler scheduler )
     {
+        this.bufferingIdGeneratorFactory = bufferingIdGeneratorFactory;
         this.scheduler = scheduler;
-        bufferingIdGeneratorFactory = new BufferingIdGeneratorFactory(
-                idGeneratorFactory, transactionsSnapshotSupplier, eligibleForReuse, idTypeConfigurationProvider );
     }
 
     public IdGeneratorFactory getIdGeneratorFactory()
@@ -80,4 +75,10 @@ public void maintenance()
     {
         bufferingIdGeneratorFactory.maintenance();
     }
+
+    @Override
+    public void initialize( Supplier<KernelTransactionsSnapshot> transactionsSnapshotSupplier )
+    {
+        bufferingIdGeneratorFactory.initialize( transactionsSnapshotSupplier );
+    }
 }