//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private ConsistencyCheckService.Result runConsistencyCheck(org.neo4j.helpers.progress.ProgressMonitorFactory progressFactory, org.neo4j.kernel.configuration.Config config) throws org.neo4j.consistency.checking.full.ConsistencyCheckIncompleteException
private ConsistencyCheckService.Result RunConsistencyCheck(ProgressMonitorFactory progressFactory, Config config)
{
ConsistencyCheckService consistencyCheckService = new ConsistencyCheckService();
DatabaseLayout databaseLayout = DatabaseLayout.of(_testDirectory.storeDir());
LogProvider logProvider = NullLogProvider.Instance;
return(consistencyCheckService.RunFullConsistencyCheck(databaseLayout, config, progressFactory, logProvider, false));
}
internal BackupStrategyCoordinator(ConsistencyCheckService consistencyCheckService, OutsideWorld outsideWorld, LogProvider logProvider, ProgressMonitorFactory progressMonitorFactory, IList <BackupStrategyWrapper> strategies)
{
this._consistencyCheckService = consistencyCheckService;
this._outsideWorld = outsideWorld;
this._logProvider = logProvider;
this._progressMonitorFactory = progressMonitorFactory;
this._strategies = strategies;
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldReportProgress() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldReportProgress()
{
Setup(GraphDatabaseSettings.SchemaIndex.NATIVE_BTREE10);
Writer writer = new StringWriter();
ProgressMonitorFactory factory = ProgressMonitorFactory.textual(writer);
ConsistencyCheckService.Result result = RunConsistencyCheck(factory);
assertTrue("Expected new database to be clean.", result.Successful);
assertTrue(writer.ToString().Contains("Index structure consistency check"));
}
public FullCheck(ProgressMonitorFactory progressFactory, Statistics statistics, int threads, ConsistencyFlags consistencyFlags, Config config, bool startCountsStore)
{
this._statistics = statistics;
this._threads = threads;
this._progressFactory = progressFactory;
this._samplingConfig = new IndexSamplingConfig(config);
this._checkGraph = consistencyFlags.CheckGraph;
this._checkIndexes = consistencyFlags.CheckIndexes;
this._checkIndexStructure = consistencyFlags.CheckIndexStructure;
this._checkLabelScanStore = consistencyFlags.CheckLabelScanStore;
this._checkPropertyOwners = consistencyFlags.CheckPropertyOwners;
this._startCountsStore = startCountsStore;
}
/// <summary>
/// Construct a wrapper of supported backup strategies
/// </summary>
/// <param name="onlineBackupContext"> the input of the backup tool, such as CLI arguments, config etc. </param>
/// <param name="backupProtocolService"> the underlying backup implementation for HA and single node instances </param>
/// <param name="backupDelegator"> the backup implementation used for CC backups </param>
/// <param name="pageCache"> the page cache used moving files </param>
/// <returns> strategy coordinator that handles the which backup strategies are tried and establishes if a backup was successful or not </returns>
internal virtual BackupStrategyCoordinator BackupStrategyCoordinator(OnlineBackupContext onlineBackupContext, BackupProtocolService backupProtocolService, BackupDelegator backupDelegator, PageCache pageCache)
{
FileSystemAbstraction fs = _outsideWorld.fileSystem();
BackupCopyService copyService = new BackupCopyService(fs, new FileMoveProvider(fs));
ProgressMonitorFactory progressMonitorFactory = ProgressMonitorFactory.textual(_outsideWorld.errorStream());
BackupRecoveryService recoveryService = new BackupRecoveryService();
long timeout = onlineBackupContext.RequiredArguments.Timeout;
Config config = onlineBackupContext.Config;
StoreFiles storeFiles = new StoreFiles(fs, pageCache);
BackupStrategy ccStrategy = new CausalClusteringBackupStrategy(backupDelegator, _addressResolver, _logProvider, storeFiles);
BackupStrategy haStrategy = new HaBackupStrategy(backupProtocolService, _addressResolver, _logProvider, timeout);
BackupStrategyWrapper ccStrategyWrapper = Wrap(ccStrategy, copyService, pageCache, config, recoveryService);
BackupStrategyWrapper haStrategyWrapper = Wrap(haStrategy, copyService, pageCache, config, recoveryService);
StrategyResolverService strategyResolverService = new StrategyResolverService(haStrategyWrapper, ccStrategyWrapper);
IList <BackupStrategyWrapper> strategies = strategyResolverService.GetStrategies(onlineBackupContext.RequiredArguments.SelectedBackupProtocol);
return(new BackupStrategyCoordinator(_consistencyCheckService, _outsideWorld, _logProvider, progressMonitorFactory, strategies));
}
internal virtual void ScanForOrphanChains(ProgressMonitorFactory progressFactory)
{
IList <ThreadStart> tasks = new List <ThreadStart>();
ProgressMonitorFactory.MultiPartBuilder progress = progressFactory.MultipleParts("Checking for orphan chains");
if (_owners != null)
{
tasks.Add(new OrphanCheck(RecordType.PROPERTY, _owners, progress));
}
if (_dynamics != null)
{
foreach (KeyValuePair <RecordType, ConcurrentMap <long, DynamicOwner> > entry in _dynamics.SetOfKeyValuePairs())
{
tasks.Add(new OrphanCheck(entry.Key, entry.Value, progress));
}
}
foreach (ThreadStart task in tasks)
{
task.run();
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private ConsistencyCheckService.Result runConsistencyCheck(org.neo4j.helpers.progress.ProgressMonitorFactory progressFactory) throws org.neo4j.consistency.checking.full.ConsistencyCheckIncompleteException
private ConsistencyCheckService.Result RunConsistencyCheck(ProgressMonitorFactory progressFactory)
{
return(RunConsistencyCheck(progressFactory, Config(Settings.TRUE, Settings.TRUE)));
}
//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, org.neo4j.logging.LogProvider logProvider, boolean verbose, org.neo4j.consistency.checking.full.ConsistencyFlags consistencyFlags) throws org.neo4j.consistency.checking.full.ConsistencyCheckIncompleteException
public virtual Result RunFullConsistencyCheck(DatabaseLayout databaseLayout, Config config, ProgressMonitorFactory progressFactory, LogProvider logProvider, bool verbose, ConsistencyFlags consistencyFlags)
{
FileSystemAbstraction fileSystem = new DefaultFileSystemAbstraction();
try
{
return(RunFullConsistencyCheck(databaseLayout, config, progressFactory, logProvider, fileSystem, verbose, consistencyFlags));
}
finally
{
try
{
fileSystem.Dispose();
}
catch (IOException e)
{
Log log = logProvider.getLog(this.GetType());
log.Error("Failure during shutdown of file system", e);
}
}
}
AggregatedProgressMonitor CreateProgressMonitor(ProgressMonitorStatusMessage progressMessage)
{
var factory = new ProgressMonitorFactory();
return((AggregatedProgressMonitor)factory.CreateProgressMonitor(progressMessage.Status));
}
private void AssertDatabaseConsistent()
{
LogProvider logProvider = FormattedLogProvider.toOutputStream(System.out);
try
{
ConsistencyCheckService.Result result = (new ConsistencyCheckService()).runFullConsistencyCheck(_testDirectory.databaseLayout(), Config.defaults(), ProgressMonitorFactory.textual(System.err), logProvider, false);
assertTrue(result.Successful);
}
catch (ConsistencyCheckIncompleteException e)
{
fail(e.Message);
}
}
public virtual Result RunFullConsistencyCheck(DatabaseLayout databaseLayout, Config tuningConfiguration, ProgressMonitorFactory progressFactory, LogProvider logProvider, bool verbose)
{
return(RunFullConsistencyCheck(databaseLayout, tuningConfiguration, progressFactory, logProvider, verbose, new ConsistencyFlags(tuningConfiguration)));
}
//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));
}
public virtual Result RunFullConsistencyCheck(DatabaseLayout databaseLayout, Config tuningConfiguration, ProgressMonitorFactory progressFactory, LogProvider logProvider, FileSystemAbstraction fileSystem, PageCache pageCache, bool verbose, File reportDir)
{
return(RunFullConsistencyCheck(databaseLayout, tuningConfiguration, progressFactory, logProvider, fileSystem, pageCache, verbose, reportDir, new ConsistencyFlags(tuningConfiguration)));
}
//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, 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, ConsistencyFlags consistencyFlags)
{
return(RunFullConsistencyCheck(databaseLayout, config, progressFactory, logProvider, fileSystem, pageCache, verbose, DefaultReportDir(config, databaseLayout.DatabaseDirectory()), consistencyFlags));
}
//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, org.neo4j.logging.LogProvider logProvider, org.neo4j.io.fs.FileSystemAbstraction fileSystem, boolean verbose, java.io.File reportDir, org.neo4j.consistency.checking.full.ConsistencyFlags consistencyFlags) throws org.neo4j.consistency.checking.full.ConsistencyCheckIncompleteException
public virtual Result RunFullConsistencyCheck(DatabaseLayout databaseLayout, Config config, ProgressMonitorFactory progressFactory, LogProvider logProvider, FileSystemAbstraction fileSystem, bool verbose, File reportDir, ConsistencyFlags consistencyFlags)
{
Log log = logProvider.getLog(this.GetType());
JobScheduler jobScheduler = JobSchedulerFactory.createInitialisedScheduler();
ConfiguringPageCacheFactory pageCacheFactory = new ConfiguringPageCacheFactory(fileSystem, config, PageCacheTracer.NULL, Org.Neo4j.Io.pagecache.tracing.cursor.PageCursorTracerSupplier_Fields.Null, logProvider.GetLog(typeof(PageCache)), EmptyVersionContextSupplier.EMPTY, jobScheduler);
PageCache pageCache = pageCacheFactory.OrCreatePageCache;
try
{
return(RunFullConsistencyCheck(databaseLayout, config, progressFactory, logProvider, fileSystem, pageCache, verbose, reportDir, consistencyFlags));
}
finally
{
try
{
pageCache.Close();
}
catch (Exception e)
{
log.Error("Failure during shutdown of the page cache", e);
}
try
{
jobScheduler.close();
}
catch (Exception e)
{
log.Error("Failure during shutdown of the job scheduler", e);
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void execute(String[] args) throws org.neo4j.commandline.admin.IncorrectUsage, org.neo4j.commandline.admin.CommandFailed
public override void Execute(string[] args)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final String database;
string database;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final boolean verbose;
bool verbose;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.Optional<java.nio.file.Path> additionalConfigFile;
Optional <Path> additionalConfigFile;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.nio.file.Path reportDir;
Path reportDir;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.Optional<java.nio.file.Path> backupPath;
Optional <Path> backupPath;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final boolean checkGraph;
bool checkGraph;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final boolean checkIndexes;
bool checkIndexes;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final boolean checkIndexStructure;
bool checkIndexStructure;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final boolean checkLabelScanStore;
bool checkLabelScanStore;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final boolean checkPropertyOwners;
bool checkPropertyOwners;
try
{
database = _arguments.parse(args).get(ARG_DATABASE);
backupPath = _arguments.getOptionalPath("backup");
verbose = _arguments.getBoolean("verbose");
additionalConfigFile = _arguments.getOptionalPath("additional-config");
reportDir = _arguments.getOptionalPath("report-dir").orElseThrow(() => new System.ArgumentException("report-dir must be a valid path"));
}
catch (System.ArgumentException e)
{
throw new IncorrectUsage(e.Message);
}
if (backupPath.Present)
{
if (_arguments.has(ARG_DATABASE))
{
throw new IncorrectUsage("Only one of '--" + ARG_DATABASE + "' and '--backup' can be specified.");
}
if (!backupPath.get().toFile().Directory)
{
throw new CommandFailed(format("Specified backup should be a directory: %s", backupPath.get()));
}
}
Config config = LoadNeo4jConfig(_homeDir, _configDir, database, LoadAdditionalConfig(additionalConfigFile));
try
{
// We can remove the loading from config file in 4.0
if (_arguments.has(CHECK_GRAPH))
{
checkGraph = _arguments.getBoolean(CHECK_GRAPH);
}
else
{
checkGraph = config.Get(ConsistencyCheckSettings.ConsistencyCheckGraph);
}
if (_arguments.has(CHECK_INDEXES))
{
checkIndexes = _arguments.getBoolean(CHECK_INDEXES);
}
else
{
checkIndexes = config.Get(ConsistencyCheckSettings.ConsistencyCheckIndexes);
}
if (_arguments.has(CHECK_INDEX_STRUCTURE))
{
checkIndexStructure = _arguments.getBoolean(CHECK_INDEX_STRUCTURE);
}
else
{
checkIndexStructure = config.Get(ConsistencyCheckSettings.ConsistencyCheckIndexStructure);
}
if (_arguments.has(CHECK_LABEL_SCAN_STORE))
{
checkLabelScanStore = _arguments.getBoolean(CHECK_LABEL_SCAN_STORE);
}
else
{
checkLabelScanStore = config.Get(ConsistencyCheckSettings.ConsistencyCheckLabelScanStore);
}
if (_arguments.has(CHECK_PROPERTY_OWNERS))
{
checkPropertyOwners = _arguments.getBoolean(CHECK_PROPERTY_OWNERS);
}
else
{
checkPropertyOwners = config.Get(ConsistencyCheckSettings.ConsistencyCheckPropertyOwners);
}
}
catch (System.ArgumentException e)
{
throw new IncorrectUsage(e.Message);
}
try
{
using (FileSystemAbstraction fileSystem = new DefaultFileSystemAbstraction())
{
File databaseDirectory = backupPath.map(Path.toFile).orElse(config.Get(database_path));
DatabaseLayout databaseLayout = DatabaseLayout.of(databaseDirectory);
CheckDbState(databaseLayout, config);
ZoneId logTimeZone = config.Get(GraphDatabaseSettings.db_timezone).ZoneId;
// Only output progress indicator if a console receives the output
ProgressMonitorFactory progressMonitorFactory = ProgressMonitorFactory.NONE;
if (System.console() != null)
{
progressMonitorFactory = ProgressMonitorFactory.textual(System.out);
}
ConsistencyCheckService.Result consistencyCheckResult = _consistencyCheckService.runFullConsistencyCheck(databaseLayout, config, progressMonitorFactory, FormattedLogProvider.withZoneId(logTimeZone).toOutputStream(System.out), fileSystem, verbose, reportDir.toFile(), new ConsistencyFlags(checkGraph, checkIndexes, checkIndexStructure, checkLabelScanStore, checkPropertyOwners));
if (!consistencyCheckResult.Successful)
{
throw new CommandFailed(format("Inconsistencies found. See '%s' for details.", consistencyCheckResult.ReportFile()));
}
}
}
catch (Exception e) when(e is ConsistencyCheckIncompleteException || e is IOException)
{
throw new CommandFailed("Consistency checking failed." + e.Message, e);
}
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: public void checkCounts(org.neo4j.kernel.impl.api.CountsAccessor counts, final org.neo4j.consistency.report.ConsistencyReporter reporter, org.neo4j.helpers.progress.ProgressMonitorFactory progressFactory)
public virtual void CheckCounts(CountsAccessor counts, ConsistencyReporter reporter, ProgressMonitorFactory progressFactory)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int nodes = nodeCounts.size();
int nodes = _nodeCounts.size();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int relationships = relationshipCounts.size();
int relationships = _relationshipCounts.size();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int total = nodes + relationships;
int total = nodes + relationships;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicInteger nodeEntries = new java.util.concurrent.atomic.AtomicInteger(0);
AtomicInteger nodeEntries = new AtomicInteger(0);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicInteger relationshipEntries = new java.util.concurrent.atomic.AtomicInteger(0);
AtomicInteger relationshipEntries = new AtomicInteger(0);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.helpers.progress.ProgressListener listener = progressFactory.singlePart("Checking node and relationship counts", total);
ProgressListener listener = progressFactory.SinglePart("Checking node and relationship counts", total);
listener.Started();
Counts.accept(new CountsVisitor_AdapterAnonymousInnerClass(this, reporter, nodeEntries, relationshipEntries, listener));
reporter.ForCounts(new CountsEntry(nodeKey(WILDCARD), nodeEntries.get()), CHECK_NODE_KEY_COUNT);
reporter.ForCounts(new CountsEntry(relationshipKey(WILDCARD, WILDCARD, WILDCARD), relationshipEntries.get()), CHECK_RELATIONSHIP_KEY_COUNT);
listener.Done();
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: ConsistencyCheckService.Result run(String... args) throws ToolFailureException
internal virtual ConsistencyCheckService.Result Run(params string[] args)
{
Args arguments = Args.withFlags(VERBOSE).parse(args);
File storeDir = DetermineStoreDirectory(arguments);
Config tuningConfiguration = ReadConfiguration(arguments);
bool verbose = IsVerbose(arguments);
DatabaseLayout databaseLayout = DatabaseLayout.of(storeDir);
CheckDbState(databaseLayout, tuningConfiguration);
ZoneId logTimeZone = tuningConfiguration.Get(GraphDatabaseSettings.db_timezone).ZoneId;
LogProvider logProvider = FormattedLogProvider.withZoneId(logTimeZone).toOutputStream(_systemOut);
try
{
return(_consistencyCheckService.runFullConsistencyCheck(databaseLayout, tuningConfiguration, ProgressMonitorFactory.textual(_systemError), logProvider, _fs, verbose, new ConsistencyFlags(tuningConfiguration)));
}
catch (ConsistencyCheckIncompleteException e)
{
throw new ToolFailureException("Check aborted due to exception", e);
}
}
private static void ConsistencyCheckIndexStructure(LabelScanStore labelScanStore, IndexAccessors indexes, ConsistencyReporter report, ProgressMonitorFactory progressMonitorFactory)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final long schemaIndexCount = org.neo4j.helpers.collection.Iterables.count(indexes.onlineRules());
long schemaIndexCount = Iterables.count(indexes.OnlineRules());
const long additionalCount = 1; // LabelScanStore
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final long totalCount = schemaIndexCount + additionalCount;
long totalCount = schemaIndexCount + additionalCount;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.helpers.progress.ProgressListener listener = progressMonitorFactory.singlePart("Index structure consistency check", totalCount);
ProgressListener listener = progressMonitorFactory.SinglePart("Index structure consistency check", totalCount);
listener.Started();
ConsistencyCheckLabelScanStore(labelScanStore, report, listener);
ConsistencyCheckSchemaIndexes(indexes, report, listener);
listener.Done();
}
public FullCheck(Config config, ProgressMonitorFactory progressFactory, Statistics statistics, int threads, bool startCountsStore) : this(progressFactory, statistics, threads, new ConsistencyFlags(config), config, startCountsStore)
{
}
internal HttpCopier(OutsideWorld outsideWorld) : this(outsideWorld, Thread.sleep, (text, length)->ProgressMonitorFactory.textual(outsideWorld.OutStream()).singlePart(text, length))
{
}
