Use schema state directly to clear it instead of using callback.

Propagate schema state to perform operations directly instead of passing
Runnable callback.

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

@@ -59,6 +59,7 @@
 import org.neo4j.kernel.impl.api.KernelTransactionsSnapshot;
 import org.neo4j.kernel.impl.api.LegacyIndexProviderLookup;
 import org.neo4j.kernel.impl.api.LockingStatementOperations;
+import org.neo4j.kernel.impl.api.SchemaState;
 import org.neo4j.kernel.impl.api.SchemaStateConcern;
 import org.neo4j.kernel.impl.api.SchemaWriteGuard;
 import org.neo4j.kernel.impl.api.StackingQueryRegistrationOperations;
@@ -136,7 +137,6 @@
 import org.neo4j.kernel.impl.transaction.log.rotation.LogRotationImpl;
 import org.neo4j.kernel.impl.transaction.state.NeoStoreFileListing;
 import org.neo4j.kernel.impl.util.Dependencies;
-import org.neo4j.scheduler.JobScheduler;
 import org.neo4j.kernel.impl.util.SynchronizedArrayIdOrderingQueue;
 import org.neo4j.kernel.info.DiagnosticsExtractor;
 import org.neo4j.kernel.info.DiagnosticsManager;
@@ -158,6 +158,7 @@
 import org.neo4j.logging.Log;
 import org.neo4j.logging.LogProvider;
 import org.neo4j.logging.Logger;
+import org.neo4j.scheduler.JobScheduler;
 import org.neo4j.storageengine.api.StorageEngine;
 import org.neo4j.storageengine.api.StoreFileMetadata;
 import org.neo4j.storageengine.api.StoreReadLayer;
@@ -439,7 +440,7 @@ public void start() throws IOException
 
             storageEngine = buildStorageEngine(
                     propertyKeyTokenHolder, labelTokens, relationshipTypeTokens, legacyIndexProviderLookup,
-                    indexConfigStore, updateableSchemaState::clear, legacyIndexTransactionOrdering );
+                    indexConfigStore, updateableSchemaState, legacyIndexTransactionOrdering );
 
             LogEntryReader<ReadableClosablePositionAwareChannel> logEntryReader =
                     new VersionAwareLogEntryReader<>( storageEngine.commandReaderFactory(), STRICT );
