public DirectStoreAccess(StoreAccess nativeStores, LabelScanStore labelScanStore, IndexProviderMap indexes, TokenHolders tokenHolders)
{
this._nativeStores = nativeStores;
this._labelScanStore = labelScanStore;
this._indexes = indexes;
this._tokenHolders = tokenHolders;
}
internal ProcedureGDSFactory(PlatformModule platform, DataSourceModule dataSource, CoreAPIAvailabilityGuard coreAPIAvailabilityGuard, TokenHolders tokenHolders, ThreadToStatementContextBridge bridge)
{
this._platform = platform;
this._dataSource = dataSource;
this._availability = coreAPIAvailabilityGuard;
this._urlValidator = url => platform.UrlAccessRule.validate(platform.Config, url);
this._tokenHolders = tokenHolders;
this._bridge = bridge;
}
public override Lifecycle NewInstance(KernelContext context, Dependencies dependencies)
{
Config config = dependencies.Config;
bool ephemeral = config.Get(GraphDatabaseSettings.ephemeral);
FileSystemAbstraction fileSystemAbstraction = dependencies.FileSystem();
DirectoryFactory directoryFactory = directoryFactory(ephemeral);
OperationalMode operationalMode = context.DatabaseInfo().OperationalMode;
JobScheduler scheduler = dependencies.Scheduler();
IndexDirectoryStructure.Factory directoryStructureFactory = SubProviderDirectoryStructure(context.Directory());
TokenHolders tokenHolders = dependencies.TokenHolders();
Log log = dependencies.LogService.getInternalLog(typeof(FulltextIndexProvider));
AuxiliaryTransactionStateManager auxiliaryTransactionStateManager;
try
{
auxiliaryTransactionStateManager = dependencies.AuxiliaryTransactionStateManager();
}
catch (UnsatisfiedDependencyException e)
{
string message = "Fulltext indexes failed to register as transaction state providers. This means that, if queried, they will not be able to " +
"uncommitted transactional changes into account. This is fine if the indexes are opened for non-transactional work, such as for " +
"consistency checking. The reason given is: " + e.Message;
LogDependencyException(context, log.ErrorLogger(), message);
auxiliaryTransactionStateManager = new NullAuxiliaryTransactionStateManager();
}
FulltextIndexProvider provider = new FulltextIndexProvider(Descriptor, directoryStructureFactory, fileSystemAbstraction, config, tokenHolders, directoryFactory, operationalMode, scheduler, auxiliaryTransactionStateManager, log);
string procedureRegistrationFailureMessage = "Failed to register the fulltext index procedures. The fulltext index provider will be loaded and " +
"updated like normal, but it might not be possible to query any fulltext indexes. The reason given is: ";
try
{
dependencies.Procedures().registerComponent(typeof(FulltextAdapter), procContext => provider, true);
dependencies.Procedures().registerProcedure(typeof(FulltextProcedures));
}
catch (KernelException e)
{
string message = procedureRegistrationFailureMessage + e.getUserMessage(new NonTransactionalTokenNameLookup(tokenHolders));
// We use the 'warn' logger in this case, because it can occur due to multi-database shenanigans, or due to internal restarts in HA.
// These scenarios are less serious, and will _probably_ not prevent FTS from working. Hence we only warn about this.
LogDependencyException(context, log.WarnLogger(), message);
}
catch (UnsatisfiedDependencyException e)
{
string message = procedureRegistrationFailureMessage + e.Message;
LogDependencyException(context, log.ErrorLogger(), message);
}
return(provider);
}
public DefaultMasterImplSPI(GraphDatabaseAPI graphDb, FileSystemAbstraction fileSystemAbstraction, Monitors monitors, TokenHolders tokenHolders, IdGeneratorFactory idGeneratorFactory, TransactionCommitProcess transactionCommitProcess, CheckPointer checkPointer, TransactionIdStore transactionIdStore, LogicalTransactionStore logicalTransactionStore, NeoStoreDataSource neoStoreDataSource, LogProvider logProvider)
{
this._graphDb = graphDb;
this._fileSystem = fileSystemAbstraction;
this._tokenHolders = tokenHolders;
this._idGeneratorFactory = idGeneratorFactory;
this._transactionCommitProcess = transactionCommitProcess;
this._checkPointer = checkPointer;
this._neoStoreDataSource = neoStoreDataSource;
this._databaseDirectory = graphDb.DatabaseLayout().databaseDirectory();
this._txChecksumLookup = new TransactionChecksumLookup(transactionIdStore, logicalTransactionStore);
this._responsePacker = new ResponsePacker(logicalTransactionStore, transactionIdStore, graphDb.storeId);
this._monitors = monitors;
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
monitors.AddMonitorListener(new LoggingStoreCopyServerMonitor(logProvider.GetLog(typeof(StoreCopyServer))), typeof(StoreCopyServer).FullName);
}
public DefaultEditionModuleDatabaseContext(DefaultEditionModule editionModule, string databaseName)
{
this._databaseName = databaseName;
this._transactionStartTimeout = editionModule.TransactionStartTimeout;
this._schemaWriteGuard = editionModule.SchemaWriteGuard;
this._headerInformationFactory = editionModule.HeaderInformationFactory;
this._commitProcessFactory = editionModule.CommitProcessFactory;
this._constraintSemantics = editionModule.ConstraintSemantics;
this._ioLimiter = editionModule.IoLimiter;
this._accessCapability = editionModule.AccessCapability;
this._watcherServiceFactory = editionModule.WatcherServiceFactory;
this._idContext = editionModule.IdContextFactory.createIdContext(databaseName);
this._tokenHolders = editionModule.TokenHoldersProvider.apply(databaseName);
this._locks = editionModule.LocksSupplier.get();
this._statementLocksFactory = editionModule.StatementLocksFactoryProvider.apply(_locks);
this._transactionMonitor = editionModule.CreateTransactionMonitor();
this._editionModule = editionModule;
}
//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()
{
_dataSource = mock(typeof(NeoStoreDataSource));
StorageEngine storageEngine = mock(typeof(StorageEngine));
StorageReader storageReader = mock(typeof(StorageReader));
when(storageEngine.NewReader()).thenReturn(storageReader);
_indexingService = mock(typeof(IndexingService));
TokenHolders tokenHolders = MockedTokenHolders();
when(tokenHolders.LabelTokens().getIdByName(EXISTING_LABEL)).thenReturn(LABEL_ID);
when(tokenHolders.PropertyKeyTokens().getIdByName(EXISTING_PROPERTY)).thenReturn(PROPERTY_ID);
when(tokenHolders.PropertyKeyTokens().getIdByName(NON_EXISTING_PROPERTY)).thenReturn(-1);
when(tokenHolders.LabelTokens().getIdByName(NON_EXISTING_LABEL)).thenReturn(NO_TOKEN);
DependencyResolver resolver = mock(typeof(DependencyResolver));
when(resolver.ResolveDependency(typeof(IndexingService))).thenReturn(_indexingService);
when(resolver.ResolveDependency(typeof(StorageEngine))).thenReturn(storageEngine);
when(resolver.ResolveDependency(typeof(TokenHolders))).thenReturn(tokenHolders);
when(_dataSource.DependencyResolver).thenReturn(resolver);
}
internal ExtendedRecordStorageEngine(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 explicitIndexProviderLookup, IndexConfigStore indexConfigStore, IdOrderingQueue explicitIndexTransactionOrdering, IdGeneratorFactory idGeneratorFactory, IdController idController, System.Func <BatchTransactionApplierFacade, BatchTransactionApplierFacade> transactionApplierTransformer, Monitors monitors, RecoveryCleanupWorkCollector recoveryCleanupWorkCollector, OperationalMode operationalMode) : base(databaseLayout, config, pageCache, fs, logProvider, userLogProvider, tokenHolders, schemaState, constraintSemantics, scheduler, tokenNameLookup, lockService, indexProviderMap, indexingServiceMonitor, databaseHealth, explicitIndexProviderLookup, indexConfigStore, explicitIndexTransactionOrdering, idGeneratorFactory, idController, monitors, recoveryCleanupWorkCollector, operationalMode, EmptyVersionContextSupplier.EMPTY)
{
this.TransactionApplierTransformer = transactionApplierTransformer;
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") public static org.neo4j.kernel.extension.DatabaseKernelExtensions instantiateKernelExtensions(java.io.File databaseDirectory, org.neo4j.io.fs.FileSystemAbstraction fileSystem, org.neo4j.kernel.configuration.Config config, org.neo4j.logging.internal.LogService logService, org.neo4j.io.pagecache.PageCache pageCache, org.neo4j.scheduler.JobScheduler jobScheduler, org.neo4j.index.internal.gbptree.RecoveryCleanupWorkCollector recoveryCollector, org.neo4j.kernel.impl.factory.DatabaseInfo databaseInfo, org.neo4j.kernel.monitoring.Monitors monitors, org.neo4j.kernel.impl.core.TokenHolders tokenHolders)
public static DatabaseKernelExtensions InstantiateKernelExtensions(File databaseDirectory, FileSystemAbstraction fileSystem, Config config, LogService logService, PageCache pageCache, JobScheduler jobScheduler, RecoveryCleanupWorkCollector recoveryCollector, DatabaseInfo databaseInfo, Monitors monitors, TokenHolders tokenHolders)
{
Dependencies deps = new Dependencies();
deps.SatisfyDependencies(fileSystem, config, logService, pageCache, recoveryCollector, monitors, jobScheduler, tokenHolders);
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("rawtypes") Iterable kernelExtensions = org.neo4j.helpers.Service.load(org.neo4j.kernel.extension.KernelExtensionFactory.class);
System.Collections.IEnumerable kernelExtensions = Service.load(typeof(KernelExtensionFactory));
KernelContext kernelContext = new SimpleKernelContext(databaseDirectory, databaseInfo, deps);
return(new DatabaseKernelExtensions(kernelContext, kernelExtensions, deps, KernelExtensionFailureStrategies.ignore()));
}
public BridgingCacheAccess(SchemaCache schemaCache, SchemaState schemaState, TokenHolders tokenHolders)
{
this._schemaCache = schemaCache;
this._schemaState = schemaState;
this._tokenHolders = tokenHolders;
}
public NonTransactionalTokenNameLookup(TokenHolders tokenHolders, bool includeId)
{
this._tokenHolders = tokenHolders;
this._includeId = includeId;
}
public NonTransactionalTokenNameLookup(TokenHolders tokenHolders) : this(tokenHolders, false)
{
}
internal State(StorageEngine storageEngine, IndexingService indexingService, TokenHolders tokenHolders)
{
this.StorageEngine = storageEngine;
this.IndexingService = indexingService;
this.TokenHolders = tokenHolders;
}
