org.neo4j.kernel.recovery.Recovery Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of neo4j-kernel Show documentation
Show all versions of neo4j-kernel Show documentation
Neo4j kernel is a lightweight, embedded Java database designed to
store data structured as graphs rather than tables. For more
information, see http://neo4j.org.
/*
* Copyright (c) "Neo4j"
* Neo4j Sweden AB [https://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 logTailMetadata,
MemoryTracker memoryTracker,
DatabaseTracers databaseTracers)
throws IOException {
return isRecoveryRequired(
fs,
pageCache,
databaseLayout,
StorageEngineFactory.selectStorageEngine(fs, databaseLayout, config),
config,
logTailMetadata,
memoryTracker,
databaseTracers);
}
public static boolean isRecoveryRequired(
FileSystemAbstraction fs,
PageCache pageCache,
DatabaseLayout layout,
StorageEngineFactory storageEngineFactory,
Config config,
Optional logTailMetadata,
MemoryTracker memoryTracker,
DatabaseTracers databaseTracers)
throws IOException {
RecoveryRequiredChecker requiredChecker =
new RecoveryRequiredChecker(fs, pageCache, config, storageEngineFactory, databaseTracers);
final var databaseLayout = storageEngineFactory.formatSpecificDatabaseLayout(layout);
return logTailMetadata.isPresent()
? requiredChecker.isRecoveryRequiredAt(databaseLayout, logTailMetadata.get())
: requiredChecker.isRecoveryRequiredAt(databaseLayout, memoryTracker);
}
public static Context context(
FileSystemAbstraction fs,
PageCache pageCache,
DatabaseTracers tracers,
Config config,
DatabaseLayout databaseLayout,
MemoryTracker memoryTracker,
IOController ioController,
InternalLogProvider logProvider,
KernelVersionProvider emptyLogsFallbackKernelVersion) {
return new Context(
fs,
pageCache,
databaseLayout,
config,
memoryTracker,
tracers,
ioController,
logProvider,
emptyLogsFallbackKernelVersion);
}
public static Context context(
FileSystemAbstraction fs,
PageCache pageCache,
DatabaseTracers tracers,
Config config,
DatabaseLayout databaseLayout,
MemoryTracker memoryTracker,
IOController ioController,
InternalLogProvider logProvider,
LogTailMetadata logTail) {
return new Context(
fs, pageCache, databaseLayout, config, memoryTracker, tracers, ioController, logProvider, logTail);
}
/**
* Context used to perform recovery of database described by provided layout.
* If recovery is not required - nothing will be done to the database or logs unless {@link Context#force()} is specified
*/
public static class Context {
private final MemoryTracker memoryTracker;
private final DatabaseLayout databaseLayout;
private final FileSystemAbstraction fs;
private final PageCache pageCache;
private final Config config;
private final DatabaseTracers tracers;
private final InternalLogProvider logProvider;
private boolean forceRunRecovery;
private Monitors globalMonitors = new Monitors();
private Iterable> extensionFactories;
private Optional providedLogTail = Optional.empty();
private RecoveryStartupChecker startupChecker = EMPTY_CHECKER;
private Clock clock = systemClock();
private final IOController ioController;
private RecoveryPredicate recoveryPredicate = RecoveryPredicate.ALL;
private RecoveryMode mode = RecoveryMode.FULL;
private long awaitIndexesOnlineMillis;
private final KernelVersionProvider emptyLogsFallbackKernelVersion;
private Context(
FileSystemAbstraction fileSystemAbstraction,
PageCache pageCache,
DatabaseLayout databaseLayout,
Config config,
MemoryTracker memoryTracker,
DatabaseTracers tracers,
IOController ioController,
InternalLogProvider logProvider,
KernelVersionProvider emptyLogsFallbackKernelVersion) {
requireNonNull(pageCache);
requireNonNull(fileSystemAbstraction);
requireNonNull(databaseLayout);
requireNonNull(config);
this.pageCache = pageCache;
this.fs = fileSystemAbstraction;
this.databaseLayout = databaseLayout;
this.config = config;
this.memoryTracker = memoryTracker;
this.tracers = tracers;
this.ioController = ioController;
this.logProvider = requireNonNull(logProvider);
this.emptyLogsFallbackKernelVersion = emptyLogsFallbackKernelVersion;
}
private Context(
FileSystemAbstraction fileSystemAbstraction,
PageCache pageCache,
DatabaseLayout databaseLayout,
Config config,
MemoryTracker memoryTracker,
DatabaseTracers tracers,
IOController ioController,
InternalLogProvider logProvider,
LogTailMetadata logTail) {
requireNonNull(pageCache);
requireNonNull(fileSystemAbstraction);
requireNonNull(databaseLayout);
requireNonNull(config);
this.pageCache = pageCache;
this.fs = fileSystemAbstraction;
this.databaseLayout = databaseLayout;
this.config = config;
this.memoryTracker = memoryTracker;
this.tracers = tracers;
this.ioController = ioController;
this.logProvider = requireNonNull(logProvider);
// No need for the kernelVersionProvider if we are guaranteed a log tail.
this.emptyLogsFallbackKernelVersion = KernelVersionProvider.THROWING_PROVIDER;
this.providedLogTail = Optional.of(logTail);
}
/**
* @param monitors global server monitors
*/
public Context monitors(Monitors monitors) {
this.globalMonitors = monitors;
return this;
}
/**
* @param extensionFactories extension factories for extensions that should participate in recovery
*/
public Context extensionFactories(Iterable> extensionFactories) {
this.extensionFactories = extensionFactories;
return this;
}
/**
* Force recovery to run even if the usual checks indicates that it's not required.
* In specific cases, like after store copy there's always a need for doing a recovery or at least to start the db, checkpoint and shut down,
* even if the normal "is recovery required" checks says that recovery isn't required
*/
public Context force() {
this.forceRunRecovery = true;
return this;
}
/**
* @param startupChecker Checker for recovery startup.
*/
public Context startupChecker(RecoveryStartupChecker startupChecker) {
this.startupChecker = startupChecker;
return this;
}
/**
* @param clock The clock to use
*/
public Context clock(Clock clock) {
this.clock = clock;
return this;
}
/**
* @param recoveryPredicate Criteria to decide when to stop recovery
* We always replay everything, but can do early termination based on predicate for point in time recovery
*/
public Context recoveryPredicate(RecoveryPredicate recoveryPredicate) {
this.recoveryPredicate = recoveryPredicate;
return this;
}
public Context awaitIndexesOnline(long time, TimeUnit unit) {
this.awaitIndexesOnlineMillis = unit.toMillis(time);
return this;
}
public Context recoveryMode(RecoveryMode mode) {
this.mode = mode;
return this;
}
}
/**
* Perform recovery as specified by the provided context
* @param context The context to use
* @throws IOException on any unexpected I/O exception encountered during recovery.
*/
public static boolean performRecovery(Context context) throws IOException {
requireNonNull(context);
StorageEngineFactory storageEngineFactory =
selectStorageEngine(context.fs, context.databaseLayout, context.config);
Iterable> extensionFactories =
context.extensionFactories != null ? context.extensionFactories : loadExtensions();
assert !(context.pageCache instanceof DatabasePageCache)
: "Recovery should use global page cache to avoid using overloaded mapping.";
var config = new LocalConfig(context.config);
try {
return performRecovery(
context.fs,
context.pageCache,
context.tracers,
config,
storageEngineFactory.formatSpecificDatabaseLayout(context.databaseLayout),
storageEngineFactory,
context.forceRunRecovery,
context.logProvider,
context.globalMonitors,
extensionFactories,
context.providedLogTail,
context.startupChecker,
context.memoryTracker,
context.clock,
context.ioController,
context.recoveryPredicate,
context.awaitIndexesOnlineMillis,
context.emptyLogsFallbackKernelVersion,
context.mode);
} finally {
config.removeAllLocalListeners();
}
}
private static boolean performRecovery(
FileSystemAbstraction fs,
PageCache pageCache,
DatabaseTracers tracers,
Config config,
DatabaseLayout databaseLayout,
StorageEngineFactory storageEngineFactory,
boolean forceRunRecovery,
InternalLogProvider logProvider,
Monitors globalMonitors,
Iterable> extensionFactories,
Optional providedLogTail,
RecoveryStartupChecker startupChecker,
MemoryTracker memoryTracker,
Clock clock,
IOController ioController,
RecoveryPredicate recoveryPredicate,
long awaitIndexesOnlineMillis,
KernelVersionProvider emptyLogsFallbackKernelVersion,
RecoveryMode mode)
throws IOException {
InternalLog recoveryLog = logProvider.getLog(Recovery.class);
if (!forceRunRecovery
&& !isRecoveryRequired(
fs,
pageCache,
databaseLayout,
storageEngineFactory,
config,
providedLogTail,
memoryTracker,
tracers)) {
return false;
}
checkAllFilesPresence(databaseLayout, fs, pageCache, storageEngineFactory);
LifeSupport recoveryLife = new LifeSupport();
var namedDatabaseId = createRecoveryDatabaseId(fs, pageCache, databaseLayout, storageEngineFactory);
Monitors monitors = new Monitors(globalMonitors, logProvider);
VersionStorage recoveryVersionStorage = VersionStorage.EMPTY_STORAGE;
DatabasePageCache databasePageCache =
new DatabasePageCache(pageCache, ioController, recoveryVersionStorage, config);
SimpleLogService logService = new SimpleLogService(logProvider);
DatabaseReadOnlyChecker readOnlyChecker = writable();
DatabaseSchemaState schemaState = new DatabaseSchemaState(logProvider);
JobScheduler scheduler = recoveryLife.add(JobSchedulerFactory.createInitialisedScheduler());
DatabaseAvailabilityGuard guard = new RecoveryAvailabilityGuard(namedDatabaseId, clock, recoveryLog);
recoveryLife.add(guard);
TransactionVersionContextSupplier versionContextSupplier = new TransactionVersionContextSupplier();
versionContextSupplier.init(EMPTY_SNAPSHOT_FACTORY, EMPTY_OLDEST_ID_FACTORY);
CursorContextFactory cursorContextFactory =
new CursorContextFactory(tracers.getPageCacheTracer(), versionContextSupplier);
DatabaseHealth databaseHealth = new DatabaseHealth(HealthEventGenerator.NO_OP, recoveryLog);
// The token registries during recovery can add tokens w/o making a defensive copy
// of all internal token registry state, because there should be none doing lookups
// In fact token lookup should not be necessary at all during recovery
TokenHolders tokenHolders = new TokenHolders(
new CreatingTokenHolder(ReadOnlyTokenCreator.READ_ONLY, TYPE_PROPERTY_KEY),
new CreatingTokenHolder(ReadOnlyTokenCreator.READ_ONLY, TYPE_LABEL),
new CreatingTokenHolder(ReadOnlyTokenCreator.READ_ONLY, TYPE_RELATIONSHIP_TYPE));
RecoveryCleanupWorkCollector recoveryCleanupCollector =
recoveryLife.add(new GroupingRecoveryCleanupWorkCollector(
scheduler, INDEX_CLEANUP, INDEX_CLEANUP_WORK, databaseLayout.getDatabaseName()));
DatabaseExtensions extensions = recoveryLife.add(instantiateRecoveryExtensions(
databaseLayout,
fs,
config,
logService,
databasePageCache,
scheduler,
DbmsInfo.TOOL,
monitors,
tokenHolders,
recoveryCleanupCollector,
readOnlyChecker,
extensionFactories,
guard,
tracers,
namedDatabaseId,
cursorContextFactory));
Dependencies indexDependencies = new Dependencies(extensions);
indexDependencies.satisfyDependencies(recoveryVersionStorage);
var indexProviderMap = recoveryLife.add(StaticIndexProviderMapFactory.create(
recoveryLife,
config,
databasePageCache,
fs,
logService,
monitors,
readOnlyChecker,
HostedOnMode.SINGLE,
recoveryCleanupCollector,
databaseLayout,
tokenHolders,
scheduler,
cursorContextFactory,
tracers.getPageCacheTracer(),
indexDependencies));
LogTailMetadata logTailMetadata = providedLogTail.orElseGet(() -> loadLogTail(
fs,
tracers,
config,
databaseLayout,
storageEngineFactory,
memoryTracker,
emptyLogsFallbackKernelVersion));
MetadataCache recoveryMetaDataCache = new MetadataCache(logTailMetadata);
StorageEngine storageEngine = storageEngineFactory.instantiate(
fs,
clock,
databaseLayout,
config,
databasePageCache,
tokenHolders,
schemaState,
getConstraintSemantics(),
indexProviderMap,
NO_LOCK_SERVICE,
new DefaultIdGeneratorFactory(
fs, recoveryCleanupCollector, tracers.getPageCacheTracer(), databaseLayout.getDatabaseName()),
databaseHealth,
logService.getInternalLogProvider(),
logService.getUserLogProvider(),
recoveryCleanupCollector,
logTailMetadata,
recoveryMetaDataCache,
memoryTracker,
cursorContextFactory,
tracers.getPageCacheTracer(),
recoveryVersionStorage);
// Schema indexes
FullScanStoreView fullScanStoreView = new FullScanStoreView(NO_LOCK_SERVICE, storageEngine, config, scheduler);
IndexStoreViewFactory indexStoreViewFactory = new IndexStoreViewFactory(
config, storageEngine, NO_LOCKS_LOCK_MANAGER, fullScanStoreView, NO_LOCK_SERVICE, logProvider);
IndexStatisticsStore indexStatisticsStore = new IndexStatisticsStore(
databasePageCache,
fs,
databaseLayout,
recoveryCleanupCollector,
false,
cursorContextFactory,
tracers.getPageCacheTracer(),
storageEngine.getOpenOptions());
IndexingService indexingService = Database.buildIndexingService(
storageEngine,
schemaState,
indexStoreViewFactory,
indexStatisticsStore,
new DatabaseIndexStats(),
config,
scheduler,
indexProviderMap,
tokenHolders,
logProvider,
monitors.newMonitor(IndexMonitor.class),
cursorContextFactory,
memoryTracker,
databaseLayout.getDatabaseName(),
readOnlyChecker,
clock,
recoveryMetaDataCache,
fs,
EMPTY_VISIBILITY_PROVIDER);
MetadataProvider metadataProvider = storageEngine.metadataProvider();
var dependencies = dependenciesOf(
databaseLayout,
config,
databasePageCache,
fs,
logProvider,
tokenHolders,
schemaState,
getConstraintSemantics(),
NO_LOCK_SERVICE,
databaseHealth,
new DefaultIdGeneratorFactory(
fs, recoveryCleanupCollector, tracers.getPageCacheTracer(), databaseLayout.getDatabaseName()),
new DefaultIdController(),
readOnlyChecker,
cursorContextFactory,
logService,
metadataProvider);
LogFiles logFiles = LogFilesBuilder.builder(databaseLayout, fs, recoveryMetaDataCache)
.withStorageEngineFactory(storageEngineFactory)
.withConfig(config)
.withDatabaseTracers(tracers)
.withExternalLogTailMetadata(logTailMetadata)
.withDependencies(dependencies)
.withMemoryTracker(memoryTracker)
.build();
boolean failOnCorruptedLogFiles = config.get(GraphDatabaseInternalSettings.fail_on_corrupted_log_files);
validateStoreId(logTailMetadata, storageEngine.retrieveStoreId());
TransactionMetadataCache metadataCache = new TransactionMetadataCache();
PhysicalLogicalTransactionStore transactionStore = new PhysicalLogicalTransactionStore(
logFiles,
metadataCache,
storageEngineFactory.commandReaderFactory(),
monitors,
failOnCorruptedLogFiles,
config);
LifeSupport schemaLife = new LifeSupport();
schemaLife.add(storageEngine.schemaAndTokensLifecycle());
schemaLife.add(indexingService);
var doParallelRecovery = config.get(GraphDatabaseInternalSettings.do_parallel_recovery);
TransactionLogsRecovery transactionLogsRecovery = transactionLogRecovery(
fs,
metadataProvider,
monitors.newMonitor(RecoveryMonitor.class),
monitors.newMonitor(RecoveryStartInformationProvider.Monitor.class),
logFiles,
storageEngine,
logTailMetadata,
transactionStore,
metadataProvider,
schemaLife,
databaseLayout,
failOnCorruptedLogFiles,
recoveryLog,
startupChecker,
memoryTracker,
clock,
doParallelRecovery,
recoveryPredicate,
cursorContextFactory,
mode,
new BinarySupportedKernelVersions(config),
metadataProvider);
CheckPointerImpl.ForceOperation forceOperation =
new DefaultForceOperation(indexingService, storageEngine, databasePageCache);
var checkpointAppender = logFiles.getCheckpointFile().getCheckpointAppender();
LogPruning logPruning = new LogPruningImpl(
fs, logFiles, logProvider, new LogPruneStrategyFactory(), clock, config, new ReentrantLock());
CheckPointerImpl checkPointer = new CheckPointerImpl(
metadataProvider,
RecoveryThreshold.INSTANCE,
forceOperation,
logPruning,
checkpointAppender,
databaseHealth,
logProvider,
tracers,
new StoreCopyCheckPointMutex(),
cursorContextFactory,
clock,
ioController,
recoveryMetaDataCache);
recoveryLife.add(indexStatisticsStore);
recoveryLife.add(storageEngine);
recoveryLife.add(new MissingTransactionLogsCheck(config, logTailMetadata, recoveryLog));
recoveryLife.add(logFiles);
recoveryLife.add(transactionLogsRecovery);
recoveryLife.add(checkPointer);
try {
recoveryLife.start();
if (databaseHealth.hasNoPanic()) {
if (logTailMetadata.hasUnreadableBytesInCheckpointLogs()) {
logFiles.getCheckpointFile().rotate();
}
if (awaitIndexesOnlineMillis > 0) {
awaitIndexesOnline(indexingService, awaitIndexesOnlineMillis);
}
// stop extensions now to prevent possible interference with checkpoint
extensions.stop();
String recoveryMessage =
logTailMetadata.logsMissing() ? "Recovery with missing logs completed." : "Recovery completed.";
checkPointer.forceCheckPoint(new SimpleTriggerInfo(recoveryMessage));
}
} finally {
recoveryLife.shutdown();
}
return true;
}
private static void awaitIndexesOnline(IndexingService indexingService, long awaitIndexesOnlineMillis) {
var stopWatch = Stopwatch.start();
try {
for (IndexProxy indexProxy : indexingService.getIndexProxies()) {
while (stopWatch.hasTimedOut(awaitIndexesOnlineMillis, MILLISECONDS)
&& indexProxy.getState() == InternalIndexState.POPULATING) {
MILLISECONDS.sleep(10);
}
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
private static LogTailMetadata loadLogTail(
FileSystemAbstraction fs,
DatabaseTracers tracers,
Config config,
DatabaseLayout databaseLayout,
StorageEngineFactory storageEngineFactory,
MemoryTracker memoryTracker,
KernelVersionProvider emptyLogsFallbackKernelVersion) {
try {
return new LogTailExtractor(fs, config, storageEngineFactory, tracers, false)
.getTailMetadata(databaseLayout, memoryTracker, emptyLogsFallbackKernelVersion);
} catch (IOException ioe) {
throw new UncheckedIOException("Fail to load log tail.", ioe);
}
}
private static NamedDatabaseId createRecoveryDatabaseId(
FileSystemAbstraction fs,
PageCache pageCache,
DatabaseLayout databaseLayout,
StorageEngineFactory storageEngineFactory) {
UUID uuid = storageEngineFactory
.databaseIdUuid(fs, databaseLayout, pageCache, CursorContext.NULL_CONTEXT)
.orElse(new UUID(0, 0));
return DatabaseIdFactory.from(databaseLayout.getDatabaseName(), uuid);
}
public static void validateStoreId(LogTailMetadata tailMetadata, StoreId storeId) {
var optionalTxStoreId = tailMetadata.getStoreId();
if (optionalTxStoreId.isPresent()) {
var txStoreId = optionalTxStoreId.get();
if (!storeId.isSameOrUpgradeSuccessor(txStoreId) && !txStoreId.isSameOrUpgradeSuccessor(storeId)) {
throw new RuntimeException(
"Mismatching store id. Store StoreId: " + storeId + ". Transaction log StoreId: " + txStoreId);
}
}
}
private static void checkAllFilesPresence(
DatabaseLayout databaseLayout,
FileSystemAbstraction fs,
PageCache pageCache,
StorageEngineFactory storageEngineFactory) {
StorageFilesState state = storageEngineFactory.checkStoreFileState(fs, databaseLayout, pageCache);
if (state.recoveryState() == RecoveryState.UNRECOVERABLE) {
throw new RuntimeException(format(
"Store files %s is(are) missing and recovery is not possible. Please restore from a consistent backup.",
state.missingFiles()));
}
}
private static TransactionLogsRecovery transactionLogRecovery(
FileSystemAbstraction fileSystemAbstraction,
TransactionIdStore transactionIdStore,
RecoveryMonitor recoveryMonitor,
RecoveryStartInformationProvider.Monitor positionMonitor,
LogFiles logFiles,
StorageEngine storageEngine,
KernelVersionProvider versionProvider,
LogicalTransactionStore logicalTransactionStore,
LogVersionRepository logVersionRepository,
Lifecycle schemaLife,
DatabaseLayout databaseLayout,
boolean failOnCorruptedLogFiles,
InternalLog log,
RecoveryStartupChecker startupChecker,
MemoryTracker memoryTracker,
Clock clock,
boolean doParallelRecovery,
RecoveryPredicate recoveryPredicate,
CursorContextFactory contextFactory,
RecoveryMode mode,
BinarySupportedKernelVersions binarySupportedKernelVersions,
MetadataProvider metadataProvider) {
RecoveryService recoveryService = new DefaultRecoveryService(
storageEngine,
transactionIdStore,
logicalTransactionStore,
logVersionRepository,
logFiles,
versionProvider,
positionMonitor,
log,
clock,
doParallelRecovery,
binarySupportedKernelVersions,
contextFactory,
metadataProvider);
CorruptedLogsTruncator logsTruncator = new CorruptedLogsTruncator(
databaseLayout.databaseDirectory(), logFiles, fileSystemAbstraction, memoryTracker);
var loggerPrintWriterAdaptor = new LoggerPrintWriterAdaptor(log, Level.INFO);
return new TransactionLogsRecovery(
recoveryService,
logsTruncator,
schemaLife,
recoveryMonitor,
ProgressMonitorFactory.basicTextual(loggerPrintWriterAdaptor),
failOnCorruptedLogFiles,
startupChecker,
recoveryPredicate,
contextFactory,
mode);
}
private static Iterable> loadExtensions() {
return Iterables.cast(Services.loadAll(ExtensionFactory.class));
}
private static DatabaseExtensions instantiateRecoveryExtensions(
DatabaseLayout databaseLayout,
FileSystemAbstraction fileSystem,
Config config,
LogService logService,
PageCache pageCache,
JobScheduler jobScheduler,
DbmsInfo info,
Monitors monitors,
TokenHolders tokenHolders,
RecoveryCleanupWorkCollector recoveryCleanupCollector,
DatabaseReadOnlyChecker readOnlyChecker,
Iterable> extensionFactories,
AvailabilityGuard availabilityGuard,
DatabaseTracers tracers,
NamedDatabaseId namedDatabaseId,
CursorContextFactory contextFactory) {
List> recoveryExtensions = stream(extensionFactories)
.filter(extension -> extension.getClass().isAnnotationPresent(RecoveryExtension.class))
.toList();
NonListenableMonitors nonListenableMonitors =
new NonListenableMonitors(monitors, logService.getInternalLogProvider());
var deps = dependenciesOf(
fileSystem,
config,
logService,
pageCache,
nonListenableMonitors,
jobScheduler,
tokenHolders,
recoveryCleanupCollector,
tracers,
databaseLayout,
readOnlyChecker,
availabilityGuard,
namedDatabaseId,
FileStoreProviderRegistry.EMPTY,
contextFactory);
DatabaseExtensionContext extensionContext = new DatabaseExtensionContext(databaseLayout, info, deps);
return new DatabaseExtensions(extensionContext, recoveryExtensions, deps, ExtensionFailureStrategies.fail());
}
private static PageCache getPageCache(Config config, FileSystemAbstraction fs, JobScheduler jobScheduler) {
ConfiguringPageCacheFactory pageCacheFactory = new ConfiguringPageCacheFactory(
fs,
config,
PageCacheTracer.NULL,
NullLog.getInstance(),
jobScheduler,
Clocks.nanoClock(),
new MemoryPools());
return pageCacheFactory.getOrCreatePageCache();
}
static void throwUnableToCleanRecover(Throwable t) {
throw new RuntimeException(
"Error reading transaction logs, recovery not possible. To force the database to start anyway, you can specify '"
+ GraphDatabaseInternalSettings.fail_on_corrupted_log_files.name()
+ "=false'. This will try to recover as much "
+ "as possible and then truncate the corrupt part of the transaction log. Doing this means your database "
+ "integrity might be compromised, please consider restoring from a consistent backup instead.",
t);
}
private static class RecoveryAvailabilityGuard extends DatabaseAvailabilityGuard {
RecoveryAvailabilityGuard(NamedDatabaseId namedDatabaseId, Clock clock, InternalLog log) {
// we do not want ot pass real config to guard for recovery
super(namedDatabaseId, clock, log, 0, new CompositeDatabaseAvailabilityGuard(clock, Config.defaults()));
init();
start();
}
@Override
public void addListener(AvailabilityListener listener) {
super.addListener(listener);
listener.available();
}
}
// We need to create monitors that do not allow listener registration here since at this point another version of
// extensions already stared by owning
// database life and if we will allow registration of listeners here we will end-up having same event captured by
// multiple listeners resulting in
// for example duplicated logging records in user facing logs
private static class NonListenableMonitors extends Monitors {
NonListenableMonitors(Monitors monitors, InternalLogProvider logProvider) {
super(monitors, logProvider);
}
@Override
public void addMonitorListener(Object monitorListener, String... tags) {}
}
private static class MissingTransactionLogsCheck extends LifecycleAdapter {
private final Config config;
private final LogTailMetadata logTail;
private final InternalLog log;
MissingTransactionLogsCheck(Config config, LogTailMetadata logTail, InternalLog log) {
this.config = config;
this.logTail = logTail;
this.log = log;
}
@Override
public void init() {
checkForMissingLogFiles();
}
private void checkForMissingLogFiles() {
if (logTail.logsMissing()) {
if (config.get(GraphDatabaseSettings.fail_on_missing_files)) {
log.error("Transaction logs are missing and recovery is not possible.");
log.info(
"To force the database to start anyway, you can specify '%s=false'. "
+ "This will create new transaction log and will update database metadata accordingly. "
+ "Doing this means your database integrity might be compromised, "
+ "please consider restoring from a consistent backup instead.",
GraphDatabaseSettings.fail_on_missing_files.name());
throw new RuntimeException("Transaction logs are missing and recovery is not possible.");
}
log.warn("No transaction logs were detected, but recovery was forced by user.");
}
}
}
}