//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldWaitForOngoingForceToCompleteBeforeForcingAgain() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldWaitForOngoingForceToCompleteBeforeForcingAgain()
{
_channelCommandQueue.put(ChannelCommand.Dummy);
// The 'emptyBuffer...' command will be put into the queue, and then it'll block on 'force' because the queue
// will be at capacity.
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final BatchingTransactionAppender appender = life.add(createTransactionAppender());
BatchingTransactionAppender appender = _life.add(CreateTransactionAppender());
_life.start();
ThreadStart runnable = CreateForceAfterAppendRunnable(appender);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.concurrent.Future<?> future = executor.submit(runnable);
Future <object> future = _executor.submit(runnable);
_forceSemaphore.acquire();
Thread otherThread = fork(runnable);
awaitThreadState(otherThread, _millisecondsToWait, Thread.State.TIMED_WAITING);
assertThat(_channelCommandQueue.take(), @is(ChannelCommand.Dummy));
assertThat(_channelCommandQueue.take(), @is(ChannelCommand.EmptyBufferIntoChannelAndClearIt));
assertThat(_channelCommandQueue.take(), @is(ChannelCommand.Force));
assertThat(_channelCommandQueue.take(), @is(ChannelCommand.EmptyBufferIntoChannelAndClearIt));
assertThat(_channelCommandQueue.take(), @is(ChannelCommand.Force));
future.get();
otherThread.Join();
assertTrue(_channelCommandQueue.Empty);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void correctLastAppliedToPreviousLogTransactionInHeaderOnLogFileRotation() throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void CorrectLastAppliedToPreviousLogTransactionInHeaderOnLogFileRotation()
{
LogFiles logFiles = GetLogFiles(_logVersionRepository, _transactionIdStore);
Life.add(logFiles);
DatabaseHealth databaseHealth = DatabaseHealth;
LogRotationImpl logRotation = new LogRotationImpl(_monitors.newMonitor(typeof(Org.Neo4j.Kernel.impl.transaction.log.rotation.LogRotation_Monitor)), logFiles, databaseHealth);
TransactionMetadataCache transactionMetadataCache = new TransactionMetadataCache();
SynchronizedArrayIdOrderingQueue idOrderingQueue = new SynchronizedArrayIdOrderingQueue();
BatchingTransactionAppender transactionAppender = new BatchingTransactionAppender(logFiles, logRotation, transactionMetadataCache, _transactionIdStore, idOrderingQueue, databaseHealth);
Life.add(transactionAppender);
LogAppendEvent logAppendEvent = new RotationLogAppendEvent(logRotation);
TransactionToApply transactionToApply = PrepareTransaction();
transactionAppender.Append(transactionToApply, logAppendEvent);
assertEquals(1, logFiles.HighestLogVersion);
File highestLogFile = logFiles.HighestLogFile;
LogHeader logHeader = LogHeaderReader.readLogHeader(FileSystem, highestLogFile);
assertEquals(2, logHeader.LastCommittedTxId);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldKernelPanicIfNotAbleToWriteACheckPoint() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldKernelPanicIfNotAbleToWriteACheckPoint()
{
// Given
IOException ioex = new IOException("boom!");
FlushablePositionAwareChannel channel = mock(typeof(FlushablePositionAwareChannel), RETURNS_MOCKS);
when(channel.Put(anyByte())).thenReturn(channel);
when(channel.PutLong(anyLong())).thenThrow(ioex);
when(channel.Put(anyByte())).thenThrow(ioex);
when(_logFile.Writer).thenReturn(channel);
BatchingTransactionAppender appender = Life.add(CreateTransactionAppender());
// When
try
{
appender.CheckPoint(new LogPosition(0L, 0L), LogCheckPointEvent.NULL);
fail("should have thrown ");
}
catch (IOException ex)
{
assertEquals(ioex, ex);
}
// Then
verify(_databaseHealth, times(1)).panic(ioex);
}
/*
* There was an issue where if multiple concurrent appending threads did append and they moved on
* to await a force, where the force would fail and the one doing the force would raise a panic...
* the other threads may not notice the panic and move on to mark those transactions as committed
* and notice the panic later (which would be too late).
*/
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldHaveAllConcurrentAppendersSeePanic() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldHaveAllConcurrentAppendersSeePanic()
{
// GIVEN
Adversary adversary = new ClassGuardedAdversary(new CountingAdversary(1, true), FailMethod(typeof(BatchingTransactionAppender), "force"));
EphemeralFileSystemAbstraction efs = new EphemeralFileSystemAbstraction();
FileSystemAbstraction fs = new AdversarialFileSystemAbstraction(adversary, efs);
_life.add(new FileSystemLifecycleAdapter(fs));
DatabaseHealth databaseHealth = new DatabaseHealth(mock(typeof(DatabasePanicEventGenerator)), NullLog.Instance);
LogFiles logFiles = LogFilesBuilder.builder(_testDirectory.databaseLayout(), fs).withLogVersionRepository(_logVersionRepository).withTransactionIdStore(_transactionIdStore).build();
_life.add(logFiles);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final BatchingTransactionAppender appender = life.add(new BatchingTransactionAppender(logFiles, logRotation, transactionMetadataCache, transactionIdStore, explicitIndexTransactionOrdering, databaseHealth));
BatchingTransactionAppender appender = _life.add(new BatchingTransactionAppender(logFiles, _logRotation, _transactionMetadataCache, _transactionIdStore, _explicitIndexTransactionOrdering, databaseHealth));
_life.start();
// WHEN
int numberOfAppenders = 10;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch trap = new java.util.concurrent.CountDownLatch(numberOfAppenders);
System.Threading.CountdownEvent trap = new System.Threading.CountdownEvent(numberOfAppenders);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.transaction.tracing.LogAppendEvent beforeForceTrappingEvent = new org.neo4j.kernel.impl.transaction.tracing.LogAppendEvent_Empty()
LogAppendEvent beforeForceTrappingEvent = new LogAppendEvent_EmptyAnonymousInnerClass(this, trap);
Race race = new Race();
for (int i = 0; i < numberOfAppenders; i++)
{
race.AddContestant(() =>
{
try
{
// Append to the log, the LogAppenderEvent will have all of the appending threads
// do wait for all of the other threads to start the force thing
appender.Append(Tx(), beforeForceTrappingEvent);
fail("No transaction should be considered appended");
}
catch (IOException)
{
// Good, we know that this test uses an adversarial file system which will throw
// an exception in BatchingTransactionAppender#force, and since all these transactions
// will append and be forced in the same batch, where the force will fail then
// all these transactions should fail. If there's any transaction not failing then
// it just didn't notice the panic, which would be potentially hazardous.
}
});
}
// THEN perform the race. The relevant assertions are made inside the contestants.
race.Go();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldForceLogChannel() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldForceLogChannel()
{
BatchingTransactionAppender appender = _life.add(CreateTransactionAppender());
_life.start();
appender.ForceAfterAppend(_logAppendEvent);
assertThat(_channelCommandQueue.take(), @is(ChannelCommand.EmptyBufferIntoChannelAndClearIt));
assertThat(_channelCommandQueue.take(), @is(ChannelCommand.Force));
assertTrue(_channelCommandQueue.Empty);
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: private Runnable createForceAfterAppendRunnable(final BatchingTransactionAppender appender)
private ThreadStart CreateForceAfterAppendRunnable(BatchingTransactionAppender appender)
{
return(() =>
{
try
{
appender.ForceAfterAppend(_logAppendEvent);
}
catch (IOException e)
{
throw new Exception(e);
}
});
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldKernelPanicIfTransactionIdsMismatch() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldKernelPanicIfTransactionIdsMismatch()
{
// Given
BatchingTransactionAppender appender = Life.add(CreateTransactionAppender());
when(_transactionIdStore.nextCommittingTransactionId()).thenReturn(42L);
TransactionToApply batch = new TransactionToApply(mock(typeof(TransactionRepresentation)), 43L);
// When
try
{
appender.Append(batch, Org.Neo4j.Kernel.impl.transaction.tracing.LogAppendEvent_Fields.Null);
fail("should have thrown ");
}
catch (System.InvalidOperationException ex)
{
// Then
verify(_databaseHealth, times(1)).panic(ex);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldBeAbleToWriteACheckPoint() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldBeAbleToWriteACheckPoint()
{
// Given
FlushablePositionAwareChannel channel = mock(typeof(FlushablePositionAwareChannel), RETURNS_MOCKS);
Flushable flushable = mock(typeof(Flushable));
when(channel.PrepareForFlush()).thenReturn(flushable);
when(channel.PutLong(anyLong())).thenReturn(channel);
when(_logFile.Writer).thenReturn(channel);
BatchingTransactionAppender appender = Life.add(CreateTransactionAppender());
// When
appender.CheckPoint(new LogPosition(1L, 2L), LogCheckPointEvent.NULL);
// Then
verify(channel, times(1)).putLong(1L);
verify(channel, times(1)).putLong(2L);
verify(channel, times(1)).prepareForFlush();
verify(flushable, times(1)).flush();
verify(_databaseHealth, never()).panic(any());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void databasePanicShouldHandleOutOfMemoryErrors() throws java.io.IOException, InterruptedException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void DatabasePanicShouldHandleOutOfMemoryErrors()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch panicLatch = new java.util.concurrent.CountDownLatch(1);
System.Threading.CountdownEvent panicLatch = new System.Threading.CountdownEvent(1);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch adversaryLatch = new java.util.concurrent.CountDownLatch(1);
System.Threading.CountdownEvent adversaryLatch = new System.Threading.CountdownEvent(1);
OutOfMemoryAwareFileSystem fs = new OutOfMemoryAwareFileSystem();
_life.add(new FileSystemLifecycleAdapter(fs));
DatabaseHealth slowPanicDatabaseHealth = new SlowPanickingDatabaseHealth(panicLatch, adversaryLatch);
LogFiles logFiles = LogFilesBuilder.builder(_testDirectory.databaseLayout(), fs).withLogVersionRepository(_logVersionRepository).withTransactionIdStore(_transactionIdStore).build();
_life.add(logFiles);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final BatchingTransactionAppender appender = life.add(new BatchingTransactionAppender(logFiles, logRotation, transactionMetadataCache, transactionIdStore, explicitIndexTransactionOrdering, slowPanicDatabaseHealth));
BatchingTransactionAppender appender = _life.add(new BatchingTransactionAppender(logFiles, _logRotation, _transactionMetadataCache, _transactionIdStore, _explicitIndexTransactionOrdering, slowPanicDatabaseHealth));
_life.start();
// Commit initial transaction
appender.Append(Tx(), Org.Neo4j.Kernel.impl.transaction.tracing.LogAppendEvent_Fields.Null);
// Try to commit one transaction, will fail during flush with OOM, but not actually panic
fs.ShouldOOM = true;
Future <long> failingTransaction = _executor.submit(() => appender.Append(Tx(), Org.Neo4j.Kernel.impl.transaction.tracing.LogAppendEvent_Fields.Null));
panicLatch.await();
// Try to commit one additional transaction, should fail since database has already panicked
fs.ShouldOOM = false;
try
{
appender.Append(Tx(), new LogAppendEvent_EmptyAnonymousInnerClass2(this, adversaryLatch));
fail("Should have failed since database should have panicked");
}
catch (IOException e)
{
assertTrue(e.Message.contains("The database has encountered a critical error"));
}
// Check that we actually got an OutOfMemoryError
try
{
failingTransaction.get();
fail("Should have failed with OutOfMemoryError error");
}
catch (ExecutionException e)
{
assertTrue(e.InnerException is System.OutOfMemoryException);
}
// Check number of transactions, should only have one
LogEntryReader <ReadableClosablePositionAwareChannel> logEntryReader = new VersionAwareLogEntryReader <ReadableClosablePositionAwareChannel>();
assertEquals(logFiles.LowestLogVersion, logFiles.HighestLogVersion);
long version = logFiles.HighestLogVersion;
using (LogVersionedStoreChannel channel = logFiles.OpenForVersion(version), ReadAheadLogChannel readAheadLogChannel = new ReadAheadLogChannel(channel), LogEntryCursor cursor = new LogEntryCursor(logEntryReader, readAheadLogChannel))
{
LogEntry entry;
long numberOfTransactions = 0;
while (cursor.Next())
{
entry = cursor.Get();
if (entry is LogEntryCommit)
{
numberOfTransactions++;
}
}
assertEquals(1, numberOfTransactions);
}
}
