Search in sources :

Example 1 with LoggingLogTailScannerMonitor

use of org.neo4j.kernel.recovery.LoggingLogTailScannerMonitor in project neo4j by neo4j.

the class Database method start.

/**
 * Start the database and make it ready for transaction processing.
 * A database will automatically recover itself, if necessary, when started.
 * If the store files are obsolete (older than oldest supported version), then start will throw an exception.
 */
@Override
public synchronized void start() {
    if (started) {
        return;
    }
    // Ensure we're initialized
    init();
    try {
        // Upgrade the store before we begin
        upgradeStore(databaseConfig, databasePageCache, otherDatabaseMemoryTracker);
        // Check the tail of transaction logs and validate version
        LogEntryReader logEntryReader = new VersionAwareLogEntryReader(storageEngineFactory.commandReaderFactory());
        LogFiles logFiles = getLogFiles(logEntryReader);
        databaseMonitors.addMonitorListener(new LoggingLogFileMonitor(msgLog));
        databaseMonitors.addMonitorListener(new LoggingLogTailScannerMonitor(internalLogProvider.getLog(AbstractLogTailScanner.class)));
        databaseMonitors.addMonitorListener(new ReverseTransactionCursorLoggingMonitor(internalLogProvider.getLog(ReversedSingleFileTransactionCursor.class)));
        var pageCacheTracer = tracers.getPageCacheTracer();
        boolean storageExists = storageEngineFactory.storageExists(fs, databaseLayout, databasePageCache);
        validateStoreAndTxLogs(logFiles, pageCacheTracer, storageExists);
        performRecovery(fs, databasePageCache, tracers, databaseConfig, databaseLayout, storageEngineFactory, false, internalLogProvider, databaseMonitors, extensionFactories, Optional.of(logFiles), new RecoveryStartupChecker(startupController, namedDatabaseId), otherDatabaseMemoryTracker, clock);
        // Build all modules and their services
        DatabaseSchemaState databaseSchemaState = new DatabaseSchemaState(internalLogProvider);
        idController.initialize(() -> kernelModule.kernelTransactions().get());
        storageEngine = storageEngineFactory.instantiate(fs, databaseLayout, databaseConfig, databasePageCache, tokenHolders, databaseSchemaState, constraintSemantics, indexProviderMap, lockService, idGeneratorFactory, idController, databaseHealth, internalLogProvider, recoveryCleanupWorkCollector, pageCacheTracer, !storageExists, readOnlyDatabaseChecker, otherDatabaseMemoryTracker);
        MetadataProvider metadataProvider = storageEngine.metadataProvider();
        databaseDependencies.satisfyDependency(metadataProvider);
        // Recreate the logFiles after storage engine to get access to dependencies
        logFiles = getLogFiles(logEntryReader);
        life.add(storageEngine);
        life.add(storageEngine.schemaAndTokensLifecycle());
        life.add(logFiles);
        // Token indexes
        FullScanStoreView fullScanStoreView = new FullScanStoreView(lockService, storageEngine::newReader, databaseConfig, scheduler);
        IndexStoreViewFactory indexStoreViewFactory = new IndexStoreViewFactory(databaseConfig, storageEngine::newReader, locks, fullScanStoreView, lockService, internalLogProvider);
        // Schema indexes
        IndexStatisticsStore indexStatisticsStore = new IndexStatisticsStore(databasePageCache, databaseLayout, recoveryCleanupWorkCollector, readOnlyDatabaseChecker, pageCacheTracer);
        IndexingService indexingService = buildIndexingService(storageEngine, databaseSchemaState, indexStoreViewFactory, indexStatisticsStore, pageCacheTracer, otherDatabaseMemoryTracker);
        databaseDependencies.satisfyDependency(storageEngine.countsAccessor());
        versionContextSupplier.init(metadataProvider::getLastClosedTransactionId);
        CheckPointerImpl.ForceOperation forceOperation = new DefaultForceOperation(indexingService, storageEngine);
        DatabaseTransactionLogModule transactionLogModule = buildTransactionLogs(logFiles, databaseConfig, internalLogProvider, scheduler, forceOperation, logEntryReader, metadataProvider, databaseMonitors, databaseDependencies);
        databaseTransactionEventListeners = new DatabaseTransactionEventListeners(databaseFacade, transactionEventListeners, namedDatabaseId);
        life.add(databaseTransactionEventListeners);
        final DatabaseKernelModule kernelModule = buildKernel(logFiles, transactionLogModule.transactionAppender(), indexingService, databaseSchemaState, storageEngine, metadataProvider, metadataProvider, databaseAvailabilityGuard, clock, indexStatisticsStore, leaseService);
        kernelModule.satisfyDependencies(databaseDependencies);
        // Do these assignments last so that we can ensure no cyclical dependencies exist
        this.kernelModule = kernelModule;
        databaseDependencies.satisfyDependency(databaseSchemaState);
        databaseDependencies.satisfyDependency(logEntryReader);
        databaseDependencies.satisfyDependency(storageEngine);
        databaseDependencies.satisfyDependency(indexingService);
        databaseDependencies.satisfyDependency(indexStoreViewFactory);
        databaseDependencies.satisfyDependency(indexStatisticsStore);
        databaseDependencies.satisfyDependency(indexProviderMap);
        databaseDependencies.satisfyDependency(forceOperation);
        databaseDependencies.satisfyDependency(new DatabaseEntityCounters(this.idGeneratorFactory, databaseDependencies.resolveDependency(CountsAccessor.class)));
        var providerSpi = QueryEngineProvider.spi(internalLogProvider, databaseMonitors, scheduler, life, getKernel(), databaseConfig);
        this.executionEngine = QueryEngineProvider.initialize(databaseDependencies, databaseFacade, engineProvider, isSystem(), providerSpi);
        this.checkpointerLifecycle = new CheckpointerLifecycle(transactionLogModule.checkPointer(), databaseHealth, ioController);
        life.add(databaseHealth);
        life.add(databaseAvailabilityGuard);
        life.add(databaseAvailability);
        life.setLast(checkpointerLifecycle);
        databaseDependencies.resolveDependency(DbmsDiagnosticsManager.class).dumpDatabaseDiagnostics(this);
        life.start();
        registerUpgradeListener();
        eventListeners.databaseStart(namedDatabaseId);
        /*
             * At this point recovery has completed and the database is ready for use. Whatever panic might have
             * happened before has been healed. So we can safely set the kernel health to ok.
             * This right now has any real effect only in the case of internal restarts (for example, after a store copy).
             * Standalone instances will have to be restarted by the user, as is proper for all database panics.
             */
        databaseHealth.healed();
        started = true;
        postStartupInit(storageExists);
    } catch (Throwable e) {
        handleStartupFailure(e);
    }
}
Also used : CheckPointerImpl(org.neo4j.kernel.impl.transaction.log.checkpoint.CheckPointerImpl) RecoveryStartupChecker(org.neo4j.kernel.recovery.RecoveryStartupChecker) LogFiles(org.neo4j.kernel.impl.transaction.log.files.LogFiles) VersionAwareLogEntryReader(org.neo4j.kernel.impl.transaction.log.entry.VersionAwareLogEntryReader) LogEntryReader(org.neo4j.kernel.impl.transaction.log.entry.LogEntryReader) DbmsDiagnosticsManager(org.neo4j.kernel.diagnostics.providers.DbmsDiagnosticsManager) ReverseTransactionCursorLoggingMonitor(org.neo4j.kernel.impl.transaction.log.reverse.ReverseTransactionCursorLoggingMonitor) DatabaseSchemaState(org.neo4j.kernel.impl.api.DatabaseSchemaState) FullScanStoreView(org.neo4j.kernel.impl.transaction.state.storeview.FullScanStoreView) IndexingService(org.neo4j.kernel.impl.api.index.IndexingService) IndexStatisticsStore(org.neo4j.kernel.impl.api.index.stats.IndexStatisticsStore) VersionAwareLogEntryReader(org.neo4j.kernel.impl.transaction.log.entry.VersionAwareLogEntryReader) LoggingLogFileMonitor(org.neo4j.kernel.impl.transaction.log.LoggingLogFileMonitor) CheckpointerLifecycle(org.neo4j.kernel.impl.transaction.log.checkpoint.CheckpointerLifecycle) LoggingLogTailScannerMonitor(org.neo4j.kernel.recovery.LoggingLogTailScannerMonitor) DatabaseEntityCounters(org.neo4j.kernel.impl.store.stats.DatabaseEntityCounters) IndexStoreViewFactory(org.neo4j.kernel.impl.transaction.state.storeview.IndexStoreViewFactory) MetadataProvider(org.neo4j.storageengine.api.MetadataProvider) DatabaseTransactionEventListeners(org.neo4j.kernel.internal.event.DatabaseTransactionEventListeners)

