//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: void execute(final org.neo4j.kernel.api.direct.DirectStoreAccess directStoreAccess, final org.neo4j.consistency.checking.CheckDecorator decorator, final org.neo4j.consistency.store.RecordAccess recordAccess, final org.neo4j.consistency.report.InconsistencyReport report, org.neo4j.consistency.checking.cache.CacheAccess cacheAccess, org.neo4j.consistency.report.ConsistencyReporter.Monitor reportMonitor) throws ConsistencyCheckIncompleteException
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
internal virtual void Execute(DirectStoreAccess directStoreAccess, CheckDecorator decorator, RecordAccess recordAccess, InconsistencyReport report, CacheAccess cacheAccess, ConsistencyReporter.Monitor reportMonitor)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.consistency.report.ConsistencyReporter reporter = new org.neo4j.consistency.report.ConsistencyReporter(recordAccess, report, reportMonitor);
ConsistencyReporter reporter = new ConsistencyReporter(recordAccess, report, reportMonitor);
StoreProcessor processEverything = new StoreProcessor(decorator, reporter, Stage_Fields.SequentialForward, cacheAccess);
ProgressMonitorFactory.MultiPartBuilder progress = _progressFactory.multipleParts("Full Consistency Check");
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.store.StoreAccess nativeStores = directStoreAccess.nativeStores();
StoreAccess nativeStores = directStoreAccess.NativeStores();
try
{
using (IndexAccessors indexes = new IndexAccessors(directStoreAccess.Indexes(), nativeStores.SchemaStore, _samplingConfig))
{
MultiPassStore.Factory multiPass = new MultiPassStore.Factory(decorator, recordAccess, cacheAccess, report, reportMonitor);
ConsistencyCheckTasks taskCreator = new ConsistencyCheckTasks(progress, processEverything, nativeStores, _statistics, cacheAccess, directStoreAccess.LabelScanStore(), indexes, directStoreAccess.TokenHolders(), multiPass, reporter, _threads);
if (_checkIndexStructure)
{
ConsistencyCheckIndexStructure(directStoreAccess.LabelScanStore(), indexes, reporter, _progressFactory);
}
IList <ConsistencyCheckerTask> tasks = taskCreator.CreateTasksForFullCheck(_checkLabelScanStore, _checkIndexes, _checkGraph);
progress.Build();
TaskExecutor.Execute(tasks, decorator.prepare);
}
}
catch (Exception e)
{
throw new ConsistencyCheckIncompleteException(e);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: protected void stop() throws Throwable
protected internal virtual void Stop()
{
if (_directStoreAccess != null)
{
_neoStore.close();
_directStoreAccess.Dispose();
_directStoreAccess = null;
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: org.neo4j.consistency.report.ConsistencySummaryStatistics execute(org.neo4j.kernel.api.direct.DirectStoreAccess stores, org.neo4j.logging.Log log, org.neo4j.consistency.report.ConsistencyReporter.Monitor reportMonitor) throws ConsistencyCheckIncompleteException
internal virtual ConsistencySummaryStatistics Execute(DirectStoreAccess stores, Log log, ConsistencyReporter.Monitor reportMonitor)
{
ConsistencySummaryStatistics summary = new ConsistencySummaryStatistics();
InconsistencyReport report = new InconsistencyReport(new InconsistencyMessageLogger(log), summary);
OwnerCheck ownerCheck = new OwnerCheck(_checkPropertyOwners);
CountsBuilderDecorator countsBuilder = new CountsBuilderDecorator(stores.NativeStores());
CheckDecorator decorator = new Org.Neo4j.Consistency.checking.CheckDecorator_ChainCheckDecorator(ownerCheck, countsBuilder);
CacheAccess cacheAccess = new DefaultCacheAccess(AUTO_WITHOUT_PAGECACHE.newByteArray(stores.NativeStores().NodeStore.HighId, new sbyte[ByteArrayBitsManipulator.MAX_BYTES]), _statistics.Counts, _threads);
RecordAccess records = RecordAccess(stores.NativeStores(), cacheAccess);
Execute(stores, decorator, records, report, cacheAccess, reportMonitor);
ownerCheck.ScanForOrphanChains(_progressFactory);
if (_checkGraph)
{
CountsAccessor countsAccessor = stores.NativeStores().Counts;
bool checkCounts = true;
if (_startCountsStore && countsAccessor is CountsTracker)
{
CountsTracker tracker = ( CountsTracker )countsAccessor;
// Perhaps other read-only use cases thinks it's fine to just rebuild an in-memory counts store,
// but the consistency checker should instead prevent rebuild and report that the counts store is broken or missing
tracker.Initializer = new RebuildPreventingCountsInitializer(this);
try
{
tracker.Start();
}
catch (Exception e)
{
log.Error("Counts store is missing, broken or of an older format and will not be consistency checked", e);
summary.Update(RecordType.COUNTS, 1, 0);
checkCounts = false;
}
}
if (checkCounts)
{
countsBuilder.CheckCounts(countsAccessor, new ConsistencyReporter(records, report), _progressFactory);
}
}
if (!summary.Consistent)
{
log.Warn("Inconsistencies found: " + summary);
}
return(summary);
}
private DirectStoreAccess DirectStoreAccess(bool readOnly)
{
if (_directStoreAccess == null)
{
_life.start();
JobScheduler scheduler = _life.add(JobSchedulerFactory.createInitialisedScheduler());
_fileSystem = new DefaultFileSystemAbstraction();
PageCache pageCache = GetPageCache(_fileSystem);
LogProvider logProvider = NullLogProvider.Instance;
Config config = Config.defaults(GraphDatabaseSettings.read_only, readOnly ? TRUE : FALSE);
DefaultIdGeneratorFactory idGeneratorFactory = new DefaultIdGeneratorFactory(_fileSystem);
StoreFactory storeFactory = new StoreFactory(_directory.databaseLayout(), config, idGeneratorFactory, pageCache, _fileSystem, logProvider, EmptyVersionContextSupplier.EMPTY);
_neoStore = storeFactory.OpenAllNeoStores();
StoreAccess nativeStores;
if (_keepStatistics)
{
AccessStatistics accessStatistics = new AccessStatistics();
_statistics = new VerboseStatistics(accessStatistics, new DefaultCounts(defaultConsistencyCheckThreadsNumber()), NullLog.Instance);
nativeStores = new AccessStatsKeepingStoreAccess(_neoStore, accessStatistics);
}
else
{
_statistics = Statistics.NONE;
nativeStores = new StoreAccess(_neoStore);
}
nativeStores.Initialize();
IndexStoreView indexStoreView = new NeoStoreIndexStoreView(LockService.NO_LOCK_SERVICE, nativeStores.RawNeoStores);
Monitors monitors = new Monitors();
LabelScanStore labelScanStore = StartLabelScanStore(pageCache, indexStoreView, monitors, readOnly);
IndexProviderMap indexes = CreateIndexes(pageCache, _fileSystem, _directory.databaseDir(), config, scheduler, logProvider, monitors);
TokenHolders tokenHolders = new TokenHolders(new DelegatingTokenHolder(new ReadOnlyTokenCreator(), Org.Neo4j.Kernel.impl.core.TokenHolder_Fields.TYPE_PROPERTY_KEY), new DelegatingTokenHolder(new ReadOnlyTokenCreator(), Org.Neo4j.Kernel.impl.core.TokenHolder_Fields.TYPE_LABEL), new DelegatingTokenHolder(new ReadOnlyTokenCreator(), Org.Neo4j.Kernel.impl.core.TokenHolder_Fields.TYPE_RELATIONSHIP_TYPE));
tokenHolders.PropertyKeyTokens().InitialTokens = _neoStore.PropertyKeyTokenStore.Tokens;
tokenHolders.LabelTokens().InitialTokens = _neoStore.LabelTokenStore.Tokens;
tokenHolders.RelationshipTypeTokens().InitialTokens = _neoStore.RelationshipTypeTokenStore.Tokens;
_directStoreAccess = new DirectStoreAccess(nativeStores, labelScanStore, indexes, tokenHolders);
}
return(_directStoreAccess);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.neo4j.consistency.report.ConsistencySummaryStatistics execute(org.neo4j.kernel.api.direct.DirectStoreAccess stores, org.neo4j.logging.Log log) throws ConsistencyCheckIncompleteException
public virtual ConsistencySummaryStatistics Execute(DirectStoreAccess stores, Log log)
{
return(Execute(stores, log, NO_MONITOR));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public Result runFullConsistencyCheck(org.neo4j.io.layout.DatabaseLayout databaseLayout, org.neo4j.kernel.configuration.Config config, org.neo4j.helpers.progress.ProgressMonitorFactory progressFactory, final org.neo4j.logging.LogProvider logProvider, final org.neo4j.io.fs.FileSystemAbstraction fileSystem, final org.neo4j.io.pagecache.PageCache pageCache, final boolean verbose, java.io.File reportDir, org.neo4j.consistency.checking.full.ConsistencyFlags consistencyFlags) throws org.neo4j.consistency.checking.full.ConsistencyCheckIncompleteException
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
public virtual Result RunFullConsistencyCheck(DatabaseLayout databaseLayout, Config config, ProgressMonitorFactory progressFactory, LogProvider logProvider, FileSystemAbstraction fileSystem, PageCache pageCache, bool verbose, File reportDir, ConsistencyFlags consistencyFlags)
{
AssertRecovered(databaseLayout, config, fileSystem, pageCache);
Log log = logProvider.getLog(this.GetType());
config.augment(GraphDatabaseSettings.read_only, TRUE);
config.augment(GraphDatabaseSettings.pagecache_warmup_enabled, FALSE);
StoreFactory factory = new StoreFactory(databaseLayout, config, new DefaultIdGeneratorFactory(fileSystem), pageCache, fileSystem, logProvider, EmptyVersionContextSupplier.EMPTY);
ConsistencySummaryStatistics summary;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.io.File reportFile = chooseReportPath(reportDir);
File reportFile = ChooseReportPath(reportDir);
Suppliers.Lazy <PrintWriter> reportWriterSupplier = GetReportWriterSupplier(fileSystem, reportFile);
Log reportLog = new ConsistencyReportLog(reportWriterSupplier);
// Bootstrap kernel extensions
Monitors monitors = new Monitors();
LifeSupport life = new LifeSupport();
JobScheduler jobScheduler = life.Add(JobSchedulerFactory.createInitialisedScheduler());
TokenHolders tokenHolders = new TokenHolders(new DelegatingTokenHolder(new ReadOnlyTokenCreator(), Org.Neo4j.Kernel.impl.core.TokenHolder_Fields.TYPE_PROPERTY_KEY), new DelegatingTokenHolder(new ReadOnlyTokenCreator(), Org.Neo4j.Kernel.impl.core.TokenHolder_Fields.TYPE_LABEL), new DelegatingTokenHolder(new ReadOnlyTokenCreator(), Org.Neo4j.Kernel.impl.core.TokenHolder_Fields.TYPE_RELATIONSHIP_TYPE));
DatabaseKernelExtensions extensions = life.Add(instantiateKernelExtensions(databaseLayout.DatabaseDirectory(), fileSystem, config, new SimpleLogService(logProvider, logProvider), pageCache, jobScheduler, RecoveryCleanupWorkCollector.ignore(), TOOL, monitors, tokenHolders));
DefaultIndexProviderMap indexes = life.Add(new DefaultIndexProviderMap(extensions, config));
try
{
using (NeoStores neoStores = factory.OpenAllNeoStores())
{
// Load tokens before starting extensions, etc.
tokenHolders.PropertyKeyTokens().InitialTokens = neoStores.PropertyKeyTokenStore.Tokens;
tokenHolders.LabelTokens().InitialTokens = neoStores.LabelTokenStore.Tokens;
tokenHolders.RelationshipTypeTokens().InitialTokens = neoStores.RelationshipTypeTokenStore.Tokens;
life.Start();
LabelScanStore labelScanStore = new NativeLabelScanStore(pageCache, databaseLayout, fileSystem, Org.Neo4j.Kernel.Impl.Api.scan.FullStoreChangeStream_Fields.Empty, true, monitors, RecoveryCleanupWorkCollector.ignore());
life.Add(labelScanStore);
int numberOfThreads = DefaultConsistencyCheckThreadsNumber();
Statistics statistics;
StoreAccess storeAccess;
AccessStatistics stats = new AccessStatistics();
if (verbose)
{
statistics = new VerboseStatistics(stats, new DefaultCounts(numberOfThreads), log);
storeAccess = new AccessStatsKeepingStoreAccess(neoStores, stats);
}
else
{
statistics = Statistics.NONE;
storeAccess = new StoreAccess(neoStores);
}
storeAccess.Initialize();
DirectStoreAccess stores = new DirectStoreAccess(storeAccess, labelScanStore, indexes, tokenHolders);
FullCheck check = new FullCheck(progressFactory, statistics, numberOfThreads, consistencyFlags, config, true);
summary = check.Execute(stores, new DuplicatingLog(log, reportLog));
}
}
finally
{
life.Shutdown();
if (reportWriterSupplier.Initialised)
{
reportWriterSupplier.get().close();
}
}
if (!summary.Consistent)
{
log.Warn("See '%s' for a detailed consistency report.", reportFile.Path);
return(Result.failure(reportFile));
}
return(Result.success(reportFile));
}
