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: @BeforeEach void setUp() throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
internal virtual void SetUp()
{
_databaseAvailabilityGuard = new DatabaseAvailabilityGuard(DEFAULT_DATABASE_NAME, Clocks.systemClock(), NullLog.Instance);
_databaseHealth = new DatabaseHealth(mock(typeof(DatabasePanicEventGenerator)), NullLog.Instance);
_localDatabase = StubLocalDatabase.Create(() => _databaseHealth, _databaseAvailabilityGuard);
_localDatabase.start();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void givenClusterWhenShutdownMasterThenCannotStartTransactionOnSlave() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void GivenClusterWhenShutdownMasterThenCannotStartTransactionOnSlave()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.ha.HighlyAvailableGraphDatabase master = cluster.getMaster();
HighlyAvailableGraphDatabase master = _cluster.Master;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.ha.HighlyAvailableGraphDatabase slave = cluster.getAnySlave();
HighlyAvailableGraphDatabase slave = _cluster.AnySlave;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final long nodeId;
long nodeId;
using (Transaction tx = master.BeginTx())
{
nodeId = master.CreateNode().Id;
tx.Success();
}
_cluster.sync();
// When
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.FutureTask<bool> result = new java.util.concurrent.FutureTask<>(() ->
FutureTask <bool> result = new FutureTask <bool>(() =>
{
try
{
using (Transaction tx = slave.BeginTx())
{
tx.AcquireWriteLock(slave.GetNodeById(nodeId));
}
}
catch (Exception e)
{
return(contains(e, typeof(TransactionFailureException)));
}
// Fail otherwise
return(false);
});
DatabaseAvailabilityGuard masterGuard = master.DependencyResolver.resolveDependency(typeof(DatabaseAvailabilityGuard));
masterGuard.AddListener(new UnavailabilityListener(result));
master.Shutdown();
// Then
assertThat(result.get(), equalTo(true));
}
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()
{
_master = mock(typeof(Master));
_databaseAvailabilityGuard = new DatabaseAvailabilityGuard(DEFAULT_DATABASE_NAME, Clocks.fakeClock(), Instance);
_lockManager = new CommunityLockManger(Config.defaults(), Clocks.systemClock());
_local = spy(_lockManager.newClient());
_logProvider = new AssertableLogProvider();
LockResult lockResultOk = new LockResult(LockStatus.OkLocked);
TransactionStreamResponse <LockResult> responseOk = new TransactionStreamResponse <LockResult>(lockResultOk, null, Org.Neo4j.com.TransactionStream_Fields.Empty, Org.Neo4j.com.ResourceReleaser_Fields.NoOp);
WhenMasterAcquireShared().thenReturn(responseOk);
WhenMasterAcquireExclusive().thenReturn(responseOk);
_client = new SlaveLocksClient(_master, _local, _lockManager, mock(typeof(RequestContextFactory)), _databaseAvailabilityGuard, _logProvider);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void throwsWhenTxAwaitDurationExpires()
public virtual void ThrowsWhenTxAwaitDurationExpires()
{
long lastClosedTransactionId = 100;
System.Func <TransactionIdStore> txIdStore = () => FixedTxIdStore(lastClosedTransactionId);
Duration txAwaitDuration = Duration.ofSeconds(42);
FakeClock clock = new FakeClock();
DatabaseAvailabilityGuard databaseAvailabilityGuard = spy(new DatabaseAvailabilityGuard(DEFAULT_DATABASE_NAME, clock, NullLog.Instance));
when(databaseAvailabilityGuard.Available).then(invocation =>
{
// move clock forward on the first availability check
// this check is executed on every tx id polling iteration
bool available = ( bool )invocation.callRealMethod();
clock.Forward(txAwaitDuration.Seconds + 1, SECONDS);
return(available);
});
TransactionStateMachineV1SPI txSpi = CreateTxSpi(txIdStore, txAwaitDuration, databaseAvailabilityGuard, clock);
Future <Void> result = OtherThread.execute(state =>
{
txSpi.AwaitUpToDate(lastClosedTransactionId + 42);
return(null);
});
try
{
result.get(20, SECONDS);
}
catch (Exception e)
{
assertThat(e, instanceOf(typeof(ExecutionException)));
assertThat(e.InnerException, instanceOf(typeof(TransactionFailureException)));
}
}
private static TransactionStateMachineV1SPI CreateTxSpi(System.Func <TransactionIdStore> txIdStore, Duration txAwaitDuration, DatabaseAvailabilityGuard availabilityGuard, Clock clock)
{
QueryExecutionEngine queryExecutionEngine = mock(typeof(QueryExecutionEngine));
DependencyResolver dependencyResolver = mock(typeof(DependencyResolver));
ThreadToStatementContextBridge bridge = new ThreadToStatementContextBridge(availabilityGuard);
when(dependencyResolver.ResolveDependency(typeof(ThreadToStatementContextBridge))).thenReturn(bridge);
when(dependencyResolver.ResolveDependency(typeof(QueryExecutionEngine))).thenReturn(queryExecutionEngine);
when(dependencyResolver.ResolveDependency(typeof(DatabaseAvailabilityGuard))).thenReturn(availabilityGuard);
when(dependencyResolver.ProvideDependency(typeof(TransactionIdStore))).thenReturn(txIdStore);
GraphDatabaseAPI db = mock(typeof(GraphDatabaseAPI));
when(Db.DependencyResolver).thenReturn(dependencyResolver);
GraphDatabaseQueryService queryService = mock(typeof(GraphDatabaseQueryService));
when(queryService.DependencyResolver).thenReturn(dependencyResolver);
when(dependencyResolver.ResolveDependency(typeof(GraphDatabaseQueryService))).thenReturn(queryService);
BoltChannel boltChannel = new BoltChannel("bolt-42", "bolt", new EmbeddedChannel());
return(new TransactionStateMachineV1SPI(db, boltChannel, txAwaitDuration, clock));
}
private static TransactionStateMachineV1SPI CreateTxSpi(System.Func <TransactionIdStore> txIdStore, Duration txAwaitDuration, Clock clock)
{
DatabaseAvailabilityGuard databaseAvailabilityGuard = new DatabaseAvailabilityGuard(DEFAULT_DATABASE_NAME, clock, NullLog.Instance);
return(CreateTxSpi(txIdStore, txAwaitDuration, databaseAvailabilityGuard, clock));
}
//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()
{
_requestContextFactory = new RequestContextFactory(1, singleton(mock(typeof(TransactionIdStore))));
_master = mock(typeof(Master));
_databaseAvailabilityGuard = new DatabaseAvailabilityGuard(DEFAULT_DATABASE_NAME, Clocks.systemClock(), Instance);
}
//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()
{
_databaseAvailabilityGuard = new DatabaseAvailabilityGuard(DEFAULT_DATABASE_NAME, _clock, NullLog.Instance);
}
