internal virtual void InstantiateTree(RecoveryCleanupWorkCollector recoveryCleanupWorkCollector, System.Action <PageCursor> headerWriter)
{
EnsureDirectoryExist();
GBPTree.Monitor monitor = TreeMonitor();
Tree = new GBPTree <KEY, VALUE>(PageCache, StoreFile, Layout, 0, monitor, NO_HEADER_READER, headerWriter, recoveryCleanupWorkCollector, _readOnly);
AfterTreeInstantiation(Tree);
}
private void EnsureTreeInstantiated()
{
if (tree == null)
{
instantiateTree(RecoveryCleanupWorkCollector.ignore(), NO_HEADER_WRITER);
}
}
protected internal NativeIndexProvider(IndexProviderDescriptor descriptor, Factory directoryStructureFactory, PageCache pageCache, FileSystemAbstraction fs, Monitor monitor, RecoveryCleanupWorkCollector recoveryCleanupWorkCollector, bool readOnly) : base(descriptor, directoryStructureFactory)
{
this.PageCache = pageCache;
this.Fs = fs;
this.Monitor = monitor;
this.RecoveryCleanupWorkCollector = recoveryCleanupWorkCollector;
this.ReadOnly = readOnly;
}
public TemporalIndexProvider(PageCache pageCache, FileSystemAbstraction fs, IndexDirectoryStructure.Factory directoryStructure, Monitor monitor, RecoveryCleanupWorkCollector recoveryCleanupWorkCollector, bool readOnly) : base(_temporalProviderDescriptor, directoryStructure)
{
this._pageCache = pageCache;
this._fs = fs;
this._monitor = monitor;
this._recoveryCleanupWorkCollector = recoveryCleanupWorkCollector;
this._readOnly = readOnly;
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void setupIndex() throws java.io.IOException
private void SetupIndex()
{
RecoveryCleanupWorkCollector recoveryCleanupWorkCollector = RecoveryCleanupWorkCollector.Immediate();
bool readOnly = true;
// tree = new GBPTree<>( pageCache, indexFile, layout, pageSize, NO_MONITOR, NO_HEADER_READER, NO_HEADER_WRITER,
// RecoveryCleanupWorkCollector.immediate() );
_tree = new GBPTree <MutableLong, MutableLong>(_pageCache, _indexFile, _layout, _pageSize, NO_MONITOR, NO_HEADER_READER, NO_HEADER_WRITER, recoveryCleanupWorkCollector, readOnly);
}
public SpatialIndexProvider(PageCache pageCache, FileSystemAbstraction fs, IndexDirectoryStructure.Factory directoryStructure, Monitor monitor, RecoveryCleanupWorkCollector recoveryCleanupWorkCollector, bool readOnly, Config config) : base(_spatialProviderDescriptor, directoryStructure)
{
this._pageCache = pageCache;
this._fs = fs;
this._monitor = monitor;
this._recoveryCleanupWorkCollector = recoveryCleanupWorkCollector;
this._readOnly = readOnly;
this._configuration = SpaceFillingCurveSettingsFactory.getConfiguredSpaceFillingCurveConfiguration(config);
this._configuredSettings = GetConfiguredSpaceFillingCurveSettings(config);
}
internal PartFactory(PageCache pageCache, FileSystemAbstraction fs, RecoveryCleanupWorkCollector recoveryCleanupWorkCollector, IndexProvider.Monitor monitor, StoreIndexDescriptor descriptor, SpatialIndexFiles spatialIndexFiles, SpaceFillingCurveConfiguration searchConfiguration, bool readOnly)
{
this.PageCache = pageCache;
this.Fs = fs;
this.RecoveryCleanupWorkCollector = recoveryCleanupWorkCollector;
this.Monitor = monitor;
this.Descriptor = descriptor;
this.SpatialIndexFiles = spatialIndexFiles;
this.SearchConfiguration = searchConfiguration;
this.ReadOnly = readOnly;
}
internal PartFactory(PageCache pageCache, FileSystemAbstraction fs, RecoveryCleanupWorkCollector recoveryCleanupWorkCollector, IndexProvider.Monitor monitor, StoreIndexDescriptor descriptor, IndexSamplingConfig samplingConfig, TemporalIndexFiles temporalIndexFiles, bool readOnly)
{
this.PageCache = pageCache;
this.Fs = fs;
this.RecoveryCleanupWorkCollector = recoveryCleanupWorkCollector;
this.Monitor = monitor;
this.Descriptor = descriptor;
this.SamplingConfig = samplingConfig;
this.TemporalIndexFiles = temporalIndexFiles;
this.ReadOnly = readOnly;
}
/*
* Test access to be able to control page size.
*/
internal NativeLabelScanStore(PageCache pageCache, DatabaseLayout directoryStructure, FileSystemAbstraction fs, FullStoreChangeStream fullStoreChangeStream, bool readOnly, Monitors monitors, RecoveryCleanupWorkCollector recoveryCleanupWorkCollector, int pageSize)
{
this._pageCache = pageCache;
this._fs = fs;
this._pageSize = pageSize;
this._fullStoreChangeStream = fullStoreChangeStream;
this._directoryStructure = directoryStructure;
this._storeFile = GetLabelScanStoreFile(directoryStructure);
this._readOnly = readOnly;
this._monitors = monitors;
this._monitor = monitors.NewMonitor(typeof(Org.Neo4j.Kernel.api.labelscan.LabelScanStore_Monitor));
this._recoveryCleanupWorkCollector = recoveryCleanupWorkCollector;
this._fileSystem = fs;
}
internal ModularDatabaseCreationContext(string databaseName, PlatformModule platformModule, DatabaseEditionContext editionContext, Procedures procedures, GraphDatabaseFacade facade)
{
this._databaseName = databaseName;
this._config = platformModule.Config;
DatabaseIdContext idContext = editionContext.IdContext;
this._idGeneratorFactory = idContext.IdGeneratorFactory;
this._idController = idContext.IdController;
this._databaseLayout = platformModule.StoreLayout.databaseLayout(databaseName);
this._logService = platformModule.Logging;
this._scheduler = platformModule.JobScheduler;
this._globalDependencies = platformModule.Dependencies;
this._tokenHolders = editionContext.CreateTokenHolders();
this._tokenNameLookup = new NonTransactionalTokenNameLookup(_tokenHolders);
this._locks = editionContext.CreateLocks();
this._statementLocksFactory = editionContext.CreateStatementLocksFactory();
this._schemaWriteGuard = editionContext.SchemaWriteGuard;
this._transactionEventHandlers = new TransactionEventHandlers(facade);
this._monitors = new Monitors(platformModule.Monitors);
this._indexingServiceMonitor = _monitors.newMonitor(typeof(IndexingService.Monitor));
this._physicalLogMonitor = _monitors.newMonitor(typeof(LogFileCreationMonitor));
this._fs = platformModule.FileSystem;
this._transactionStats = editionContext.CreateTransactionMonitor();
this._databaseHealth = new DatabaseHealth(platformModule.PanicEventGenerator, _logService.getInternalLog(typeof(DatabaseHealth)));
this._transactionHeaderInformationFactory = editionContext.HeaderInformationFactory;
this._commitProcessFactory = editionContext.CommitProcessFactory;
this._autoIndexing = new InternalAutoIndexing(platformModule.Config, _tokenHolders.propertyKeyTokens());
this._indexConfigStore = new IndexConfigStore(_databaseLayout, _fs);
this._explicitIndexProvider = new DefaultExplicitIndexProvider();
this._pageCache = platformModule.PageCache;
this._constraintSemantics = editionContext.ConstraintSemantics;
this._tracers = platformModule.Tracers;
this._procedures = procedures;
this._ioLimiter = editionContext.IoLimiter;
this._clock = platformModule.Clock;
this._databaseAvailabilityGuard = editionContext.CreateDatabaseAvailabilityGuard(_clock, _logService, _config);
this._databaseAvailability = new DatabaseAvailability(_databaseAvailabilityGuard, _transactionStats, platformModule.Clock, AwaitActiveTransactionDeadlineMillis);
this._coreAPIAvailabilityGuard = new CoreAPIAvailabilityGuard(_databaseAvailabilityGuard, editionContext.TransactionStartTimeout);
this._accessCapability = editionContext.AccessCapability;
this._storeCopyCheckPointMutex = new StoreCopyCheckPointMutex();
this._recoveryCleanupWorkCollector = platformModule.RecoveryCleanupWorkCollector;
this._databaseInfo = platformModule.DatabaseInfo;
this._versionContextSupplier = platformModule.VersionContextSupplier;
this._collectionsFactorySupplier = platformModule.CollectionsFactorySupplier;
this._kernelExtensionFactories = platformModule.KernelExtensionFactories;
this._watcherServiceFactory = editionContext.WatcherServiceFactory;
this._facade = facade;
this._engineProviders = platformModule.EngineProviders;
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void setup()
public virtual void Setup()
{
DefaultFileSystemAbstraction fs = this._fs.get();
PageCache pc = _pageCacheRule.getPageCache(fs);
File file = _directory.file("index");
GenericLayout layout = new GenericLayout(1, _indexSettings);
RecoveryCleanupWorkCollector collector = RecoveryCleanupWorkCollector.ignore();
_descriptor = TestIndexDescriptorFactory.forLabel(1, 1).withId(1);
IndexDirectoryStructure.Factory factory = IndexDirectoryStructure.directoriesByProvider(_directory.storeDir());
IndexDirectoryStructure structure = factory.ForProvider(GenericNativeIndexProvider.Descriptor);
IndexDropAction dropAction = new FileSystemIndexDropAction(fs, structure);
_accessor = new GenericNativeIndexAccessor(pc, fs, file, layout, collector, EMPTY, _descriptor, _indexSettings, new StandardConfiguration(), dropAction, false);
}
protected internal virtual void Create(System.Action <PageCursor> headerWriter)
{
lock (this)
{
AssertNotDropped();
AssertNotClosed();
DeleteFileIfPresent(fileSystem, storeFile);
instantiateTree(RecoveryCleanupWorkCollector.immediate(), headerWriter);
// true: tree uniqueness is (value,entityId)
// false: tree uniqueness is (value) <-- i.e. more strict
_mainConflictDetector = MainConflictDetector;
// for updates we have to have uniqueness on (value,entityId) to allow for intermediary violating updates.
// there are added conflict checks after updates have been applied.
_updatesConflictDetector = new ThrowingConflictDetector <KEY, VALUE, Value[]>(true);
}
}
public override Lifecycle NewInstance(KernelContext context, SchemaIndexHaIT.IndexProviderDependencies deps)
{
PageCache pageCache = deps.PageCache();
File databaseDirectory = context.Directory();
DefaultFileSystemAbstraction fs = FileSystemRule.get();
IndexProvider.Monitor monitor = IndexProvider.Monitor_Fields.EMPTY;
Config config = deps.Config();
OperationalMode operationalMode = context.DatabaseInfo().OperationalMode;
RecoveryCleanupWorkCollector recoveryCleanupWorkCollector = deps.RecoveryCleanupWorkCollector();
FusionIndexProvider fusionIndexProvider = NativeLuceneFusionIndexProviderFactory20.create(pageCache, databaseDirectory, fs, monitor, config, operationalMode, recoveryCleanupWorkCollector);
if (InjectLatchPredicate.test(deps.Db()))
{
ControlledIndexProvider provider = new ControlledIndexProvider(fusionIndexProvider);
PerDbIndexProvider[deps.Db()] = provider;
return(provider);
}
else
{
return(fusionIndexProvider);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: SpatialIndexAccessor(org.neo4j.storageengine.api.schema.StoreIndexDescriptor descriptor, org.neo4j.io.pagecache.PageCache pageCache, org.neo4j.io.fs.FileSystemAbstraction fs, org.neo4j.index.internal.gbptree.RecoveryCleanupWorkCollector recoveryCleanupWorkCollector, org.neo4j.kernel.api.index.IndexProvider.Monitor monitor, SpatialIndexFiles spatialIndexFiles, org.neo4j.gis.spatial.index.curves.SpaceFillingCurveConfiguration searchConfiguration, boolean readOnly) throws java.io.IOException
internal SpatialIndexAccessor(StoreIndexDescriptor descriptor, PageCache pageCache, FileSystemAbstraction fs, RecoveryCleanupWorkCollector recoveryCleanupWorkCollector, IndexProvider.Monitor monitor, SpatialIndexFiles spatialIndexFiles, SpaceFillingCurveConfiguration searchConfiguration, bool readOnly) : base(new PartFactory(pageCache, fs, recoveryCleanupWorkCollector, monitor, descriptor, spatialIndexFiles, searchConfiguration, readOnly))
{
this._descriptor = descriptor;
spatialIndexFiles.LoadExistingIndexes(this);
}
//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));
}
internal PartAccessor(PageCache pageCache, FileSystemAbstraction fs, SpatialIndexFiles.SpatialFileLayout fileLayout, RecoveryCleanupWorkCollector recoveryCleanupWorkCollector, IndexProvider.Monitor monitor, StoreIndexDescriptor descriptor, SpaceFillingCurveConfiguration searchConfiguration, bool readOnly) : base(pageCache, fs, fileLayout.IndexFile, fileLayout.Layout, monitor, descriptor, NO_HEADER_WRITER, readOnly)
{
this.Layout = fileLayout.Layout;
this.Descriptor = descriptor;
this.SearchConfiguration = searchConfiguration;
this.Crs = fileLayout.SpatialFile.crs;
this.Settings = fileLayout.Settings;
instantiateTree(recoveryCleanupWorkCollector, HeaderWriter);
}
public PlatformModule(File providedStoreDir, Config config, DatabaseInfo databaseInfo, GraphDatabaseFacadeFactory.Dependencies externalDependencies)
{
this.DatabaseInfo = databaseInfo;
this.DataSourceManager = new DataSourceManager(config);
Dependencies = new Dependencies();
Dependencies.satisfyDependency(databaseInfo);
Clock = Dependencies.satisfyDependency(CreateClock());
Life = Dependencies.satisfyDependency(CreateLife());
this.StoreLayout = StoreLayout.of(providedStoreDir);
config.AugmentDefaults(GraphDatabaseSettings.neo4j_home, StoreLayout.storeDirectory().Path);
this.Config = Dependencies.satisfyDependency(config);
FileSystem = Dependencies.satisfyDependency(CreateFileSystemAbstraction());
Life.add(new FileSystemLifecycleAdapter(FileSystem));
// Component monitoring
Monitors = externalDependencies.Monitors() == null ? new Monitors() : externalDependencies.Monitors();
Dependencies.satisfyDependency(Monitors);
JobScheduler = Life.add(Dependencies.satisfyDependency(CreateJobScheduler()));
StartDeferredExecutors(JobScheduler, externalDependencies.DeferredExecutors());
// Cleanup after recovery, used by GBPTree, added to life in NeoStoreDataSource
RecoveryCleanupWorkCollector = new GroupingRecoveryCleanupWorkCollector(JobScheduler);
Dependencies.satisfyDependency(RecoveryCleanupWorkCollector);
// Database system information, used by UDC
UsageData = new UsageData(JobScheduler);
Dependencies.satisfyDependency(Life.add(UsageData));
// If no logging was passed in from the outside then create logging and register
// with this life
Logging = Dependencies.satisfyDependency(CreateLogService(externalDependencies.UserLogProvider()));
config.Logger = Logging.getInternalLog(typeof(Config));
Life.add(Dependencies.satisfyDependency(new StoreLockerLifecycleAdapter(CreateStoreLocker())));
(new JvmChecker(Logging.getInternalLog(typeof(JvmChecker)), new JvmMetadataRepository())).checkJvmCompatibilityAndIssueWarning();
string desiredImplementationName = config.Get(GraphDatabaseSettings.tracer);
Tracers = Dependencies.satisfyDependency(new Tracers(desiredImplementationName, Logging.getInternalLog(typeof(Tracers)), Monitors, JobScheduler, Clock));
Dependencies.satisfyDependency(Tracers.pageCacheTracer);
Dependencies.satisfyDependency(FirstImplementor(typeof(LogRotationMonitor), Tracers.transactionTracer, LogRotationMonitor.NULL));
Dependencies.satisfyDependency(FirstImplementor(typeof(CheckPointerMonitor), Tracers.checkPointTracer, CheckPointerMonitor.NULL));
VersionContextSupplier = CreateCursorContextSupplier(config);
CollectionsFactorySupplier = CreateCollectionsFactorySupplier(config, Life);
Dependencies.satisfyDependency(VersionContextSupplier);
PageCache = Dependencies.satisfyDependency(CreatePageCache(FileSystem, config, Logging, Tracers, VersionContextSupplier, JobScheduler));
Life.add(new PageCacheLifecycle(PageCache));
DiagnosticsManager = Life.add(Dependencies.satisfyDependency(new DiagnosticsManager(Logging.getInternalLog(typeof(DiagnosticsManager)))));
SystemDiagnostics.registerWith(DiagnosticsManager);
Dependencies.satisfyDependency(DataSourceManager);
KernelExtensionFactories = externalDependencies.KernelExtensions();
EngineProviders = externalDependencies.ExecutionEngines();
GlobalKernelExtensions = Dependencies.satisfyDependency(new GlobalKernelExtensions(new SimpleKernelContext(StoreLayout.storeDirectory(), databaseInfo, Dependencies), KernelExtensionFactories, Dependencies, KernelExtensionFailureStrategies.fail()));
UrlAccessRule = Dependencies.satisfyDependency(URLAccessRules.combined(externalDependencies.UrlAccessRules()));
ConnectorPortRegister = new ConnectorPortRegister();
Dependencies.satisfyDependency(ConnectorPortRegister);
EventHandlers = new KernelEventHandlers(Logging.getInternalLog(typeof(KernelEventHandlers)));
PanicEventGenerator = new DatabasePanicEventGenerator(EventHandlers);
PublishPlatformInfo(Dependencies.resolveDependency(typeof(UsageData)));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public static void run(final org.neo4j.io.fs.FileSystemAbstraction fs, final java.io.File storeDirectory, org.neo4j.kernel.configuration.Config config, org.neo4j.logging.LogProvider userLogProvider) throws Exception
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
public static void Run(FileSystemAbstraction fs, File storeDirectory, Config config, LogProvider userLogProvider)
{
StoreLogService logService = StoreLogService.withUserLogProvider(userLogProvider).withInternalLog(config.Get(store_internal_log_path)).build(fs);
VisibleMigrationProgressMonitor progressMonitor = new VisibleMigrationProgressMonitor(logService.GetUserLog(typeof(StoreMigration)));
LifeSupport life = new LifeSupport();
life.Add(logService);
// Add participants from kernel extensions...
DefaultExplicitIndexProvider migrationIndexProvider = new DefaultExplicitIndexProvider();
Log log = userLogProvider.GetLog(typeof(StoreMigration));
JobScheduler jobScheduler = JobSchedulerFactory.createInitialisedScheduler();
try
{
using (PageCache pageCache = createPageCache(fs, config, jobScheduler))
{
Dependencies deps = new Dependencies();
Monitors monitors = new Monitors();
deps.SatisfyDependencies(fs, config, migrationIndexProvider, pageCache, logService, monitors, RecoveryCleanupWorkCollector.immediate());
KernelContext kernelContext = new SimpleKernelContext(storeDirectory, DatabaseInfo.UNKNOWN, deps);
DatabaseKernelExtensions kernelExtensions = life.Add(new DatabaseKernelExtensions(kernelContext, GraphDatabaseDependencies.newDependencies().kernelExtensions(), deps, ignore()));
DatabaseLayout databaseLayout = DatabaseLayout.of(storeDirectory);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.transaction.log.files.LogFiles logFiles = org.neo4j.kernel.impl.transaction.log.files.LogFilesBuilder.activeFilesBuilder(databaseLayout, fs, pageCache).withConfig(config).build();
LogFiles logFiles = LogFilesBuilder.activeFilesBuilder(databaseLayout, fs, pageCache).withConfig(config).build();
LogTailScanner tailScanner = new LogTailScanner(logFiles, new VersionAwareLogEntryReader <Org.Neo4j.Kernel.impl.transaction.log.ReadableClosablePositionAwareChannel>(), monitors);
DefaultIndexProviderMap indexProviderMap = life.Add(new DefaultIndexProviderMap(kernelExtensions, config));
// Add the kernel store migrator
life.Start();
long startTime = DateTimeHelper.CurrentUnixTimeMillis();
DatabaseMigrator migrator = new DatabaseMigrator(progressMonitor, fs, config, logService, indexProviderMap, migrationIndexProvider, pageCache, RecordFormatSelector.selectForConfig(config, userLogProvider), tailScanner, jobScheduler);
migrator.Migrate(databaseLayout);
// Append checkpoint so the last log entry will have the latest version
AppendCheckpoint(logFiles, tailScanner);
long duration = DateTimeHelper.CurrentUnixTimeMillis() - startTime;
log.Info(format("Migration completed in %d s%n", duration / 1000));
}
}
catch (Exception e)
{
throw new StoreUpgrader.UnableToUpgradeException("Failure during upgrade", e);
}
finally
{
life.Shutdown();
jobScheduler.close();
}
}
public RecordStorageEngine(DatabaseLayout databaseLayout, Config config, PageCache pageCache, FileSystemAbstraction fs, LogProvider logProvider, LogProvider userLogProvider, TokenHolders tokenHolders, SchemaState schemaState, ConstraintSemantics constraintSemantics, JobScheduler scheduler, TokenNameLookup tokenNameLookup, LockService lockService, IndexProviderMap indexProviderMap, IndexingService.Monitor indexingServiceMonitor, DatabaseHealth databaseHealth, ExplicitIndexProvider explicitIndexProvider, IndexConfigStore indexConfigStore, IdOrderingQueue explicitIndexTransactionOrdering, IdGeneratorFactory idGeneratorFactory, IdController idController, Monitors monitors, RecoveryCleanupWorkCollector recoveryCleanupWorkCollector, OperationalMode operationalMode, VersionContextSupplier versionContextSupplier)
{
this._tokenHolders = tokenHolders;
this._schemaState = schemaState;
this._lockService = lockService;
this._databaseHealth = databaseHealth;
this._explicitIndexProviderLookup = explicitIndexProvider;
this._indexConfigStore = indexConfigStore;
this._constraintSemantics = constraintSemantics;
this._explicitIndexTransactionOrdering = explicitIndexTransactionOrdering;
this._idController = idController;
StoreFactory factory = new StoreFactory(databaseLayout, config, idGeneratorFactory, pageCache, fs, logProvider, versionContextSupplier);
_neoStores = factory.OpenAllNeoStores(true);
try
{
_schemaCache = new SchemaCache(constraintSemantics, Collections.emptyList(), indexProviderMap);
_schemaStorage = new SchemaStorage(_neoStores.SchemaStore);
NeoStoreIndexStoreView neoStoreIndexStoreView = new NeoStoreIndexStoreView(lockService, _neoStores);
bool readOnly = config.Get(GraphDatabaseSettings.read_only) && operationalMode == OperationalMode.single;
monitors.AddMonitorListener(new LoggingMonitor(logProvider.GetLog(typeof(NativeLabelScanStore))));
_labelScanStore = new NativeLabelScanStore(pageCache, databaseLayout, fs, new FullLabelStream(neoStoreIndexStoreView), readOnly, monitors, recoveryCleanupWorkCollector);
_indexStoreView = new DynamicIndexStoreView(neoStoreIndexStoreView, _labelScanStore, lockService, _neoStores, logProvider);
this._indexProviderMap = indexProviderMap;
_indexingService = IndexingServiceFactory.createIndexingService(config, scheduler, indexProviderMap, _indexStoreView, tokenNameLookup, Iterators.asList(_schemaStorage.loadAllSchemaRules()), logProvider, userLogProvider, indexingServiceMonitor, schemaState, readOnly);
_integrityValidator = new IntegrityValidator(_neoStores, _indexingService);
_cacheAccess = new BridgingCacheAccess(_schemaCache, schemaState, tokenHolders);
_explicitIndexApplierLookup = new Org.Neo4j.Kernel.Impl.Api.ExplicitIndexApplierLookup_Direct(explicitIndexProvider);
_labelScanStoreSync = new WorkSync <Supplier <LabelScanWriter>, LabelUpdateWork>(_labelScanStore.newWriter);
_commandReaderFactory = new RecordStorageCommandReaderFactory();
_indexUpdatesSync = new WorkSync <IndexingUpdateService, IndexUpdatesWork>(_indexingService);
_denseNodeThreshold = config.Get(GraphDatabaseSettings.dense_node_threshold);
_recordIdBatchSize = config.Get(GraphDatabaseSettings.record_id_batch_size);
}
catch (Exception failure)
{
_neoStores.close();
throw failure;
}
}
internal abstract IndexProvider NewProvider(PageCache pageCache, FileSystemAbstraction fs, IndexDirectoryStructure.Factory dir, IndexProvider.Monitor monitor, RecoveryCleanupWorkCollector collector, bool readOnly);
internal PartAccessor(PageCache pageCache, FileSystemAbstraction fs, TemporalIndexFiles.FileLayout <KEY> fileLayout, RecoveryCleanupWorkCollector recoveryCleanupWorkCollector, IndexProvider.Monitor monitor, StoreIndexDescriptor descriptor, bool readOnly) : base(pageCache, fs, fileLayout.IndexFile, fileLayout.Layout, monitor, descriptor, NO_HEADER_WRITER, readOnly)
{
this.Layout = fileLayout.Layout;
this.Descriptor = descriptor;
instantiateTree(recoveryCleanupWorkCollector, headerWriter);
}
internal GenericNativeIndexAccessor(PageCache pageCache, FileSystemAbstraction fs, File storeFile, IndexLayout <GenericKey, NativeIndexValue> layout, RecoveryCleanupWorkCollector recoveryCleanupWorkCollector, IndexProvider.Monitor monitor, StoreIndexDescriptor descriptor, IndexSpecificSpaceFillingCurveSettingsCache spaceFillingCurveSettings, SpaceFillingCurveConfiguration configuration, IndexDropAction dropAction, bool readOnly) : base(pageCache, fs, storeFile, layout, monitor, descriptor, new SpaceFillingCurveSettingsWriter(spaceFillingCurveSettings), readOnly)
{
this._spaceFillingCurveSettings = spaceFillingCurveSettings;
this._configuration = configuration;
this._dropAction = dropAction;
instantiateTree(recoveryCleanupWorkCollector, HeaderWriter);
}
private LabelScanStore GetLabelScanStore(FileSystemAbstraction fileSystemAbstraction, DatabaseLayout databaseLayout, FullStoreChangeStream fullStoreChangeStream, bool readOnly, Monitors monitors)
{
PageCache pageCache = PageCacheRule.getPageCache(fileSystemAbstraction);
return(new NativeLabelScanStore(pageCache, databaseLayout, fileSystemAbstraction, fullStoreChangeStream, readOnly, monitors, RecoveryCleanupWorkCollector.immediate()));
}
public NativeLabelScanStore(PageCache pageCache, DatabaseLayout directoryStructure, FileSystemAbstraction fs, FullStoreChangeStream fullStoreChangeStream, bool readOnly, Monitors monitors, RecoveryCleanupWorkCollector recoveryCleanupWorkCollector) : this(pageCache, directoryStructure, fs, fullStoreChangeStream, readOnly, monitors, recoveryCleanupWorkCollector, 0)
{
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldApplyIndexUpdatesInWorkSyncedBatches() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldApplyIndexUpdatesInWorkSyncedBatches()
{
// GIVEN
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
long duration = parseTimeMillis.apply(System.getProperty(this.GetType().FullName + ".duration", "2s"));
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
int numThreads = Integer.getInteger(this.GetType().FullName + ".numThreads", Runtime.Runtime.availableProcessors());
DefaultFileSystemAbstraction fs = _fileSystemRule.get();
PageCache pageCache = _pageCacheRule.getPageCache(fs);
FusionIndexProvider indexProvider = NativeLuceneFusionIndexProviderFactory20.create(pageCache, _directory.databaseDir(), fs, IndexProvider.Monitor_Fields.EMPTY, Config.defaults(), OperationalMode.single, RecoveryCleanupWorkCollector.immediate());
RecordStorageEngine storageEngine = _storageEngineRule.getWith(fs, pageCache, _directory.databaseLayout()).indexProvider(indexProvider).build();
storageEngine.Apply(Tx(singletonList(createIndexRule(DESCRIPTOR, 1, _descriptor))), TransactionApplicationMode.EXTERNAL);
Dependencies dependencies = new Dependencies();
storageEngine.SatisfyDependencies(dependencies);
IndexProxy index = dependencies.ResolveDependency(typeof(IndexingService)).getIndexProxy(_descriptor);
AwaitOnline(index);
// WHEN
Workers <Worker> workers = new Workers <Worker>(this.GetType().Name);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicBoolean end = new java.util.concurrent.atomic.AtomicBoolean();
AtomicBoolean end = new AtomicBoolean();
for (int i = 0; i < numThreads; i++)
{
workers.Start(new Worker(this, i, end, storageEngine, 10, index));
}
// let the threads hammer the storage engine for some time
Thread.Sleep(duration);
end.set(true);
// THEN (assertions as part of the workers applying transactions)
workers.AwaitAndThrowOnError();
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: TemporalIndexAccessor(org.neo4j.storageengine.api.schema.StoreIndexDescriptor descriptor, org.neo4j.kernel.impl.api.index.sampling.IndexSamplingConfig samplingConfig, org.neo4j.io.pagecache.PageCache pageCache, org.neo4j.io.fs.FileSystemAbstraction fs, org.neo4j.index.internal.gbptree.RecoveryCleanupWorkCollector recoveryCleanupWorkCollector, org.neo4j.kernel.api.index.IndexProvider.Monitor monitor, TemporalIndexFiles temporalIndexFiles, boolean readOnly) throws java.io.IOException
internal TemporalIndexAccessor(StoreIndexDescriptor descriptor, IndexSamplingConfig samplingConfig, PageCache pageCache, FileSystemAbstraction fs, RecoveryCleanupWorkCollector recoveryCleanupWorkCollector, IndexProvider.Monitor monitor, TemporalIndexFiles temporalIndexFiles, bool readOnly) : base(new PartFactory(pageCache, fs, recoveryCleanupWorkCollector, monitor, descriptor, samplingConfig, temporalIndexFiles, readOnly))
{
this._descriptor = descriptor;
temporalIndexFiles.LoadExistingIndexes(this);
}
internal GenericNativeIndexProvider(IndexDirectoryStructure.Factory directoryStructureFactory, PageCache pageCache, FileSystemAbstraction fs, Monitor monitor, RecoveryCleanupWorkCollector recoveryCleanupWorkCollector, bool readOnly, Config config) : base(Descriptor, directoryStructureFactory, pageCache, fs, monitor, recoveryCleanupWorkCollector, readOnly)
{
this._configuredSettings = new ConfiguredSpaceFillingCurveSettingsCache(config);
this._configuration = getConfiguredSpaceFillingCurveConfiguration(config);
this._archiveFailedIndex = config.Get(GraphDatabaseSettings.archive_failed_index);
this._dropAction = new FileSystemIndexDropAction(fs, directoryStructure());
}
public virtual NeoStoreDataSource GetDataSource(DatabaseLayout databaseLayout, FileSystemAbstraction fs, PageCache pageCache, DependencyResolver otherCustomOverriddenDependencies)
{
ShutdownAnyRunning();
StatementLocksFactory locksFactory = mock(typeof(StatementLocksFactory));
StatementLocks statementLocks = mock(typeof(StatementLocks));
Org.Neo4j.Kernel.impl.locking.Locks_Client locks = mock(typeof(Org.Neo4j.Kernel.impl.locking.Locks_Client));
when(statementLocks.Optimistic()).thenReturn(locks);
when(statementLocks.Pessimistic()).thenReturn(locks);
when(locksFactory.NewInstance()).thenReturn(statementLocks);
JobScheduler jobScheduler = mock(typeof(JobScheduler), RETURNS_MOCKS);
Monitors monitors = new Monitors();
Dependencies mutableDependencies = new Dependencies(otherCustomOverriddenDependencies);
// Satisfy non-satisfied dependencies
Config config = Dependency(mutableDependencies, typeof(Config), deps => Config.defaults());
config.augment(default_schema_provider, EMPTY.ProviderDescriptor.name());
LogService logService = Dependency(mutableDependencies, typeof(LogService), deps => new SimpleLogService(NullLogProvider.Instance));
IdGeneratorFactory idGeneratorFactory = Dependency(mutableDependencies, typeof(IdGeneratorFactory), deps => new DefaultIdGeneratorFactory(fs));
IdTypeConfigurationProvider idConfigurationProvider = Dependency(mutableDependencies, typeof(IdTypeConfigurationProvider), deps => new CommunityIdTypeConfigurationProvider());
DatabaseHealth databaseHealth = Dependency(mutableDependencies, typeof(DatabaseHealth), deps => new DatabaseHealth(mock(typeof(DatabasePanicEventGenerator)), NullLog.Instance));
SystemNanoClock clock = Dependency(mutableDependencies, typeof(SystemNanoClock), deps => Clocks.nanoClock());
TransactionMonitor transactionMonitor = Dependency(mutableDependencies, typeof(TransactionMonitor), deps => new DatabaseTransactionStats());
DatabaseAvailabilityGuard databaseAvailabilityGuard = Dependency(mutableDependencies, typeof(DatabaseAvailabilityGuard), deps => new DatabaseAvailabilityGuard(DEFAULT_DATABASE_NAME, deps.resolveDependency(typeof(SystemNanoClock)), NullLog.Instance));
Dependency(mutableDependencies, typeof(DiagnosticsManager), deps => new DiagnosticsManager(NullLog.Instance));
Dependency(mutableDependencies, typeof(IndexProvider), deps => EMPTY);
_dataSource = new NeoStoreDataSource(new TestDatabaseCreationContext(DEFAULT_DATABASE_NAME, databaseLayout, config, idGeneratorFactory, logService, mock(typeof(JobScheduler), RETURNS_MOCKS), mock(typeof(TokenNameLookup)), mutableDependencies, mockedTokenHolders(), locksFactory, mock(typeof(SchemaWriteGuard)), mock(typeof(TransactionEventHandlers)), IndexingService.NO_MONITOR, fs, transactionMonitor, databaseHealth, mock(typeof(LogFileCreationMonitor)), TransactionHeaderInformationFactory.DEFAULT, new CommunityCommitProcessFactory(), mock(typeof(InternalAutoIndexing)), mock(typeof(IndexConfigStore)), mock(typeof(ExplicitIndexProvider)), pageCache, new StandardConstraintSemantics(), monitors, new Tracers("null", NullLog.Instance, monitors, jobScheduler, clock), mock(typeof(Procedures)), Org.Neo4j.Io.pagecache.IOLimiter_Fields.Unlimited, databaseAvailabilityGuard, clock, new CanWrite(), new StoreCopyCheckPointMutex(), RecoveryCleanupWorkCollector.immediate(), new BufferedIdController(new BufferingIdGeneratorFactory(idGeneratorFactory, Org.Neo4j.Kernel.impl.store.id.IdReuseEligibility_Fields.Always, idConfigurationProvider), jobScheduler), DatabaseInfo.COMMUNITY, new TransactionVersionContextSupplier(), ON_HEAP, Collections.emptyList(), file => EMPTY_WATCHER, new GraphDatabaseFacade(), Iterables.empty()));
return(_dataSource);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void before()
public virtual void Before()
{
PageCache pageCache = _pageCacheRule.getPageCache(_fileSystem);
_store = _life.add(new NativeLabelScanStore(pageCache, _directory.databaseLayout(), _fileSystem, Org.Neo4j.Kernel.Impl.Api.scan.FullStoreChangeStream_Fields.Empty, false, new Monitors(), RecoveryCleanupWorkCollector.immediate(), Math.Min(pageCache.PageSize(), 256 << _random.Next(5))));
}
private IndexProviderMap CreateIndexes(PageCache pageCache, FileSystemAbstraction fileSystem, File storeDir, Config config, JobScheduler scheduler, LogProvider logProvider, Monitors monitors)
{
LogService logService = new SimpleLogService(logProvider, logProvider);
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(storeDir, fileSystem, config, logService, pageCache, scheduler, RecoveryCleanupWorkCollector.ignore(), DatabaseInfo.COMMUNITY, monitors, tokenHolders));
return(_life.add(new DefaultIndexProviderMap(extensions, config)));
}
