@Override
public void stop() {
transactionLogModule.logRotationControl().awaitAllTransactionsClosed();
transactionLogModule.logRotationControl().forceEverything();
/*
* We simply increment the version, essentially "rotating" away
* the current active log file, to avoid having a recovery on
* next startup. Not necessary, simply speeds up the startup
* process.
*/
neoStoreModule.neoStore().incrementAndGetVersion();
life.shutdown();
neoStoreModule.neoStore().close();
msgLog.info("NeoStore closed");
}
@Override
public void start() throws IOException {
dependencies = new Dependencies();
life = new LifeSupport();
storeDir = config.get(Configuration.store_dir);
File store = config.get(Configuration.neo_store);
if (!storeFactory.storeExists()) {
storeFactory.createNeoStore().close();
}
indexProvider =
dependencyResolver.resolveDependency(
SchemaIndexProvider.class, SchemaIndexProvider.HIGHEST_PRIORITIZED_OR_NONE);
// Monitor listeners
LoggingLogFileMonitor loggingLogMonitor =
new LoggingLogFileMonitor(logging.getMessagesLog(getClass()));
monitors.addMonitorListener(loggingLogMonitor);
monitors.addMonitorListener(
new RecoveryVisitor.Monitor() {
@Override
public void transactionRecovered(long txId) {
recoveredCount.incrementAndGet();
}
});
// Upgrade the store before we begin
upgradeStore(store, storeMigrationProcess, indexProvider);
// Build all modules and their services
try {
final NeoStoreModule neoStoreModule =
buildNeoStore(storeFactory, labelTokens, relationshipTypeTokens, propertyKeyTokenHolder);
this.neoStoreModule =
neoStoreModule; // TODO The only reason this is here is because of the provider-stuff for
// DiskLayer. Remove when possible
CacheModule cacheModule =
buildCaches(
neoStoreModule.neoStore(),
cacheProvider,
nodeManager,
labelTokens,
relationshipTypeTokens,
propertyKeyTokenHolder);
IndexingModule indexingModule =
buildIndexing(
config,
scheduler,
indexProvider,
lockService,
tokenNameLookup,
logging,
indexingServiceMonitor,
neoStoreModule.neoStore(),
cacheModule.updateableSchemaState());
StoreLayerModule storeLayerModule =
buildStoreLayer(
config,
neoStoreModule.neoStore(),
cacheModule.persistenceCache(),
propertyKeyTokenHolder,
labelTokens,
relationshipTypeTokens,
indexingModule.indexingService(),
cacheModule.schemaCache());
TransactionLogModule transactionLogModule =
buildTransactionLogs(
config,
logging,
indexingModule.labelScanStore(),
fs,
neoStoreModule.neoStore(),
cacheModule.cacheAccess(),
indexingModule.indexingService(),
indexProviders.values());
buildRecovery(
fs,
cacheModule.cacheAccess(),
indexingModule.indexingService(),
indexingModule.labelScanStore(),
neoStoreModule.neoStore(),
monitors.newMonitor(RecoveryVisitor.Monitor.class),
monitors.newMonitor(Recovery.Monitor.class),
transactionLogModule.logFiles(),
transactionLogModule.logRotationControl(),
startupStatistics);
KernelModule kernelModule =
buildKernel(
indexingModule.integrityValidator(),
transactionLogModule.logicalTransactionStore(),
neoStoreModule.neoStore(),
transactionLogModule.storeApplier(),
indexingModule.indexingService(),
storeLayerModule.storeLayer(),
cacheModule.updateableSchemaState(),
indexingModule.labelScanStore(),
cacheModule.persistenceCache(),
indexingModule.schemaIndexProviderMap());
// Do these assignments last so that we can ensure no cyclical dependencies exist
this.cacheModule = cacheModule;
this.indexingModule = indexingModule;
this.storeLayerModule = storeLayerModule;
this.transactionLogModule = transactionLogModule;
this.kernelModule = kernelModule;
dependencies.satisfyDependency(this);
satisfyDependencies(
neoStoreModule,
cacheModule,
indexingModule,
storeLayerModule,
transactionLogModule,
kernelModule);
} catch (Throwable e) { // Something unexpected happened during startup
try { // Close the neostore, so that locks are released properly
neoStoreModule.neoStore().close();
} catch (Exception closeException) {
msgLog.logMessage("Couldn't close neostore after startup failure");
}
throw Exceptions.launderedException(e);
}
try {
life.start();
} catch (Throwable e) { // Something unexpected happened during startup
try { // Close the neostore, so that locks are released properly
neoStoreModule.neoStore().close();
} catch (Exception closeException) {
msgLog.logMessage("Couldn't close neostore after startup failure");
}
throw Exceptions.launderedException(e);
}
}
public void awaitAllTransactionsClosed() {
while (!neoStoreModule.neoStore().closedTransactionIdIsOnParWithCommittedTransactionId()) {
LockSupport.parkNanos(1_000_000); // 1 ms
}
}
@Override
public NeoStore evaluate() {
return neoStoreModule.neoStore();
}
public NeoStore getNeoStore() {
return neoStoreModule.neoStore();
}
// Startup sequence done
private void loadSchemaCache() {
cacheModule.schemaCache().load(neoStoreModule.neoStore().getSchemaStore().loadAllSchemaRules());
}
