diff --git a/community/kernel/src/main/java/org/neo4j/kernel/NeoStoreDataSource.java b/community/kernel/src/main/java/org/neo4j/kernel/NeoStoreDataSource.java index 409004c936279..85893223e3251 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/NeoStoreDataSource.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/NeoStoreDataSource.java @@ -23,9 +23,7 @@ import java.io.IOException; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; -import java.util.Collections; import java.util.HashMap; -import java.util.List; import java.util.Map; import java.util.Properties; import java.util.concurrent.TimeUnit; @@ -33,7 +31,6 @@ import java.util.concurrent.locks.LockSupport; import java.util.function.Supplier; -import org.neo4j.function.Factory; import org.neo4j.graphdb.DependencyResolver; import org.neo4j.graphdb.ResourceIterator; import org.neo4j.graphdb.config.Setting; @@ -71,22 +68,14 @@ import org.neo4j.kernel.impl.api.TransactionHooks; import org.neo4j.kernel.impl.api.TransactionRepresentationStoreApplier; import org.neo4j.kernel.impl.api.UpdateableSchemaState; -import org.neo4j.kernel.impl.api.index.IndexUpdateMode; import org.neo4j.kernel.impl.api.index.IndexUpdatesValidator; import org.neo4j.kernel.impl.api.index.IndexingService; -import org.neo4j.kernel.impl.api.index.OnlineIndexUpdatesValidator; import org.neo4j.kernel.impl.api.index.RecoveryIndexingUpdatesValidator; import org.neo4j.kernel.impl.api.index.SchemaIndexProviderMap; -import org.neo4j.kernel.impl.api.index.sampling.IndexSamplingConfig; import org.neo4j.kernel.impl.api.scan.LabelScanStoreProvider; import org.neo4j.kernel.impl.api.state.ConstraintIndexCreator; -import org.neo4j.kernel.impl.api.store.CacheLayer; -import org.neo4j.kernel.impl.api.store.DiskLayer; import org.neo4j.kernel.impl.api.store.ProcedureCache; -import org.neo4j.kernel.impl.api.store.SchemaCache; import org.neo4j.kernel.impl.api.store.StoreReadLayer; -import org.neo4j.kernel.impl.api.store.StoreStatement; -import org.neo4j.kernel.impl.cache.BridgingCacheAccess; import org.neo4j.kernel.impl.constraints.ConstraintSemantics; import org.neo4j.kernel.impl.core.CacheAccessBackDoor; import org.neo4j.kernel.impl.core.LabelTokenHolder; @@ -100,13 +89,12 @@ 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.storageengine.StorageEngine; +import org.neo4j.kernel.impl.storageengine.impl.recordstorage.RecordStorageEngine; import org.neo4j.kernel.impl.store.MetaDataStore; import org.neo4j.kernel.impl.store.NeoStores; -import org.neo4j.kernel.impl.store.SchemaStorage; -import org.neo4j.kernel.impl.store.StoreFactory; import org.neo4j.kernel.impl.store.StoreId; import org.neo4j.kernel.impl.store.UnderlyingStorageException; -import org.neo4j.kernel.impl.store.record.SchemaRule; import org.neo4j.kernel.impl.storemigration.StoreUpgrader; import org.neo4j.kernel.impl.storemigration.StoreVersionCheck; import org.neo4j.kernel.impl.storemigration.UpgradableDatabase; @@ -148,13 +136,10 @@ import org.neo4j.kernel.impl.transaction.log.rotation.LogRotation; import org.neo4j.kernel.impl.transaction.log.rotation.LogRotationImpl; import org.neo4j.kernel.impl.transaction.log.rotation.StoreFlusher; -import org.neo4j.kernel.impl.transaction.state.DefaultSchemaIndexProviderMap; import org.neo4j.kernel.impl.transaction.state.IntegrityValidator; import org.neo4j.kernel.impl.transaction.state.NeoStoreFileListing; -import org.neo4j.kernel.impl.transaction.state.NeoStoreIndexStoreView; import org.neo4j.kernel.impl.transaction.state.NeoStoreTransactionContextFactory; import org.neo4j.kernel.impl.transaction.state.NeoStoresSupplier; -import org.neo4j.kernel.impl.transaction.state.PropertyLoader; import org.neo4j.kernel.impl.transaction.state.RecoveryVisitor; import org.neo4j.kernel.impl.util.Dependencies; import org.neo4j.kernel.impl.util.IdOrderingQueue; @@ -177,11 +162,6 @@ import org.neo4j.logging.Logger; import org.neo4j.unsafe.batchinsert.LabelScanWriter; -import static org.neo4j.helpers.Settings.BOOLEAN; -import static org.neo4j.helpers.Settings.TRUE; -import static org.neo4j.helpers.Settings.setting; -import static org.neo4j.helpers.collection.Iterables.toList; -import static org.neo4j.kernel.impl.locking.LockService.NO_LOCK_SERVICE; import static org.neo4j.kernel.impl.transaction.log.pruning.LogPruneStrategyFactory.fromConfigValue; public class NeoStoreDataSource implements NeoStoresSupplier, Lifecycle, IndexProviders @@ -191,9 +171,8 @@ private interface CacheModule UpdateableSchemaState updateableSchemaState(); } - private interface StoreLayerModule + private interface StoreLayerModule extends StorageEngine { - StoreReadLayer storeLayer(); NeoStores neoStores(); MetaDataStore metaDataStore(); @@ -327,12 +306,6 @@ boolean applicable( DiagnosticsPhase phase ) public static final String DEFAULT_DATA_SOURCE_NAME = "nioneodb"; - /** - * This setting is hidden to the user and is here merely for making it easier to back out of - * a change where reading property chains incurs read locks on {@link LockService}. - */ - private static final Setting use_read_locks_on_property_reads = - setting( "experimental.use_read_locks_on_property_reads", BOOLEAN, TRUE ); private final Monitors monitors; private final Tracers tracers; @@ -375,7 +348,6 @@ boolean applicable( DiagnosticsPhase phase ) private File storeDir; private boolean readOnly; - private CacheModule cacheModule; private StoreLayerModule storeLayerModule; private TransactionLogModule transactionLogModule; private KernelModule kernelModule; @@ -510,12 +482,12 @@ public void start() throws IOException LegacyIndexApplierLookup legacyIndexApplierLookup = dependencies.satisfyDependency( new LegacyIndexApplierLookup.Direct( legacyIndexProviderLookup ) ); - CacheModule cacheModule = buildCaches(); + UpdateableSchemaState updateableSchemaState = new KernelSchemaStateStore( logProvider ); // TODO Introduce a StorageEngine abstraction at the StoreLayerModule boundary storeLayerModule = buildStoreLayer( propertyKeyTokenHolder, labelTokens, relationshipTypeTokens, - cacheModule.updateableSchemaState()::clear ); + updateableSchemaState::clear ); TransactionLogModule transactionLogModule = buildTransactionLogs( storeDir, config, logProvider, scheduler, storeLayerModule.labelScanStore(), @@ -532,20 +504,29 @@ public void start() throws IOException transactionLogModule.transactionAppender(), storeLayerModule.neoStores(), transactionLogModule.storeApplier(), storeLayerModule.indexingService(), storeLayerModule.indexUpdatesValidator(), - storeLayerModule.storeLayer(), - cacheModule.updateableSchemaState(), storeLayerModule.labelScanStore(), + storeLayerModule.storeReadLayer(), + updateableSchemaState, storeLayerModule.labelScanStore(), storeLayerModule.schemaIndexProviderMap(), storeLayerModule.procedureCache() ); // Do these assignments last so that we can ensure no cyclical dependencies exist - this.cacheModule = cacheModule; this.storeLayerModule = storeLayerModule; this.transactionLogModule = transactionLogModule; this.kernelModule = kernelModule; dependencies.satisfyDependency( this ); - satisfyDependencies( cacheModule, storeLayerModule, transactionLogModule, - kernelModule ); + dependencies.satisfyDependency( updateableSchemaState ); + dependencies.satisfyDependencies( storeLayerModule.cacheAccess() ); + dependencies.satisfyDependencies( storeLayerModule.indexingService() ); + dependencies.satisfyDependencies( storeLayerModule.indexUpdatesValidator() ); + dependencies.satisfyDependencies( storeLayerModule.integrityValidator() ); + dependencies.satisfyDependencies( storeLayerModule.labelScanStore() ); + dependencies.satisfyDependencies( storeLayerModule.metaDataStore() ); + dependencies.satisfyDependencies( storeLayerModule.neoStores() ); + dependencies.satisfyDependencies( storeLayerModule.procedureCache() ); + dependencies.satisfyDependencies( storeLayerModule.schemaIndexProviderMap() ); + dependencies.satisfyDependencies( storeLayerModule.storeReadLayer() ); + satisfyDependencies( transactionLogModule, kernelModule ); } catch ( Throwable e ) { @@ -609,101 +590,30 @@ private void upgradeStore( File storeDir, StoreUpgrader storeMigrationProcess, S storeMigrationProcess.migrateIfNeeded( storeDir, upgradableDatabase, indexProvider ); } - private CacheModule buildCaches() - { - final UpdateableSchemaState updateableSchemaState = new KernelSchemaStateStore( logProvider ); - - return new CacheModule() - { - @Override - public UpdateableSchemaState updateableSchemaState() - { - return updateableSchemaState; - } - }; - } - private StoreLayerModule buildStoreLayer( PropertyKeyTokenHolder propertyKeyTokenHolder, LabelTokenHolder labelTokens, RelationshipTypeTokenHolder relationshipTypeTokens, Runnable schemaStateChangeCallback ) { - life.add( new LifecycleAdapter() - { - @Override - public void start() throws IOException - { - storeLayerModule.neoStores().makeStoreOk(); - - propertyKeyTokenHolder.setInitialTokens( - storeLayerModule.neoStores().getPropertyKeyTokenStore().getTokens( Integer.MAX_VALUE ) ); - relationshipTypeTokens.setInitialTokens( - storeLayerModule.neoStores().getRelationshipTypeTokenStore().getTokens( Integer.MAX_VALUE ) ); - labelTokens.setInitialTokens( - storeLayerModule.neoStores().getLabelTokenStore().getTokens( Integer.MAX_VALUE ) ); - - storeLayerModule.neoStores().rebuildCountStoreIfNeeded(); // TODO: move this to counts store lifecycle - storeLayerModule.loadSchemaCache(); - } - } ); - - final StoreFactory storeFactory = new StoreFactory( storeDir, config, idGeneratorFactory, pageCache, fs, logProvider ); - final NeoStores neoStores = storeFactory.openAllNeoStores( true ); - - final DefaultSchemaIndexProviderMap providerMap; - final IndexingService indexingService; - final IntegrityValidator integrityValidator; - final IndexUpdatesValidator indexUpdatesValidator; - final LabelScanStore labelScanStore; - final SchemaCache schemaCache; - final CacheAccessBackDoor cacheAccess; - final StoreReadLayer storeLayer; - final ProcedureCache procedureCache; - - try - { - providerMap = new DefaultSchemaIndexProviderMap( indexProvider ); - - indexingService = IndexingService.create( - new IndexSamplingConfig( config ), scheduler, providerMap, - new NeoStoreIndexStoreView( lockService, neoStores ), tokenNameLookup, - toList( new SchemaStorage( neoStores.getSchemaStore() ).allIndexRules() ), logProvider, - indexingServiceMonitor, schemaStateChangeCallback ); - integrityValidator = new IntegrityValidator( neoStores, indexingService ); - - indexUpdatesValidator = dependencies.satisfyDependency( - new OnlineIndexUpdatesValidator( neoStores, kernelHealth, new PropertyLoader( neoStores ), - indexingService, IndexUpdateMode.ONLINE ) ); - - // TODO Move to constructor - labelScanStore = dependencyResolver.resolveDependency( LabelScanStoreProvider.class, - LabelScanStoreProvider.HIGHEST_PRIORITIZED ).getLabelScanStore(); - - life.add( indexingService ); - life.add( labelScanStore ); - - - schemaCache = new SchemaCache( constraintSemantics, Collections.emptyList() ); - cacheAccess = new BridgingCacheAccess( schemaCache, schemaStateChangeCallback, - propertyKeyTokenHolder, relationshipTypeTokens, labelTokens ); - procedureCache = new ProcedureCache(); - SchemaStorage schemaStorage = new SchemaStorage( neoStores.getSchemaStore() ); - DiskLayer diskLayer = new DiskLayer( propertyKeyTokenHolder, labelTokens, relationshipTypeTokens, schemaStorage, - neoStores, indexingService, storeStatementFactory( neoStores ) ); - storeLayer = new CacheLayer( diskLayer, schemaCache, procedureCache ); - } - catch ( Throwable failure ) + class Module extends RecordStorageEngine implements StoreLayerModule { - neoStores.close(); - throw failure; - } - - return new StoreLayerModule() - { - @Override - public StoreReadLayer storeLayer() + public Module( File storeDir, Config config, IdGeneratorFactory idGeneratorFactory, + PageCache pageCache, FileSystemAbstraction fs, LogProvider logProvider, + PropertyKeyTokenHolder propertyKeyTokenHolder, + LabelTokenHolder labelTokens, + RelationshipTypeTokenHolder relationshipTypeTokens, + Runnable schemaStateChangeCallback, + ConstraintSemantics constraintSemantics, JobScheduler scheduler, + TokenNameLookup tokenNameLookup, LockService lockService, + SchemaIndexProvider indexProvider, + IndexingService.Monitor indexingServiceMonitor, KernelHealth kernelHealth, + LabelScanStoreProvider labelScanStoreProvider ) { - return storeLayer; + super( storeDir, config, idGeneratorFactory, pageCache, fs, logProvider, propertyKeyTokenHolder, + labelTokens, + relationshipTypeTokens, schemaStateChangeCallback, constraintSemantics, scheduler, + tokenNameLookup, + lockService, indexProvider, indexingServiceMonitor, kernelHealth, labelScanStoreProvider ); } @Override @@ -759,21 +669,15 @@ public ProcedureCache procedureCache() { return procedureCache; } + } - @Override - public void loadSchemaCache() - { - List schemaRules = toList( neoStores.getSchemaStore().loadAllSchemaRules() ); - schemaCache.load( schemaRules ); - } - }; - } - - private Factory storeStatementFactory( final NeoStores neoStores ) - { - final LockService lockService = - config.get( use_read_locks_on_property_reads ) ? this.lockService : NO_LOCK_SERVICE; - return () -> new StoreStatement( neoStores, lockService ); + LabelScanStoreProvider labelScanStore = dependencyResolver.resolveDependency( LabelScanStoreProvider.class, + LabelScanStoreProvider.HIGHEST_PRIORITIZED ); + return life.add( + new Module( storeDir, config, idGeneratorFactory, pageCache, fs, logProvider, propertyKeyTokenHolder, + labelTokens, relationshipTypeTokens, schemaStateChangeCallback, constraintSemantics, scheduler, + tokenNameLookup, lockService, indexProvider, indexingServiceMonitor, kernelHealth, + labelScanStore ) ); } private TransactionLogModule buildTransactionLogs( File storeDir, Config config, LogProvider logProvider, @@ -1094,11 +998,6 @@ public IndexingService getIndexService() return storeLayerModule.indexingService(); } - public SchemaIndexProvider getIndexProvider() - { - return indexProvider; - } - public LabelScanStore getLabelScanStore() { return storeLayerModule.labelScanStore(); @@ -1239,7 +1138,7 @@ public NeoStores get() public StoreReadLayer getStoreLayer() { - return storeLayerModule.storeLayer(); + return storeLayerModule.storeReadLayer(); } public DependencyResolver getDependencyResolver() diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/storageengine/StorageEngine.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/storageengine/StorageEngine.java new file mode 100644 index 0000000000000..68439d2747123 --- /dev/null +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/storageengine/StorageEngine.java @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2002-2015 "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 . + */ +package org.neo4j.kernel.impl.storageengine; + +import org.neo4j.kernel.impl.api.store.StoreReadLayer; + +/** + * A StorageEngine provides the functionality to durably store data, and read it back. + */ +public interface StorageEngine +{ + StoreReadLayer storeReadLayer(); +} diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/storageengine/impl/recordstorage/RecordStorageEngine.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/storageengine/impl/recordstorage/RecordStorageEngine.java new file mode 100644 index 0000000000000..e7bfb71390611 --- /dev/null +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/storageengine/impl/recordstorage/RecordStorageEngine.java @@ -0,0 +1,210 @@ +/* + * Copyright (c) 2002-2015 "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 . + */ +package org.neo4j.kernel.impl.storageengine.impl.recordstorage; + +import java.io.File; +import java.util.Collections; +import java.util.List; + +import org.neo4j.function.Factory; +import org.neo4j.graphdb.config.Setting; +import org.neo4j.io.fs.FileSystemAbstraction; +import org.neo4j.io.pagecache.PageCache; +import org.neo4j.kernel.IdGeneratorFactory; +import org.neo4j.kernel.KernelHealth; +import org.neo4j.kernel.api.TokenNameLookup; +import org.neo4j.kernel.api.index.SchemaIndexProvider; +import org.neo4j.kernel.api.labelscan.LabelScanStore; +import org.neo4j.kernel.configuration.Config; +import org.neo4j.kernel.impl.api.index.IndexUpdateMode; +import org.neo4j.kernel.impl.api.index.IndexUpdatesValidator; +import org.neo4j.kernel.impl.api.index.IndexingService; +import org.neo4j.kernel.impl.api.index.OnlineIndexUpdatesValidator; +import org.neo4j.kernel.impl.api.index.sampling.IndexSamplingConfig; +import org.neo4j.kernel.impl.api.scan.LabelScanStoreProvider; +import org.neo4j.kernel.impl.api.store.CacheLayer; +import org.neo4j.kernel.impl.api.store.DiskLayer; +import org.neo4j.kernel.impl.api.store.ProcedureCache; +import org.neo4j.kernel.impl.api.store.SchemaCache; +import org.neo4j.kernel.impl.api.store.StoreReadLayer; +import org.neo4j.kernel.impl.api.store.StoreStatement; +import org.neo4j.kernel.impl.cache.BridgingCacheAccess; +import org.neo4j.kernel.impl.constraints.ConstraintSemantics; +import org.neo4j.kernel.impl.core.CacheAccessBackDoor; +import org.neo4j.kernel.impl.core.LabelTokenHolder; +import org.neo4j.kernel.impl.core.PropertyKeyTokenHolder; +import org.neo4j.kernel.impl.core.RelationshipTypeTokenHolder; +import org.neo4j.kernel.impl.locking.LockService; +import org.neo4j.kernel.impl.storageengine.StorageEngine; +import org.neo4j.kernel.impl.store.NeoStores; +import org.neo4j.kernel.impl.store.SchemaStorage; +import org.neo4j.kernel.impl.store.StoreFactory; +import org.neo4j.kernel.impl.store.record.SchemaRule; +import org.neo4j.kernel.impl.transaction.state.DefaultSchemaIndexProviderMap; +import org.neo4j.kernel.impl.transaction.state.IntegrityValidator; +import org.neo4j.kernel.impl.transaction.state.NeoStoreIndexStoreView; +import org.neo4j.kernel.impl.transaction.state.PropertyLoader; +import org.neo4j.kernel.impl.util.JobScheduler; +import org.neo4j.kernel.lifecycle.Lifecycle; +import org.neo4j.logging.LogProvider; + +import static org.neo4j.helpers.Settings.BOOLEAN; +import static org.neo4j.helpers.Settings.TRUE; +import static org.neo4j.helpers.Settings.setting; +import static org.neo4j.helpers.collection.Iterables.toList; +import static org.neo4j.kernel.impl.locking.LockService.NO_LOCK_SERVICE; + +public class RecordStorageEngine implements StorageEngine, Lifecycle +{ + /** + * This setting is hidden to the user and is here merely for making it easier to back out of + * a change where reading property chains incurs read locks on {@link LockService}. + */ + private static final Setting use_read_locks_on_property_reads = + setting( "experimental.use_read_locks_on_property_reads", BOOLEAN, TRUE ); + + private final StoreReadLayer storeLayer; + protected final IndexingService indexingService; + protected final NeoStores neoStores; + private final PropertyKeyTokenHolder propertyKeyTokenHolder; + private final RelationshipTypeTokenHolder relationshipTypeTokenHolder; + private final LabelTokenHolder labelTokenHolder; + private final SchemaCache schemaCache; + protected final IntegrityValidator integrityValidator; + protected final IndexUpdatesValidator indexUpdatesValidator; + protected final CacheAccessBackDoor cacheAccess; + protected final LabelScanStore labelScanStore; + protected final DefaultSchemaIndexProviderMap providerMap; + protected final ProcedureCache procedureCache; + + public RecordStorageEngine( + File storeDir, Config config, IdGeneratorFactory idGeneratorFactory, PageCache pageCache, + FileSystemAbstraction fs, LogProvider logProvider, + PropertyKeyTokenHolder propertyKeyTokenHolder, + LabelTokenHolder labelTokens, + RelationshipTypeTokenHolder relationshipTypeTokens, + Runnable schemaStateChangeCallback, + ConstraintSemantics constraintSemantics, + JobScheduler scheduler, + TokenNameLookup tokenNameLookup, + LockService lockService, + SchemaIndexProvider indexProvider, + IndexingService.Monitor indexingServiceMonitor, + KernelHealth kernelHealth, + LabelScanStoreProvider labelScanStoreProvider ) + { + this.propertyKeyTokenHolder = propertyKeyTokenHolder; + this.relationshipTypeTokenHolder = relationshipTypeTokens; + this.labelTokenHolder = labelTokens; + final StoreFactory storeFactory = new StoreFactory( storeDir, config, idGeneratorFactory, pageCache, fs, logProvider ); + neoStores = storeFactory.openAllNeoStores( true ); + + try + { + schemaCache = new SchemaCache( constraintSemantics, Collections.emptyList() ); + SchemaStorage schemaStorage = new SchemaStorage( neoStores.getSchemaStore() ); + + providerMap = new DefaultSchemaIndexProviderMap( indexProvider ); + indexingService = IndexingService.create( + new IndexSamplingConfig( config ), scheduler, providerMap, + new NeoStoreIndexStoreView( lockService, neoStores ), tokenNameLookup, + toList( new SchemaStorage( neoStores.getSchemaStore() ).allIndexRules() ), logProvider, + indexingServiceMonitor, schemaStateChangeCallback ); + + integrityValidator = new IntegrityValidator( neoStores, indexingService ); + indexUpdatesValidator = new OnlineIndexUpdatesValidator( + neoStores, kernelHealth, new PropertyLoader( neoStores ), + indexingService, IndexUpdateMode.ONLINE ); + cacheAccess = new BridgingCacheAccess( schemaCache, schemaStateChangeCallback, + propertyKeyTokenHolder, relationshipTypeTokens, labelTokens ); + + DiskLayer diskLayer = new DiskLayer( propertyKeyTokenHolder, labelTokens, relationshipTypeTokens, + schemaStorage, + neoStores, indexingService, storeStatementFactory( neoStores, config, lockService ) ); + procedureCache = new ProcedureCache(); + storeLayer = new CacheLayer( diskLayer, schemaCache, procedureCache ); + this.labelScanStore = labelScanStoreProvider.getLabelScanStore(); + } + catch ( Throwable failure ) + { + neoStores.close(); + throw failure; + } + } + + private static Factory storeStatementFactory( + NeoStores neoStores, Config config, LockService lockService ) + { + final LockService currentLockService = + config.get( use_read_locks_on_property_reads ) ? lockService : NO_LOCK_SERVICE; + return () -> new StoreStatement( neoStores, currentLockService ); + } + + @Override + public StoreReadLayer storeReadLayer() + { + return storeLayer; + } + + @Override + public void init() throws Throwable + { + indexingService.init(); + labelScanStore.init(); + } + + @Override + public void start() throws Throwable + { + neoStores.makeStoreOk(); + + propertyKeyTokenHolder.setInitialTokens( + neoStores.getPropertyKeyTokenStore().getTokens( Integer.MAX_VALUE ) ); + relationshipTypeTokenHolder.setInitialTokens( + neoStores.getRelationshipTypeTokenStore().getTokens( Integer.MAX_VALUE ) ); + labelTokenHolder.setInitialTokens( + neoStores.getLabelTokenStore().getTokens( Integer.MAX_VALUE ) ); + + neoStores.rebuildCountStoreIfNeeded(); // TODO: move this to counts store lifecycle + loadSchemaCache(); + indexingService.start(); + labelScanStore.start(); + } + + public void loadSchemaCache() + { + List schemaRules = toList( neoStores.getSchemaStore().loadAllSchemaRules() ); + schemaCache.load( schemaRules ); + } + + @Override + public void stop() throws Throwable + { + labelScanStore.stop(); + indexingService.stop(); + } + + @Override + public void shutdown() throws Throwable + { + labelScanStore.shutdown(); + indexingService.shutdown(); + } +} diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/util/function/Optionals.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/util/function/Optionals.java index e0818ca453c8f..d290620b1be47 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/util/function/Optionals.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/util/function/Optionals.java @@ -28,7 +28,7 @@ public class Optionals @Override public Object get() { - throw new UnsupportedOperationException(); + throw new UnsupportedOperationException( "Cannot get Optionals.none()" ); } @Override diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/storageengine/StorageEngineTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/storageengine/StorageEngineTest.java new file mode 100644 index 0000000000000..11128029aa061 --- /dev/null +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/storageengine/StorageEngineTest.java @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2002-2015 "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 . + */ +package org.neo4j.kernel.impl.storageengine; + +import org.junit.Before; + +import org.neo4j.kernel.IdGeneratorFactory; +import org.neo4j.test.impl.EphemeralIdGenerator; + +public abstract class StorageEngineTest +{ + private IdGeneratorFactory idGeneratorFactory; + + @Before + public void setUp() + { + idGeneratorFactory = new EphemeralIdGenerator.Factory(); + } + + protected abstract StorageEngine buildEngine( IdGeneratorFactory idGeneratorFactory ); + + + // bigger things + // TODO provide access to StoreReadLayer + // TODO create a stream of commands from a transaction state + // TODO apply a stream of commands to the store + // TODO deserialise a stream of byte buffers into commands + // TODO flush to durable storage +} diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/storageengine/impl/recordstorage/RecordStorageEngineTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/storageengine/impl/recordstorage/RecordStorageEngineTest.java new file mode 100644 index 0000000000000..b7dbd4f6462cf --- /dev/null +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/storageengine/impl/recordstorage/RecordStorageEngineTest.java @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2002-2015 "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 . + */ +package org.neo4j.kernel.impl.storageengine.impl.recordstorage; + +import org.neo4j.kernel.IdGeneratorFactory; +import org.neo4j.kernel.impl.storageengine.StorageEngine; +import org.neo4j.kernel.impl.storageengine.StorageEngineTest; + +public class RecordStorageEngineTest extends StorageEngineTest +{ + @Override + protected StorageEngine buildEngine( IdGeneratorFactory idGeneratorFactory ) + { + throw new UnsupportedOperationException( "TODO" ); + } +}