Aggregations

DbmsDiagnosticsManager (org.neo4j.kernel.diagnostics.providers.DbmsDiagnosticsManager)1 DatabaseSchemaState (org.neo4j.kernel.impl.api.DatabaseSchemaState)1 IndexingService (org.neo4j.kernel.impl.api.index.IndexingService)1 IndexStatisticsStore (org.neo4j.kernel.impl.api.index.stats.IndexStatisticsStore)1 DatabaseEntityCounters (org.neo4j.kernel.impl.store.stats.DatabaseEntityCounters)1 LoggingLogFileMonitor (org.neo4j.kernel.impl.transaction.log.LoggingLogFileMonitor)1 CheckPointerImpl (org.neo4j.kernel.impl.transaction.log.checkpoint.CheckPointerImpl)1 CheckpointerLifecycle (org.neo4j.kernel.impl.transaction.log.checkpoint.CheckpointerLifecycle)1 LogEntryReader (org.neo4j.kernel.impl.transaction.log.entry.LogEntryReader)1 VersionAwareLogEntryReader (org.neo4j.kernel.impl.transaction.log.entry.VersionAwareLogEntryReader)1 LogFiles (org.neo4j.kernel.impl.transaction.log.files.LogFiles)1 ReverseTransactionCursorLoggingMonitor (org.neo4j.kernel.impl.transaction.log.reverse.ReverseTransactionCursorLoggingMonitor)1 FullScanStoreView (org.neo4j.kernel.impl.transaction.state.storeview.FullScanStoreView)1 IndexStoreViewFactory (org.neo4j.kernel.impl.transaction.state.storeview.IndexStoreViewFactory)1 DatabaseTransactionEventListeners (org.neo4j.kernel.internal.event.DatabaseTransactionEventListeners)1 LoggingLogTailScannerMonitor (org.neo4j.kernel.recovery.LoggingLogTailScannerMonitor)1 RecoveryStartupChecker (org.neo4j.kernel.recovery.RecoveryStartupChecker)1 MetadataProvider (org.neo4j.storageengine.api.MetadataProvider)1