@@ -572,7 +573,7 @@ private StorageEngine buildStorageEngine(
             PropertyKeyTokenHolder propertyKeyTokenHolder, LabelTokenHolder labelTokens,
             RelationshipTypeTokenHolder relationshipTypeTokens,
             LegacyIndexProviderLookup legacyIndexProviderLookup, IndexConfigStore indexConfigStore,
-            Runnable schemaStateChangeCallback, SynchronizedArrayIdOrderingQueue legacyIndexTransactionOrdering )
+            SchemaState schemaState, 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
@@ -581,7 +582,7 @@ private StorageEngine buildStorageEngine(
                 () -> kernelModule.kernelTransactions().get();
         RecordStorageEngine storageEngine = new RecordStorageEngine( storeDir, config, idGeneratorFactory,
                 eligibleForReuse, idTypeConfigurationProvider, pageCache, fs, logProvider, propertyKeyTokenHolder,
-                labelTokens, relationshipTypeTokens, schemaStateChangeCallback, constraintSemantics, scheduler,
+                labelTokens, relationshipTypeTokens, schemaState, constraintSemantics, scheduler,
                 tokenNameLookup, lockService, schemaIndexProvider, indexingServiceMonitor, databaseHealth,
                 labelScanStoreProvider, legacyIndexProviderLookup, indexConfigStore, legacyIndexTransactionOrdering,
                 transactionSnapshotSupplier );

community/kernel/src/main/java/org/neo4j/kernel/impl/api/index/IndexPopulationJob.java

@@ -28,6 +28,7 @@
 import org.neo4j.kernel.api.index.IndexPopulator;
 import org.neo4j.kernel.api.index.SchemaIndexProvider;
 import org.neo4j.kernel.api.schema.index.IndexDescriptor;
+import org.neo4j.kernel.impl.api.SchemaState;
 import org.neo4j.storageengine.api.schema.PopulationProgress;
 
 import static java.lang.Thread.currentThread;
@@ -44,21 +45,16 @@ public class IndexPopulationJob implements Runnable
 {
     private final IndexingService.Monitor monitor;
     private final MultipleIndexPopulator multiPopulator;
-    private final IndexStoreView storeView;
     private final CountDownLatch doneSignal = new CountDownLatch( 1 );
-    private final Runnable schemaStateChangeCallback;
+    private final SchemaState schemaState;
 
     private volatile StoreScan<IndexPopulationFailedKernelException> storeScan;
     private volatile boolean cancelled;
 
-    public IndexPopulationJob( IndexStoreView storeView,
-                               MultipleIndexPopulator multiPopulator,
-                               IndexingService.Monitor monitor,
-                               Runnable schemaStateChangeCallback )
+    public IndexPopulationJob( MultipleIndexPopulator multiPopulator, IndexingService.Monitor monitor, SchemaState schemaState )
     {
         this.multiPopulator = multiPopulator;
-        this.storeView = storeView;
-        this.schemaStateChangeCallback = schemaStateChangeCallback;
+        this.schemaState = schemaState;
         this.monitor = monitor;
     }
 
@@ -118,7 +114,7 @@ public void run()
 
                 multiPopulator.flipAfterPopulation();
 
-                schemaStateChangeCallback.run();
+                schemaState.clear();
             }
             catch ( Throwable t )
             {

community/kernel/src/main/java/org/neo4j/kernel/impl/api/index/IndexingService.java

@@ -51,17 +51,18 @@
 import org.neo4j.kernel.api.index.SchemaIndexProvider.Descriptor;
 import org.neo4j.kernel.api.schema.LabelSchemaDescriptor;
 import org.neo4j.kernel.api.schema.index.IndexDescriptor;
+import org.neo4j.kernel.impl.api.SchemaState;
 import org.neo4j.kernel.impl.api.index.sampling.IndexSamplingController;
 import org.neo4j.kernel.impl.api.index.sampling.IndexSamplingMode;
 import org.neo4j.kernel.impl.store.UnderlyingStorageException;
 import org.neo4j.kernel.impl.store.record.IndexRule;
 import org.neo4j.kernel.impl.transaction.state.IndexUpdates;
-import org.neo4j.scheduler.JobScheduler;
 import org.neo4j.kernel.lifecycle.LifecycleAdapter;
 import org.neo4j.logging.Log;
 import org.neo4j.logging.LogProvider;
 import org.neo4j.register.Register.DoubleLongRegister;
 import org.neo4j.register.Registers;
+import org.neo4j.scheduler.JobScheduler;
 
 import static java.lang.String.format;
 import static java.util.concurrent.TimeUnit.MINUTES;
@@ -101,7 +102,7 @@ public class IndexingService extends LifecycleAdapter implements IndexingUpdateS
     private final Monitor monitor;
     private final PrimitiveLongSet recoveredNodeIds = Primitive.longSet( 20 );
     private final JobScheduler scheduler;
-    private final Runnable schemaStateChangeCallback;
+    private final SchemaState schemaState;
 
     enum State
     {
@@ -172,7 +173,7 @@ public void awaitingPopulationOfRecoveredIndex( long indexId, IndexDescriptor de
             IndexSamplingController samplingController,
             TokenNameLookup tokenNameLookup,
             JobScheduler scheduler,
-            Runnable schemaStateChangeCallback,
+            SchemaState schemaState,
             MultiPopulatorFactory multiPopulatorFactory,
             LogProvider logProvider,
             Monitor monitor )
@@ -185,7 +186,7 @@ public void awaitingPopulationOfRecoveredIndex( long indexId, IndexDescriptor de
         this.samplingController = samplingController;
         this.tokenNameLookup = tokenNameLookup;
         this.scheduler = scheduler;
-        this.schemaStateChangeCallback = schemaStateChangeCallback;
+        this.schemaState = schemaState;
         this.multiPopulatorFactory = multiPopulatorFactory;
         this.logProvider = logProvider;
         this.monitor = monitor;
@@ -739,7 +740,7 @@ public ResourceIterator<File> snapshotStoreFiles() throws IOException
     private IndexPopulationJob newIndexPopulationJob()
     {
         MultipleIndexPopulator multiPopulator = multiPopulatorFactory.create( storeView, logProvider );
-        return new IndexPopulationJob( storeView, multiPopulator, monitor, schemaStateChangeCallback );
+        return new IndexPopulationJob( multiPopulator, monitor, schemaState );
     }
 
     private void startIndexPopulation( IndexPopulationJob job )

community/kernel/src/main/java/org/neo4j/kernel/impl/api/index/IndexingServiceFactory.java

@@ -22,12 +22,13 @@
 import org.neo4j.kernel.api.TokenNameLookup;
 import org.neo4j.kernel.api.index.SchemaIndexProvider;
 import org.neo4j.kernel.configuration.Config;
+import org.neo4j.kernel.impl.api.SchemaState;
 import org.neo4j.kernel.impl.api.index.sampling.IndexSamplingConfig;
 import org.neo4j.kernel.impl.api.index.sampling.IndexSamplingController;
 import org.neo4j.kernel.impl.api.index.sampling.IndexSamplingControllerFactory;
 import org.neo4j.kernel.impl.store.record.IndexRule;
-import org.neo4j.scheduler.JobScheduler;
 import org.neo4j.logging.LogProvider;
+import org.neo4j.scheduler.JobScheduler;
 
 /**
  * Factory to create {@link IndexingService}
@@ -46,7 +47,7 @@ public static IndexingService createIndexingService( Config config,
                                           Iterable<IndexRule> indexRules,
                                           LogProvider logProvider,
                                           IndexingService.Monitor monitor,
-                                          Runnable schemaStateChangeCallback )
+                                          SchemaState schemaState )
     {
         if ( providerMap == null || providerMap.getDefaultProvider() == null )
         {
@@ -65,7 +66,7 @@ public static IndexingService createIndexingService( Config config,
                 new IndexProxyCreator( samplingConfig, storeView, providerMap, tokenNameLookup, logProvider );
 
         return new IndexingService( proxySetup, providerMap, indexMapRef, storeView, indexRules,
-                indexSamplingController, tokenNameLookup, scheduler, schemaStateChangeCallback,
+                indexSamplingController, tokenNameLookup, scheduler, schemaState,
                 multiPopulatorFactory, logProvider, monitor );
     }
 }

community/kernel/src/main/java/org/neo4j/kernel/impl/cache/BridgingCacheAccess.java

@@ -19,6 +19,7 @@
  */
 package org.neo4j.kernel.impl.cache;
 
+import org.neo4j.kernel.impl.api.SchemaState;
 import org.neo4j.kernel.impl.api.store.SchemaCache;
 import org.neo4j.kernel.impl.core.CacheAccessBackDoor;
 import org.neo4j.kernel.impl.core.LabelTokenHolder;
@@ -31,18 +32,18 @@
 public class BridgingCacheAccess implements CacheAccessBackDoor
 {
     private final SchemaCache schemaCache;
-    private final Runnable schemaStateChangeCallback;
+    private final SchemaState schemaState;
     private final PropertyKeyTokenHolder propertyKeyTokenHolder;
     private final RelationshipTypeTokenHolder relationshipTypeTokenHolder;
     private final LabelTokenHolder labelTokenHolder;
 
-    public BridgingCacheAccess( SchemaCache schemaCache, Runnable schemaStateChangeCallback,
+    public BridgingCacheAccess( SchemaCache schemaCache, SchemaState schemaState,
             PropertyKeyTokenHolder propertyKeyTokenHolder,
             RelationshipTypeTokenHolder relationshipTypeTokenHolder,
             LabelTokenHolder labelTokenHolder )
     {
         this.schemaCache = schemaCache;
-        this.schemaStateChangeCallback = schemaStateChangeCallback;
+        this.schemaState = schemaState;
         this.propertyKeyTokenHolder = propertyKeyTokenHolder;
         this.relationshipTypeTokenHolder = relationshipTypeTokenHolder;
         this.labelTokenHolder = labelTokenHolder;
@@ -58,7 +59,7 @@ public void addSchemaRule( SchemaRule rule )
     public void removeSchemaRuleFromCache( long id )
     {
         schemaCache.removeSchemaRule( id );
-        schemaStateChangeCallback.run();
+        schemaState.clear();
     }
 
     @Override

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

@@ -51,15 +51,16 @@
 import org.neo4j.kernel.impl.api.LegacyBatchIndexApplier;
 import org.neo4j.kernel.impl.api.LegacyIndexApplierLookup;
 import org.neo4j.kernel.impl.api.LegacyIndexProviderLookup;
+import org.neo4j.kernel.impl.api.SchemaState;
 import org.neo4j.kernel.impl.api.TransactionApplier;
 import org.neo4j.kernel.impl.api.TransactionApplierFacade;
 import org.neo4j.kernel.impl.api.index.IndexingService;
 import org.neo4j.kernel.impl.api.index.IndexingServiceFactory;
 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;
@@ -104,12 +105,12 @@
 import org.neo4j.kernel.impl.transaction.state.storeview.NeoStoreIndexStoreView;
 import org.neo4j.kernel.impl.util.DependencySatisfier;
 import org.neo4j.kernel.impl.util.IdOrderingQueue;
-import org.neo4j.scheduler.JobScheduler;
 import org.neo4j.kernel.info.DiagnosticsManager;
 import org.neo4j.kernel.internal.DatabaseHealth;
 import org.neo4j.kernel.lifecycle.Lifecycle;
 import org.neo4j.kernel.spi.legacyindex.IndexImplementation;
 import org.neo4j.logging.LogProvider;
+import org.neo4j.scheduler.JobScheduler;
 import org.neo4j.storageengine.api.CommandReaderFactory;
 import org.neo4j.storageengine.api.CommandsToApply;
 import org.neo4j.storageengine.api.StorageCommand;
@@ -147,7 +148,7 @@ public class RecordStorageEngine implements StorageEngine, Lifecycle
     private final LabelScanStore labelScanStore;
     private final DefaultSchemaIndexProviderMap schemaIndexProviderMap;
     private final LegacyIndexApplierLookup legacyIndexApplierLookup;
-    private final Runnable schemaStateChangeCallback;
+    private final SchemaState schemaState;
     private final SchemaStorage schemaStorage;
     private final ConstraintSemantics constraintSemantics;
     private final IdOrderingQueue legacyIndexTransactionOrdering;
@@ -181,7 +182,7 @@ public RecordStorageEngine(
             PropertyKeyTokenHolder propertyKeyTokenHolder,
             LabelTokenHolder labelTokens,
             RelationshipTypeTokenHolder relationshipTypeTokens,
-            Runnable schemaStateChangeCallback,
+            SchemaState schemaState,
             ConstraintSemantics constraintSemantics,
             JobScheduler scheduler,
             TokenNameLookup tokenNameLookup,
@@ -198,7 +199,7 @@ public RecordStorageEngine(
         this.propertyKeyTokenHolder = propertyKeyTokenHolder;
         this.relationshipTypeTokenHolder = relationshipTypeTokens;
         this.labelTokenHolder = labelTokens;
-        this.schemaStateChangeCallback = schemaStateChangeCallback;
+        this.schemaState = schemaState;
         this.scheduler = scheduler;
         this.lockService = lockService;
         this.databaseHealth = databaseHealth;
@@ -225,10 +226,10 @@ public RecordStorageEngine(
             indexingService = IndexingServiceFactory.createIndexingService( config, scheduler, schemaIndexProviderMap,
                     indexStoreView, tokenNameLookup,
                     Iterators.asList( new SchemaStorage( neoStores.getSchemaStore() ).indexesGetAll() ), logProvider,
-                    indexingServiceMonitor, schemaStateChangeCallback );
+                    indexingServiceMonitor, schemaState );
 
             integrityValidator = new IntegrityValidator( neoStores, indexingService );
-            cacheAccess = new BridgingCacheAccess( schemaCache, schemaStateChangeCallback,
+            cacheAccess = new BridgingCacheAccess( schemaCache, schemaState,
                     propertyKeyTokenHolder, relationshipTypeTokens, labelTokens );
 
             storeStatementSupplier = storeStatementSupplier( neoStores );
@@ -311,8 +312,8 @@ public void createCommands(
                     relationshipCreator, relationshipDeleter, propertyCreator, propertyDeleter );
 
             // Visit transaction state and populate these record state objects
-            TxStateVisitor txStateVisitor = new TransactionToRecordStateVisitor( recordState,
-                    schemaStateChangeCallback, schemaStorage, constraintSemantics, schemaIndexProviderMap );
+            TxStateVisitor txStateVisitor = new TransactionToRecordStateVisitor( recordState, schemaState,
+                    schemaStorage, constraintSemantics, schemaIndexProviderMap );
             CountsRecordState countsRecordState = new CountsRecordState();
             txStateVisitor = constraintSemantics.decorateTxStateVisitor(
                     storeLayer,

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

@@ -33,6 +33,7 @@
 import org.neo4j.kernel.api.schema.constaints.NodeKeyConstraintDescriptor;
 import org.neo4j.kernel.api.schema.constaints.UniquenessConstraintDescriptor;
 import org.neo4j.kernel.api.schema.index.IndexDescriptor;
+import org.neo4j.kernel.impl.api.SchemaState;
 import org.neo4j.kernel.impl.api.index.SchemaIndexProviderMap;
 import org.neo4j.kernel.impl.constraints.ConstraintSemantics;
 import org.neo4j.kernel.impl.store.SchemaStorage;
@@ -45,17 +46,17 @@ public class TransactionToRecordStateVisitor extends TxStateVisitor.Adapter
 {
     private boolean clearSchemaState;
     private final TransactionRecordState recordState;
-    private final Runnable schemaStateChangeCallback;
+    private final SchemaState schemaState;
     private final SchemaStorage schemaStorage;
     private final ConstraintSemantics constraintSemantics;
     private final SchemaIndexProviderMap schemaIndexProviderMap;
 
-    public TransactionToRecordStateVisitor( TransactionRecordState recordState, Runnable schemaStateChangeCallback,
+    public TransactionToRecordStateVisitor( TransactionRecordState recordState, SchemaState schemaState,
                                             SchemaStorage schemaStorage, ConstraintSemantics constraintSemantics,
                                             SchemaIndexProviderMap schemaIndexProviderMap )
     {
         this.recordState = recordState;
-        this.schemaStateChangeCallback = schemaStateChangeCallback;
+        this.schemaState = schemaState;
         this.schemaStorage = schemaStorage;
         this.constraintSemantics = constraintSemantics;
         this.schemaIndexProviderMap = schemaIndexProviderMap;
@@ -68,7 +69,7 @@ public void close()
         {
             if ( clearSchemaState )
             {
-                schemaStateChangeCallback.run();
+                schemaState.clear();
             }
         }
         finally

community/kernel/src/test/java/org/neo4j/kernel/impl/api/index/IndexPopulationJobTest.java

@@ -632,7 +632,7 @@ private IndexPopulationJob newIndexPopulationJob( FailedIndexProxyFactory failur
         flipper.setFlipTarget( mock( IndexProxyFactory.class ) );
 
         MultipleIndexPopulator multiPopulator = new MultipleIndexPopulator( storeView, logProvider );
-        IndexPopulationJob job = new IndexPopulationJob( storeView, multiPopulator, NO_MONITOR, stateHolder::clear );
+        IndexPopulationJob job = new IndexPopulationJob( multiPopulator, NO_MONITOR, stateHolder );
         job.addPopulator( populator, indexId, descriptor, PROVIDER_DESCRIPTOR,
                 format( ":%s(%s)", FIRST.name(), name ), flipper, failureDelegateFactory );
         return job;