Beispiel #1
0
 public CountsVisitor_AdapterAnonymousInnerClass(CountsBuilderDecorator outerInstance, ConsistencyReporter reporter, AtomicInteger nodeEntries, AtomicInteger relationshipEntries, ProgressListener listener)
 {
     this.outerInstance        = outerInstance;
     this._reporter            = reporter;
     this._nodeEntries         = nodeEntries;
     this._relationshipEntries = relationshipEntries;
     this._listener            = listener;
 }
Beispiel #2
0
//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);
        }