diff --git a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/LabelsAcceptanceTest.java b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/LabelsAcceptanceTest.java index 2b3e03e4df314..82e2c868ea943 100644 --- a/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/LabelsAcceptanceTest.java +++ b/community/community-it/kernel-it/src/test/java/org/neo4j/graphdb/LabelsAcceptanceTest.java @@ -39,18 +39,17 @@ import org.neo4j.graphdb.factory.module.CommunityEditionModule; import org.neo4j.graphdb.factory.module.EditionModule; import org.neo4j.graphdb.factory.module.PlatformModule; +import org.neo4j.graphdb.factory.module.id.IdModuleBuilder; import org.neo4j.helpers.collection.Iterables; import org.neo4j.internal.kernel.api.LabelSet; import org.neo4j.internal.kernel.api.NodeCursor; import org.neo4j.internal.kernel.api.PropertyCursor; -import org.neo4j.io.fs.FileSystemAbstraction; import org.neo4j.kernel.api.KernelTransaction; import org.neo4j.kernel.configuration.Config; import org.neo4j.kernel.impl.core.ThreadToStatementContextBridge; import org.neo4j.kernel.impl.factory.DatabaseInfo; import org.neo4j.kernel.impl.store.UnderlyingStorageException; import org.neo4j.kernel.impl.store.id.IdGenerator; -import org.neo4j.kernel.impl.store.id.IdGeneratorFactory; import org.neo4j.kernel.impl.store.id.IdType; import org.neo4j.kernel.impl.store.id.configuration.CommunityIdTypeConfigurationProvider; import org.neo4j.kernel.impl.store.id.configuration.IdTypeConfiguration; @@ -751,15 +750,7 @@ protected void create( GraphDatabaseFacadeFactory.Dependencies dependencies ) { Function factory = - platformModule -> new CommunityEditionModule( platformModule ) - { - @Override - protected Function createIdGeneratorFactory( FileSystemAbstraction fs, - IdTypeConfigurationProvider idTypeConfigurationProvider ) - { - return any -> idFactory; - } - }; + platformModule -> new CommunityEditionModuleWithCustomIdModule( platformModule, idFactory ); new GraphDatabaseFacadeFactory( DatabaseInfo.COMMUNITY, factory ) { @@ -788,4 +779,15 @@ private Node createNode( GraphDatabaseService db, Label... labels ) return node; } } + + private static class CommunityEditionModuleWithCustomIdModule extends CommunityEditionModule + { + CommunityEditionModuleWithCustomIdModule( PlatformModule platformModule, EphemeralIdGenerator.Factory idFactory ) + { + super( platformModule ); + idModule = IdModuleBuilder.of( platformModule.fileSystem, platformModule.jobScheduler ) + .withIdGenerationFactoryProvider( any -> idFactory ) + .build(); + } + } } diff --git a/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/CommunityEditionModule.java b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/CommunityEditionModule.java index c38c399218538..defbc1d4a0dc8 100644 --- a/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/CommunityEditionModule.java +++ b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/CommunityEditionModule.java @@ -20,11 +20,12 @@ package org.neo4j.graphdb.factory.module; import java.io.File; -import java.util.function.Function; import java.util.function.Predicate; import org.neo4j.function.Predicates; import org.neo4j.graphdb.factory.GraphDatabaseSettings; +import org.neo4j.graphdb.factory.module.id.IdModule; +import org.neo4j.graphdb.factory.module.id.IdModuleBuilder; import org.neo4j.internal.kernel.api.exceptions.KernelException; import org.neo4j.io.fs.FileSystemAbstraction; import org.neo4j.io.pagecache.IOLimiter; @@ -56,11 +57,6 @@ 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.store.id.DefaultIdGeneratorFactory; -import org.neo4j.kernel.impl.store.id.IdGeneratorFactory; -import org.neo4j.kernel.impl.store.id.IdReuseEligibility; -import org.neo4j.kernel.impl.store.id.configuration.CommunityIdTypeConfigurationProvider; -import org.neo4j.kernel.impl.store.id.configuration.IdTypeConfigurationProvider; import org.neo4j.kernel.impl.transaction.TransactionHeaderInformationFactory; import org.neo4j.kernel.impl.transaction.log.files.TransactionLogFiles; import org.neo4j.kernel.impl.transaction.state.DataSourceManager; @@ -102,14 +98,11 @@ public CommunityEditionModule( PlatformModule platformModule ) locksSupplier = () -> createLockManager( lockFactory, config, platformModule.clock ); statementLocksFactoryProvider = locks -> createStatementLocksFactory( locks, config, logging ); - idTypeConfigurationProvider = createIdTypeConfigurationProvider( config ); - eligibleForIdReuse = IdReuseEligibility.ALWAYS; threadToTransactionBridge = dependencies.satisfyDependency( new ThreadToStatementContextBridge( getGlobalAvailabilityGuard( platformModule.clock, logging, platformModule.config ) ) ); - createIdComponents( platformModule, dependencies, createIdGeneratorFactory( fileSystem, idTypeConfigurationProvider ) ); - dependencies.satisfyDependency( idGeneratorFactoryProvider ); - dependencies.satisfyDependency( idControllerFactory ); + + idModule = createIdModule( platformModule, fileSystem ); tokenHoldersSupplier = () -> new TokenHolders( new DelegatingTokenHolder( createPropertyKeyCreator( config, dataSourceManager ), TokenHolder.TYPE_PROPERTY_KEY ), @@ -136,6 +129,11 @@ public CommunityEditionModule( PlatformModule platformModule ) publishEditionInfo( dependencies.resolveDependency( UsageData.class ), platformModule.databaseInfo, config ); } + protected IdModule createIdModule( PlatformModule platformModule, FileSystemAbstraction fileSystem ) + { + return IdModuleBuilder.of( fileSystem, platformModule.jobScheduler ).build(); + } + protected Predicate fileWatcherFileNameFilter() { return communityFileWatcherFileNameFilter(); @@ -149,11 +147,6 @@ static Predicate communityFileWatcherFileNameFilter() ); } - protected IdTypeConfigurationProvider createIdTypeConfigurationProvider( Config config ) - { - return new CommunityIdTypeConfigurationProvider(); - } - protected ConstraintSemantics createSchemaRuleVerifier() { return new StandardConstraintSemantics(); @@ -211,12 +204,6 @@ private KernelData createKernelData( FileSystemAbstraction fileSystem, PageCache return life.add( new KernelData( fileSystem, pageCache, storeDir, config, dataSourceManager ) ); } - protected Function createIdGeneratorFactory( FileSystemAbstraction fs, - IdTypeConfigurationProvider idTypeConfigurationProvider ) - { - return databaseName -> new DefaultIdGeneratorFactory( fs, idTypeConfigurationProvider ); - } - protected TransactionHeaderInformationFactory createHeaderInformationFactory() { return TransactionHeaderInformationFactory.DEFAULT; diff --git a/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/EditionModule.java b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/EditionModule.java index d1b06076c594c..6fa39c1424652 100644 --- a/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/EditionModule.java +++ b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/EditionModule.java @@ -21,8 +21,6 @@ import java.io.File; import java.time.Clock; -import java.util.HashMap; -import java.util.Map; import java.util.function.Function; import java.util.function.Predicate; import java.util.function.Supplier; @@ -31,6 +29,7 @@ import org.neo4j.dmbs.database.DefaultDatabaseManager; import org.neo4j.graphdb.facade.GraphDatabaseFacadeFactory; import org.neo4j.graphdb.factory.GraphDatabaseSettings; +import org.neo4j.graphdb.factory.module.id.IdModule; import org.neo4j.helpers.Service; import org.neo4j.internal.kernel.api.exceptions.KernelException; import org.neo4j.io.fs.FileSystemAbstraction; @@ -56,17 +55,9 @@ import org.neo4j.kernel.impl.logging.LogService; import org.neo4j.kernel.impl.proc.ProcedureConfig; 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.transaction.stats.DatabaseTransactionStats; import org.neo4j.kernel.impl.transaction.stats.TransactionCounters; -import org.neo4j.kernel.impl.util.Dependencies; import org.neo4j.kernel.impl.util.DependencySatisfier; import org.neo4j.kernel.impl.util.watcher.DefaultFileDeletionEventListener; import org.neo4j.kernel.impl.util.watcher.DefaultFileSystemWatcherService; @@ -76,7 +67,6 @@ import org.neo4j.scheduler.JobScheduler; import org.neo4j.udc.UsageData; import org.neo4j.udc.UsageDataKeys; -import org.neo4j.util.FeatureToggles; import static org.neo4j.kernel.impl.proc.temporal.TemporalFunction.registerTemporalFunctions; @@ -86,17 +76,7 @@ */ public abstract class EditionModule { - // This resided in RecordStorageEngine prior to 3.3 - private static final boolean safeIdBuffering = FeatureToggles.flag( - EditionModule.class, "safeIdBuffering", true ); - - public Function idGeneratorFactoryProvider; - - public IdTypeConfigurationProvider idTypeConfigurationProvider; - - public Function idControllerFactory; - - public IdReuseEligibility eligibleForIdReuse; + public IdModule idModule; public Supplier tokenHoldersSupplier; @@ -255,49 +235,6 @@ protected NetworkConnectionTracker createConnectionTracker() return NetworkConnectionTracker.NO_OP; } - protected void createIdComponents( PlatformModule platformModule, Dependencies dependencies, - Function idGeneratorFactoryProvider ) - { - Function factoryProvider = idGeneratorFactoryProvider; - if ( safeIdBuffering ) - { - Function bufferingIdGeneratorFactory = new Function() - { - private final Map idGenerators = new HashMap<>(); - - @Override - public BufferingIdGeneratorFactory apply( String databaseName ) - { - return idGenerators.computeIfAbsent( databaseName, - s -> new BufferingIdGeneratorFactory( idGeneratorFactoryProvider.apply( databaseName ), eligibleForIdReuse, - idTypeConfigurationProvider ) ); - } - }; - idControllerFactory = databaseName -> createBufferedIdController( bufferingIdGeneratorFactory.apply( databaseName ), platformModule.jobScheduler ); - factoryProvider = bufferingIdGeneratorFactory; - } - else - { - idControllerFactory = any -> createDefaultIdController(); - } - this.idGeneratorFactoryProvider = factoryProvider; - } - - private BufferedIdController createBufferedIdController( BufferingIdGeneratorFactory idGeneratorFactory, JobScheduler scheduler ) - { - return new BufferedIdController( idGeneratorFactory, scheduler ); - } - - protected DefaultIdController createDefaultIdController() - { - return new DefaultIdController(); - } - - public void createDatabases( DatabaseManager databaseManager, Config config ) - { - databaseManager.createDatabase( config.get( GraphDatabaseSettings.active_database ) ); - } - public DatabaseTransactionStats createTransactionMonitor() { return databaseStatistics; @@ -322,4 +259,9 @@ public DatabaseAvailabilityGuard createDatabaseAvailabilityGuard( String databas { return (DatabaseAvailabilityGuard) getGlobalAvailabilityGuard( clock, logService, config ); } + + public void createDatabases( DatabaseManager databaseManager, Config config ) + { + databaseManager.createDatabase( config.get( GraphDatabaseSettings.active_database ) ); + } } diff --git a/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/ModularDatabaseCreationContext.java b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/ModularDatabaseCreationContext.java index 4e494006799a0..1a5869f49a359 100644 --- a/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/ModularDatabaseCreationContext.java +++ b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/ModularDatabaseCreationContext.java @@ -24,6 +24,7 @@ import org.neo4j.graphdb.DependencyResolver; import org.neo4j.graphdb.factory.GraphDatabaseSettings; +import org.neo4j.graphdb.factory.module.id.DatabaseIdContext; import org.neo4j.index.internal.gbptree.RecoveryCleanupWorkCollector; import org.neo4j.internal.kernel.api.TokenNameLookup; import org.neo4j.io.fs.FileSystemAbstraction; @@ -124,7 +125,9 @@ public class ModularDatabaseCreationContext implements DatabaseCreationContext { this.databaseName = databaseName; this.config = platformModule.config; - this.idGeneratorFactory = editionModule.idGeneratorFactoryProvider.apply( databaseName ); + DatabaseIdContext idContext = editionModule.idModule.createIdContext( databaseName ); + this.idGeneratorFactory = idContext.getIdGeneratorFactory(); + this.idController = idContext.getIdController(); this.databaseLayout = platformModule.storeLayout.databaseLayout( databaseName ); this.logService = platformModule.logging; this.scheduler = platformModule.jobScheduler; @@ -159,7 +162,6 @@ public class ModularDatabaseCreationContext implements DatabaseCreationContext this.accessCapability = editionModule.accessCapability; this.storeCopyCheckPointMutex = new StoreCopyCheckPointMutex(); this.recoveryCleanupWorkCollector = platformModule.recoveryCleanupWorkCollector; - this.idController = editionModule.idControllerFactory.apply( databaseName ); this.databaseInfo = platformModule.databaseInfo; this.versionContextSupplier = platformModule.versionContextSupplier; this.collectionsFactorySupplier = platformModule.collectionsFactorySupplier; diff --git a/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/id/DatabaseIdContext.java b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/id/DatabaseIdContext.java new file mode 100644 index 0000000000000..118833ca5857a --- /dev/null +++ b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/id/DatabaseIdContext.java @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2002-2018 "Neo4j," + * Neo4j Sweden AB [http://neo4j.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 . + */ +package org.neo4j.graphdb.factory.module.id; + +import org.neo4j.kernel.impl.storageengine.impl.recordstorage.id.IdController; +import org.neo4j.kernel.impl.store.id.IdGeneratorFactory; + +public class DatabaseIdContext +{ + private final IdGeneratorFactory idGeneratorFactory; + private final IdController idController; + + DatabaseIdContext( IdGeneratorFactory idGeneratorFactory, IdController idController ) + { + this.idGeneratorFactory = idGeneratorFactory; + this.idController = idController; + } + + public IdGeneratorFactory getIdGeneratorFactory() + { + return idGeneratorFactory; + } + + public IdController getIdController() + { + return idController; + } +} diff --git a/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/id/IdModule.java b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/id/IdModule.java new file mode 100644 index 0000000000000..e3616e88385df --- /dev/null +++ b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/id/IdModule.java @@ -0,0 +1,99 @@ +/* + * Copyright (c) 2002-2018 "Neo4j," + * Neo4j Sweden AB [http://neo4j.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 . + */ +package org.neo4j.graphdb.factory.module.id; + +import java.util.HashMap; +import java.util.Map; +import java.util.function.Function; + +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.scheduler.JobScheduler; +import org.neo4j.util.FeatureToggles; + +public class IdModule +{ + // This resided in RecordStorageEngine prior to 3.3 + private static final boolean ID_BUFFERING_FLAG = FeatureToggles.flag( IdModule.class, "safeIdBuffering", true ); + + private Function idGeneratorFactoryProvider; + private Function idControllerFactory; + + private final IdTypeConfigurationProvider idTypeConfigurationProvider; + private final IdReuseEligibility eligibleForIdReuse; + + IdModule( JobScheduler jobScheduler, Function idFactoryProvider, + IdTypeConfigurationProvider idTypeConfigurationProvider, IdReuseEligibility eligibleForIdReuse, boolean useIdBuffering ) + { + this.idTypeConfigurationProvider = idTypeConfigurationProvider; + this.eligibleForIdReuse = eligibleForIdReuse; + createIdComponents( jobScheduler, idFactoryProvider, useIdBuffering ); + } + + private void createIdComponents( JobScheduler jobScheduler, + Function idGeneratorFactoryProvider, boolean idBuffering ) + { + Function factoryProvider = idGeneratorFactoryProvider; + if ( ID_BUFFERING_FLAG && idBuffering ) + { + Function bufferingIdGeneratorFactory = new Function() + { + private final Map idGenerators = new HashMap<>(); + + @Override + public BufferingIdGeneratorFactory apply( String databaseName ) + { + return idGenerators.computeIfAbsent( databaseName, + s -> new BufferingIdGeneratorFactory( idGeneratorFactoryProvider.apply( databaseName ), eligibleForIdReuse, + idTypeConfigurationProvider ) ); + } + }; + idControllerFactory = databaseName -> createBufferedIdController( bufferingIdGeneratorFactory.apply( databaseName ), jobScheduler ); + factoryProvider = bufferingIdGeneratorFactory; + } + else + { + idControllerFactory = any -> createDefaultIdController(); + } + this.idGeneratorFactoryProvider = factoryProvider; + } + + private static BufferedIdController createBufferedIdController( BufferingIdGeneratorFactory idGeneratorFactory, JobScheduler scheduler ) + { + return new BufferedIdController( idGeneratorFactory, scheduler ); + } + + private static DefaultIdController createDefaultIdController() + { + return new DefaultIdController(); + } + + public DatabaseIdContext createIdContext( String databaseName ) + { + IdGeneratorFactory generatorFactory = idGeneratorFactoryProvider.apply( databaseName ); + IdController idController = idControllerFactory.apply( databaseName ); + return new DatabaseIdContext( generatorFactory, idController ); + } +} diff --git a/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/id/IdModuleBuilder.java b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/id/IdModuleBuilder.java new file mode 100644 index 0000000000000..1e9bd680a9e49 --- /dev/null +++ b/community/neo4j/src/main/java/org/neo4j/graphdb/factory/module/id/IdModuleBuilder.java @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2002-2018 "Neo4j," + * Neo4j Sweden AB [http://neo4j.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 . + */ +package org.neo4j.graphdb.factory.module.id; + +import java.util.function.Function; + +import org.neo4j.io.fs.FileSystemAbstraction; +import org.neo4j.kernel.impl.store.id.DefaultIdGeneratorFactory; +import org.neo4j.kernel.impl.store.id.IdGeneratorFactory; +import org.neo4j.kernel.impl.store.id.IdReuseEligibility; +import org.neo4j.kernel.impl.store.id.configuration.CommunityIdTypeConfigurationProvider; +import org.neo4j.kernel.impl.store.id.configuration.IdTypeConfigurationProvider; +import org.neo4j.scheduler.JobScheduler; + +public class IdModuleBuilder +{ + private IdReuseEligibility idReuseEligibility = IdReuseEligibility.ALWAYS; + private FileSystemAbstraction fileSystemAbstraction; + private JobScheduler jobScheduler; + private IdTypeConfigurationProvider idTypeConfigurationProvider; + private Function idGeneratorFactoryProvider; + + public static IdModuleBuilder of( IdTypeConfigurationProvider configurationProvider ) + { + IdModuleBuilder builder = new IdModuleBuilder(); + builder.idTypeConfigurationProvider = configurationProvider; + return builder; + } + + public static IdModuleBuilder of( FileSystemAbstraction fileSystemAbstraction, JobScheduler jobScheduler ) + { + IdModuleBuilder builder = new IdModuleBuilder(); + builder.fileSystemAbstraction = fileSystemAbstraction; + builder.jobScheduler = jobScheduler; + return builder; + } + + public IdModuleBuilder withFileSystem( FileSystemAbstraction fileSystem ) + { + this.fileSystemAbstraction = fileSystem; + return this; + } + + public IdModuleBuilder withJobScheduler( JobScheduler jobScheduler ) + { + this.jobScheduler = jobScheduler; + return this; + } + + public IdModuleBuilder withIdReuseEligibility( IdReuseEligibility eligibleForIdReuse ) + { + this.idReuseEligibility = eligibleForIdReuse; + return this; + } + + public IdModuleBuilder withIdGenerationFactoryProvider( Function idGeneratorFactoryProvider ) + { + this.idGeneratorFactoryProvider = idGeneratorFactoryProvider; + return this; + } + + public IdModule build() + { + if ( idGeneratorFactoryProvider == null ) + { + idGeneratorFactoryProvider = databaseName -> new DefaultIdGeneratorFactory( fileSystemAbstraction, idTypeConfigurationProvider ); + } + if ( idTypeConfigurationProvider == null ) + { + idTypeConfigurationProvider = new CommunityIdTypeConfigurationProvider(); + } + // todo pass id buffering + return new IdModule( jobScheduler, idGeneratorFactoryProvider, idTypeConfigurationProvider, idReuseEligibility, true ); + } +} diff --git a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/EnterpriseCoreEditionModule.java b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/EnterpriseCoreEditionModule.java index ce10972853a19..ec3b5abfcda76 100644 --- a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/EnterpriseCoreEditionModule.java +++ b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/EnterpriseCoreEditionModule.java @@ -29,7 +29,6 @@ import java.io.PrintWriter; import java.time.Duration; import java.util.Collection; -import java.util.function.Function; import java.util.function.Predicate; import java.util.function.Supplier; import java.util.stream.Stream; @@ -98,6 +97,7 @@ import org.neo4j.graphdb.factory.GraphDatabaseSettings; import org.neo4j.graphdb.factory.module.EditionModule; import org.neo4j.graphdb.factory.module.PlatformModule; +import org.neo4j.graphdb.factory.module.id.IdModuleBuilder; import org.neo4j.helpers.AdvertisedSocketAddress; import org.neo4j.helpers.SocketAddress; import org.neo4j.helpers.collection.Pair; @@ -124,8 +124,6 @@ import org.neo4j.kernel.impl.net.DefaultNetworkConnectionTracker; import org.neo4j.kernel.impl.pagecache.PageCacheWarmer; import org.neo4j.kernel.impl.proc.Procedures; -import org.neo4j.kernel.impl.store.id.IdGeneratorFactory; -import org.neo4j.kernel.impl.store.id.IdReuseEligibility; import org.neo4j.kernel.impl.transaction.TransactionHeaderInformationFactory; import org.neo4j.kernel.impl.transaction.log.files.LogFiles; import org.neo4j.kernel.impl.transaction.log.files.LogFilesBuilder; @@ -225,7 +223,6 @@ public EnterpriseCoreEditionModule( final PlatformModule platformModule, } dependencies.satisfyDependency( clusterStateDirectory ); - eligibleForIdReuse = IdReuseEligibility.ALWAYS; AvailabilityGuard globalGuard = getGlobalAvailabilityGuard( platformModule.clock, logging, platformModule.config ); threadToTransactionBridge = dependencies.satisfyDependency( new ThreadToStatementContextBridge( globalGuard ) ); @@ -307,11 +304,12 @@ public EnterpriseCoreEditionModule( final PlatformModule platformModule, platformModule, clusterStateDirectory.get(), config, replicationModule.getReplicator(), consensusModule.raftMachine(), dependencies, localDatabase ); - this.idTypeConfigurationProvider = coreStateMachinesModule.idTypeConfigurationProvider; - - createIdComponents( platformModule, dependencies, any -> coreStateMachinesModule.idGeneratorFactory ); - dependencies.satisfyDependency( idGeneratorFactoryProvider ); - dependencies.satisfyDependency( idControllerFactory ); + idModule = IdModuleBuilder.of( coreStateMachinesModule.idTypeConfigurationProvider ) + .withJobScheduler( platformModule.jobScheduler ) + .withIdGenerationFactoryProvider( any -> + new FreeIdFilteredIdGeneratorFactory( coreStateMachinesModule.idGeneratorFactory, + coreStateMachinesModule.freeIdCondition ) ) + .build(); // TODO: this is broken, coreStateMachinesModule.tokenHolders should be supplier, somehow... this.tokenHoldersSupplier = () -> coreStateMachinesModule.tokenHolders; @@ -383,15 +381,6 @@ protected DuplexPipelineWrapperFactory pipelineWrapperFactory() return new VoidPipelineWrapperFactory(); } - @Override - protected void createIdComponents( PlatformModule platformModule, Dependencies dependencies, - Function editionIdGeneratorFactory ) - { - super.createIdComponents( platformModule, dependencies, editionIdGeneratorFactory ); - this.idGeneratorFactoryProvider = databaseName -> new FreeIdFilteredIdGeneratorFactory( this.idGeneratorFactoryProvider.apply( databaseName ), - coreStateMachinesModule.freeIdCondition ); - } - static Predicate fileWatcherFileNameFilter() { return Predicates.any( diff --git a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/readreplica/EnterpriseReadReplicaEditionModule.java b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/readreplica/EnterpriseReadReplicaEditionModule.java index a8a2eb268c3c4..8623375805253 100644 --- a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/readreplica/EnterpriseReadReplicaEditionModule.java +++ b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/readreplica/EnterpriseReadReplicaEditionModule.java @@ -90,6 +90,7 @@ import org.neo4j.graphdb.factory.GraphDatabaseSettings; import org.neo4j.graphdb.factory.module.EditionModule; import org.neo4j.graphdb.factory.module.PlatformModule; +import org.neo4j.graphdb.factory.module.id.IdModuleBuilder; import org.neo4j.internal.kernel.api.exceptions.KernelException; import org.neo4j.io.fs.FileSystemAbstraction; import org.neo4j.io.layout.DatabaseLayout; @@ -120,8 +121,6 @@ import org.neo4j.kernel.impl.net.DefaultNetworkConnectionTracker; import org.neo4j.kernel.impl.pagecache.PageCacheWarmer; import org.neo4j.kernel.impl.proc.Procedures; -import org.neo4j.kernel.impl.store.id.DefaultIdGeneratorFactory; -import org.neo4j.kernel.impl.store.id.IdReuseEligibility; import org.neo4j.kernel.impl.transaction.TransactionHeaderInformationFactory; import org.neo4j.kernel.impl.transaction.log.TransactionAppender; import org.neo4j.kernel.impl.transaction.log.TransactionIdStore; @@ -167,8 +166,6 @@ public EnterpriseReadReplicaEditionModule( final PlatformModule platformModule, LifeSupport life = platformModule.life; - eligibleForIdReuse = IdReuseEligibility.ALWAYS; - threadToTransactionBridge = dependencies.satisfyDependency( new ThreadToStatementContextBridge( getGlobalAvailabilityGuard( platformModule.clock, logging, platformModule.config ) ) ); this.accessCapability = new ReadOnly(); @@ -181,9 +178,10 @@ public EnterpriseReadReplicaEditionModule( final PlatformModule platformModule, locksSupplier = () -> emptyLockManager; statementLocksFactoryProvider = locks -> new StatementLocksFactorySelector( locks, config, logging ).select(); - idTypeConfigurationProvider = new EnterpriseIdTypeConfigurationProvider( config ); - idGeneratorFactoryProvider = databaseName -> new DefaultIdGeneratorFactory( fileSystem, idTypeConfigurationProvider ); - idControllerFactory = databaseName -> createDefaultIdController(); + idModule = IdModuleBuilder.of( new EnterpriseIdTypeConfigurationProvider( config ) ) + .withFileSystem( fileSystem ) + .withJobScheduler( platformModule.jobScheduler ) + .build(); tokenHoldersSupplier = () -> new TokenHolders( new DelegatingTokenHolder( new ReadOnlyTokenCreator(), TokenHolder.TYPE_PROPERTY_KEY ), diff --git a/enterprise/ha/src/main/java/org/neo4j/kernel/ha/factory/HighlyAvailableEditionModule.java b/enterprise/ha/src/main/java/org/neo4j/kernel/ha/factory/HighlyAvailableEditionModule.java index 8db5afb1e7959..386c2f34310b7 100644 --- a/enterprise/ha/src/main/java/org/neo4j/kernel/ha/factory/HighlyAvailableEditionModule.java +++ b/enterprise/ha/src/main/java/org/neo4j/kernel/ha/factory/HighlyAvailableEditionModule.java @@ -63,6 +63,8 @@ import org.neo4j.graphdb.factory.GraphDatabaseSettings; import org.neo4j.graphdb.factory.module.EditionModule; import org.neo4j.graphdb.factory.module.PlatformModule; +import org.neo4j.graphdb.factory.module.id.DatabaseIdContext; +import org.neo4j.graphdb.factory.module.id.IdModuleBuilder; import org.neo4j.helpers.HostnamePort; import org.neo4j.helpers.NamedThreadFactory; import org.neo4j.internal.diagnostics.DiagnosticsManager; @@ -166,6 +168,7 @@ import org.neo4j.kernel.impl.store.MetaDataStore; import org.neo4j.kernel.impl.store.TransactionId; import org.neo4j.kernel.impl.store.id.IdGeneratorFactory; +import org.neo4j.kernel.impl.store.id.configuration.IdTypeConfigurationProvider; import org.neo4j.kernel.impl.transaction.TransactionHeaderInformationFactory; import org.neo4j.kernel.impl.transaction.log.LogicalTransactionStore; import org.neo4j.kernel.impl.transaction.log.NoSuchTransactionException; @@ -222,8 +225,6 @@ public HighlyAvailableEditionModule( final PlatformModule platformModule ) this.accessCapability = config.get( GraphDatabaseSettings.read_only ) ? new ReadOnly() : new CanWrite(); - idTypeConfigurationProvider = new EnterpriseIdTypeConfigurationProvider( config ); - watcherServiceFactory = dir -> createFileSystemWatcherService( platformModule.fileSystem, dir, logging, platformModule.jobScheduler, config, fileWatcherFileNameFilter() ); @@ -376,10 +377,17 @@ public void elected( String role, InstanceId instanceId, URI electedMember ) paxosLife.add( (Lifecycle)clusterEvents ); paxosLife.add( localClusterMemberAvailability ); + EnterpriseIdTypeConfigurationProvider idTypeConfigurationProvider = new EnterpriseIdTypeConfigurationProvider( config ); HaIdGeneratorFactory editionIdGeneratorFactory = (HaIdGeneratorFactory) createIdGeneratorFactory( masterDelegateInvocationHandler, - logging.getInternalLogProvider(), requestContextFactory, fs ); - eligibleForIdReuse = new HaIdReuseEligibility( members, platformModule.clock, idReuseSafeZone ); - createIdComponents( platformModule, dependencies, any -> editionIdGeneratorFactory ); + logging.getInternalLogProvider(), requestContextFactory, fs, idTypeConfigurationProvider ); + HaIdReuseEligibility eligibleForIdReuse = new HaIdReuseEligibility( members, platformModule.clock, idReuseSafeZone ); + idModule = IdModuleBuilder.of( idTypeConfigurationProvider ) + .withJobScheduler( platformModule.jobScheduler ) + .withFileSystem( fs ) + .withIdGenerationFactoryProvider( any -> editionIdGeneratorFactory ) + .withIdReuseEligibility( eligibleForIdReuse ) + .build(); + DatabaseIdContext idContext = idModule.createIdContext( config.get( GraphDatabaseSettings.active_database ) ); // TODO There's a cyclical dependency here that should be fixed final AtomicReference exceptionHandlerRef = new AtomicReference<>(); @@ -430,7 +438,7 @@ public void elected( String role, InstanceId instanceId, URI electedMember ) final Factory masterSPIFactory = () -> new DefaultMasterImplSPI( resolveDatabaseDependency( platformModule, GraphDatabaseFacade.class ), platformModule.fileSystem, platformModule.monitors, - tokenHolders, this.idGeneratorFactoryProvider.apply( DatabaseManager.DEFAULT_DATABASE_NAME ), + tokenHolders, idContext.getIdGeneratorFactory(), resolveDatabaseDependency( platformModule, TransactionCommitProcess.class ), resolveDatabaseDependency( platformModule, CheckPointer.class ), resolveDatabaseDependency( platformModule, TransactionIdStore.class ), @@ -672,11 +680,12 @@ private static CommitProcessFactory createCommitProcessFactory( Dependencies dep return new HighlyAvailableCommitProcessFactory( commitProcessDelegate ); } - private IdGeneratorFactory createIdGeneratorFactory( + private static IdGeneratorFactory createIdGeneratorFactory( DelegateInvocationHandler masterDelegateInvocationHandler, LogProvider logging, RequestContextFactory requestContextFactory, - FileSystemAbstraction fs ) + FileSystemAbstraction fs, + IdTypeConfigurationProvider idTypeConfigurationProvider ) { HaIdGeneratorFactory idGeneratorFactory = new HaIdGeneratorFactory( masterDelegateInvocationHandler, logging, requestContextFactory, fs, idTypeConfigurationProvider ); diff --git a/enterprise/kernel/src/main/java/org/neo4j/kernel/impl/enterprise/EnterpriseEditionModule.java b/enterprise/kernel/src/main/java/org/neo4j/kernel/impl/enterprise/EnterpriseEditionModule.java index fbbc14fd6916a..e34bc48557bae 100644 --- a/enterprise/kernel/src/main/java/org/neo4j/kernel/impl/enterprise/EnterpriseEditionModule.java +++ b/enterprise/kernel/src/main/java/org/neo4j/kernel/impl/enterprise/EnterpriseEditionModule.java @@ -29,7 +29,10 @@ import org.neo4j.graphdb.factory.module.CommunityEditionModule; import org.neo4j.graphdb.factory.module.EditionModule; import org.neo4j.graphdb.factory.module.PlatformModule; +import org.neo4j.graphdb.factory.module.id.IdModule; +import org.neo4j.graphdb.factory.module.id.IdModuleBuilder; import org.neo4j.internal.kernel.api.exceptions.KernelException; +import org.neo4j.io.fs.FileSystemAbstraction; import org.neo4j.kernel.api.net.NetworkConnectionTracker; import org.neo4j.kernel.api.security.SecurityModule; import org.neo4j.kernel.api.security.UserManagerSupplier; @@ -49,7 +52,6 @@ import org.neo4j.kernel.impl.net.DefaultNetworkConnectionTracker; import org.neo4j.kernel.impl.pagecache.PageCacheWarmer; import org.neo4j.kernel.impl.proc.Procedures; -import org.neo4j.kernel.impl.store.id.configuration.IdTypeConfigurationProvider; import org.neo4j.kernel.impl.transaction.log.files.TransactionLogFiles; /** @@ -71,6 +73,15 @@ public EnterpriseEditionModule( PlatformModule platformModule ) ioLimiter = new ConfigurableIOLimiter( platformModule.config ); } + @Override + protected IdModule createIdModule( PlatformModule platformModule, FileSystemAbstraction fileSystem ) + { + return IdModuleBuilder.of( new EnterpriseIdTypeConfigurationProvider( platformModule.config ) ) + .withFileSystem( fileSystem ) + .withJobScheduler( platformModule.jobScheduler ) + .build(); + } + @Override protected Predicate fileWatcherFileNameFilter() { @@ -86,12 +97,6 @@ static Predicate enterpriseNonClusterFileWatcherFileNameFilter() ); } - @Override - protected IdTypeConfigurationProvider createIdTypeConfigurationProvider( Config config ) - { - return new EnterpriseIdTypeConfigurationProvider( config ); - } - @Override protected ConstraintSemantics createSchemaRuleVerifier() { diff --git a/integrationtests/src/test/java/org/neo4j/TransactionGuardIT.java b/integrationtests/src/test/java/org/neo4j/TransactionGuardIT.java index 77a40e44837c9..35260c630945c 100644 --- a/integrationtests/src/test/java/org/neo4j/TransactionGuardIT.java +++ b/integrationtests/src/test/java/org/neo4j/TransactionGuardIT.java @@ -56,6 +56,9 @@ import org.neo4j.graphdb.factory.GraphDatabaseSettings; import org.neo4j.graphdb.factory.module.EditionModule; import org.neo4j.graphdb.factory.module.PlatformModule; +import org.neo4j.graphdb.factory.module.id.DatabaseIdContext; +import org.neo4j.graphdb.factory.module.id.IdModule; +import org.neo4j.graphdb.factory.module.id.IdModuleBuilder; import org.neo4j.helpers.collection.MapUtil; import org.neo4j.io.fs.FileSystemAbstraction; import org.neo4j.io.fs.FileUtils; @@ -67,13 +70,13 @@ import org.neo4j.kernel.configuration.Settings; import org.neo4j.kernel.impl.api.KernelTransactionTimeoutMonitor; import org.neo4j.kernel.impl.enterprise.EnterpriseEditionModule; +import org.neo4j.kernel.impl.enterprise.id.EnterpriseIdTypeConfigurationProvider; import org.neo4j.kernel.impl.factory.DatabaseInfo; import org.neo4j.kernel.impl.factory.GraphDatabaseFacade; import org.neo4j.kernel.impl.store.id.IdGenerator; import org.neo4j.kernel.impl.store.id.IdGeneratorFactory; import org.neo4j.kernel.impl.store.id.IdRange; import org.neo4j.kernel.impl.store.id.IdType; -import org.neo4j.kernel.impl.store.id.configuration.IdTypeConfigurationProvider; import org.neo4j.kernel.internal.GraphDatabaseAPI; import org.neo4j.logging.LogProvider; import org.neo4j.logging.NullLogProvider; @@ -721,10 +724,13 @@ private class TransactionGuardTerminationEditionModule extends EnterpriseEdition } @Override - protected Function createIdGeneratorFactory( FileSystemAbstraction fs, - IdTypeConfigurationProvider idTypeConfigurationProvider ) + protected IdModule createIdModule( PlatformModule platformModule, FileSystemAbstraction fileSystem ) { - return databaseName -> new TerminationIdGeneratorFactory( super.createIdGeneratorFactory( fs, idTypeConfigurationProvider ).apply( databaseName ) ); + DatabaseIdContext idContext = + super.createIdModule( platformModule, fileSystem ).createIdContext( platformModule.config.get( GraphDatabaseSettings.active_database ) ); + return IdModuleBuilder.of( new EnterpriseIdTypeConfigurationProvider( platformModule.config ) ) + .withIdGenerationFactoryProvider( any -> new TerminationIdGeneratorFactory( idContext.getIdGeneratorFactory() ) ) + .build(); } }