//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotCallTransactionClosedOnFailedAppendedTransaction() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldNotCallTransactionClosedOnFailedAppendedTransaction()
{
// GIVEN
long txId = 3;
string failureMessage = "Forces a failure";
FlushablePositionAwareChannel channel = spy(new PositionAwarePhysicalFlushableChannel(mock(typeof(PhysicalLogVersionedStoreChannel))));
IOException failure = new IOException(failureMessage);
when(channel.PutInt(anyInt())).thenThrow(failure);
when(_logFile.Writer).thenReturn(channel);
when(_transactionIdStore.nextCommittingTransactionId()).thenReturn(txId);
Mockito.reset(_databaseHealth);
TransactionAppender appender = Life.add(CreateTransactionAppender());
// WHEN
TransactionRepresentation transaction = mock(typeof(TransactionRepresentation));
when(transaction.AdditionalHeader()).thenReturn(new sbyte[0]);
try
{
appender.Append(new TransactionToApply(transaction), _logAppendEvent);
fail("Expected append to fail. Something is wrong with the test itself");
}
catch (IOException e)
{
// THEN
assertSame(failure, e);
verify(_transactionIdStore, times(1)).nextCommittingTransactionId();
verify(_transactionIdStore, never()).transactionClosed(eq(txId), anyLong(), anyLong());
verify(_databaseHealth).panic(failure);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldAppendSingleTransaction() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldAppendSingleTransaction()
{
// GIVEN
when(_logFile.Writer).thenReturn(_channel);
long txId = 15;
when(_transactionIdStore.nextCommittingTransactionId()).thenReturn(txId);
TransactionAppender appender = Life.add(CreateTransactionAppender());
// WHEN
TransactionRepresentation transaction = transaction(SingleCreateNodeCommand(0), new sbyte[] { 1, 2, 5 }, 2, 1, 12345, 4545, 12345 + 10);
appender.Append(new TransactionToApply(transaction), _logAppendEvent);
// THEN
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.transaction.log.entry.LogEntryReader<ReadableLogChannel> logEntryReader = new org.neo4j.kernel.impl.transaction.log.entry.VersionAwareLogEntryReader<>();
LogEntryReader <ReadableLogChannel> logEntryReader = new VersionAwareLogEntryReader <ReadableLogChannel>();
using (PhysicalTransactionCursor <ReadableLogChannel> reader = new PhysicalTransactionCursor <ReadableLogChannel>(_channel, logEntryReader))
{
reader.Next();
TransactionRepresentation tx = reader.Get().TransactionRepresentation;
assertArrayEquals(transaction.AdditionalHeader(), tx.AdditionalHeader());
assertEquals(transaction.MasterId, tx.MasterId);
assertEquals(transaction.AuthorId, tx.AuthorId);
assertEquals(transaction.TimeStarted, tx.TimeStarted);
assertEquals(transaction.TimeCommitted, tx.TimeCommitted);
assertEquals(transaction.LatestCommittedTxWhenStarted, tx.LatestCommittedTxWhenStarted);
}
}
public override TransactionCommitProcess Create(TransactionAppender appender, StorageEngine storageEngine, Config config)
{
if (config.Get(GraphDatabaseSettings.read_only))
{
return(new ReadOnlyTransactionCommitProcess());
}
return(( TransactionCommitProcess )newProxyInstance(typeof(TransactionCommitProcess).ClassLoader, new Type[] { typeof(TransactionCommitProcess) }, _commitProcessDelegate));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void addATransactionAndRewind(org.neo4j.kernel.lifecycle.LifeSupport life, org.neo4j.kernel.impl.transaction.log.files.LogFiles logFiles, TransactionMetadataCache positionCache, TransactionIdStore transactionIdStore, byte[] additionalHeader, int masterId, int authorId, long timeStarted, long latestCommittedTxWhenStarted, long timeCommitted) throws java.io.IOException
private void AddATransactionAndRewind(LifeSupport life, LogFiles logFiles, TransactionMetadataCache positionCache, TransactionIdStore transactionIdStore, sbyte[] additionalHeader, int masterId, int authorId, long timeStarted, long latestCommittedTxWhenStarted, long timeCommitted)
{
TransactionAppender appender = life.Add(new BatchingTransactionAppender(logFiles, NO_ROTATION, positionCache, transactionIdStore, BYPASS, _databaseHealth));
PhysicalTransactionRepresentation transaction = new PhysicalTransactionRepresentation(SingleCreateNodeCommand());
transaction.SetHeader(additionalHeader, masterId, authorId, timeStarted, latestCommittedTxWhenStarted, timeCommitted, -1);
appender.Append(new TransactionToApply(transaction), Org.Neo4j.Kernel.impl.transaction.tracing.LogAppendEvent_Fields.Null);
}
public CheckPointerImpl(TransactionIdStore transactionIdStore, CheckPointThreshold threshold, StorageEngine storageEngine, LogPruning logPruning, TransactionAppender appender, DatabaseHealth databaseHealth, LogProvider logProvider, CheckPointTracer tracer, IOLimiter ioLimiter, StoreCopyCheckPointMutex mutex)
{
this._appender = appender;
this._transactionIdStore = transactionIdStore;
this._threshold = threshold;
this._storageEngine = storageEngine;
this._logPruning = logPruning;
this._databaseHealth = databaseHealth;
this._ioLimiter = ioLimiter;
this._msgLog = logProvider.GetLog(typeof(CheckPointerImpl));
this._tracer = tracer;
this._mutex = mutex;
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldKeepTransactionsIntactWhenConcurrentlyRotationAndAppending() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldKeepTransactionsIntactWhenConcurrentlyRotationAndAppending()
{
// GIVEN
LogVersionRepository logVersionRepository = new SimpleLogVersionRepository();
LogFiles logFiles = LogFilesBuilder.builder(_directory.databaseLayout(), _fileSystemRule.get()).withLogVersionRepository(logVersionRepository).withRotationThreshold(ByteUnit.mebiBytes(1)).withTransactionIdStore(new SimpleTransactionIdStore()).build();
_life.add(logFiles);
//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();
AllTheMonitoring monitoring = new AllTheMonitoring(end, 100);
TransactionIdStore txIdStore = new SimpleTransactionIdStore();
TransactionMetadataCache metadataCache = new TransactionMetadataCache();
monitoring.LogFile = logFiles.LogFile;
DatabaseHealth health = new DatabaseHealth(mock(typeof(DatabasePanicEventGenerator)), NullLog.Instance);
LogRotation rotation = new LogRotationImpl(monitoring, logFiles, health);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final TransactionAppender appender = life.add(new BatchingTransactionAppender(logFiles, rotation, metadataCache, txIdStore, BYPASS, health));
TransactionAppender appender = _life.add(new BatchingTransactionAppender(logFiles, rotation, metadataCache, txIdStore, BYPASS, health));
// WHEN
Race race = new Race();
for (int i = 0; i < 10; i++)
{
race.AddContestant(() =>
{
while (!end.get())
{
try
{
appender.Append(new TransactionToApply(SillyTransaction(1_000)), NULL);
}
catch (Exception e)
{
e.printStackTrace(System.out);
end.set(true);
fail(e.Message);
}
}
});
}
race.AddContestant(EndAfterMax(10, SECONDS, end));
race.Go();
// THEN
assertTrue(monitoring.NumberOfRotations() > 0);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public System.Nullable<long> call() throws Exception
public override long?Call()
{
long lastCommittedTransactionId;
using (FileSystemAbstraction fileSystem = new DefaultFileSystemAbstraction(), Lifespan life = new Lifespan())
{
TransactionIdStore transactionIdStore = new SimpleTransactionIdStore();
TransactionMetadataCache transactionMetadataCache = new TransactionMetadataCache();
LogFiles logFiles = life.Add(CreateLogFiles(transactionIdStore, fileSystem));
TransactionAppender transactionAppender = life.Add(CreateBatchingTransactionAppender(transactionIdStore, transactionMetadataCache, logFiles));
ExecutorService executorService = Executors.newFixedThreadPool(_threads);
try
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.concurrent.Future<?>[] handlers = new java.util.concurrent.Future[threads];
Future <object>[] handlers = new Future[_threads];
for (int i = 0; i < _threads; i++)
{
TransactionRepresentationFactory factory = new TransactionRepresentationFactory();
Worker task = new Worker(transactionAppender, factory, _condition);
handlers[i] = executorService.submit(task);
}
// wait for all the workers to complete
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: for (java.util.concurrent.Future<?> handle : handlers)
foreach (Future <object> handle in handlers)
{
handle.get();
}
}
finally
{
executorService.shutdown();
}
lastCommittedTransactionId = transactionIdStore.LastCommittedTransactionId;
}
return(lastCommittedTransactionId);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotCallTransactionClosedOnFailedForceLogToDisk() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldNotCallTransactionClosedOnFailedForceLogToDisk()
{
// GIVEN
long txId = 3;
string failureMessage = "Forces a failure";
FlushablePositionAwareChannel channel = spy(new InMemoryClosableChannel());
IOException failure = new IOException(failureMessage);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.io.Flushable flushable = mock(java.io.Flushable.class);
Flushable flushable = mock(typeof(Flushable));
doAnswer(invocation =>
{
invocation.callRealMethod();
return(flushable);
}).when(channel).prepareForFlush();
doThrow(failure).when(flushable).flush();
when(_logFile.Writer).thenReturn(channel);
TransactionMetadataCache metadataCache = new TransactionMetadataCache();
TransactionIdStore transactionIdStore = mock(typeof(TransactionIdStore));
when(transactionIdStore.NextCommittingTransactionId()).thenReturn(txId);
Mockito.reset(_databaseHealth);
TransactionAppender appender = Life.add(new BatchingTransactionAppender(_logFiles, NO_ROTATION, metadataCache, transactionIdStore, BYPASS, _databaseHealth));
// WHEN
TransactionRepresentation transaction = mock(typeof(TransactionRepresentation));
when(transaction.AdditionalHeader()).thenReturn(new sbyte[0]);
try
{
appender.Append(new TransactionToApply(transaction), _logAppendEvent);
fail("Expected append to fail. Something is wrong with the test itself");
}
catch (IOException e)
{
// THEN
assertSame(failure, e);
verify(transactionIdStore, times(1)).nextCommittingTransactionId();
verify(transactionIdStore, never()).transactionClosed(eq(txId), anyLong(), anyLong());
verify(_databaseHealth).panic(failure);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldAppendCommittedTransactions() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldAppendCommittedTransactions()
{
// GIVEN
when(_logFile.Writer).thenReturn(_channel);
long nextTxId = 15;
when(_transactionIdStore.nextCommittingTransactionId()).thenReturn(nextTxId);
TransactionAppender appender = Life.add(new BatchingTransactionAppender(_logFiles, NO_ROTATION, _positionCache, _transactionIdStore, BYPASS, _databaseHealth));
// WHEN
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final byte[] additionalHeader = new byte[]{1, 2, 5};
sbyte[] additionalHeader = new sbyte[] { 1, 2, 5 };
const int masterId = 2;
int authorId = 1;
const long timeStarted = 12345;
long latestCommittedTxWhenStarted = nextTxId - 5;
long timeCommitted = timeStarted + 10;
PhysicalTransactionRepresentation transactionRepresentation = new PhysicalTransactionRepresentation(SingleCreateNodeCommand(0));
transactionRepresentation.SetHeader(additionalHeader, masterId, authorId, timeStarted, latestCommittedTxWhenStarted, timeCommitted, -1);
LogEntryStart start = new LogEntryStart(0, 0, 0L, latestCommittedTxWhenStarted, null, LogPosition.UNSPECIFIED);
LogEntryCommit commit = new LogEntryCommit(nextTxId, 0L);
CommittedTransactionRepresentation transaction = new CommittedTransactionRepresentation(start, transactionRepresentation, commit);
appender.Append(new TransactionToApply(transactionRepresentation, transaction.CommitEntry.TxId), _logAppendEvent);
// THEN
LogEntryReader <ReadableLogChannel> logEntryReader = new VersionAwareLogEntryReader <ReadableLogChannel>();
using (PhysicalTransactionCursor <ReadableLogChannel> reader = new PhysicalTransactionCursor <ReadableLogChannel>(_channel, logEntryReader))
{
reader.Next();
TransactionRepresentation result = reader.Get().TransactionRepresentation;
assertArrayEquals(additionalHeader, result.AdditionalHeader());
assertEquals(masterId, result.MasterId);
assertEquals(authorId, result.AuthorId);
assertEquals(timeStarted, result.TimeStarted);
assertEquals(timeCommitted, result.TimeCommitted);
assertEquals(latestCommittedTxWhenStarted, result.LatestCommittedTxWhenStarted);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldAppendBatchOfTransactions() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldAppendBatchOfTransactions()
{
// GIVEN
when(_logFile.Writer).thenReturn(_channel);
TransactionAppender appender = Life.add(CreateTransactionAppender());
when(_transactionIdStore.nextCommittingTransactionId()).thenReturn(2L, 3L, 4L);
TransactionToApply batch = BatchOf(Transaction(SingleCreateNodeCommand(0), new sbyte[0], 0, 0, 0, 1, 0), Transaction(SingleCreateNodeCommand(1), new sbyte[0], 0, 0, 0, 1, 0), Transaction(SingleCreateNodeCommand(2), new sbyte[0], 0, 0, 0, 1, 0));
// WHEN
appender.Append(batch, _logAppendEvent);
// THEN
TransactionToApply tx = batch;
assertEquals(2L, tx.TransactionId());
tx = tx.Next();
assertEquals(3L, tx.TransactionId());
tx = tx.Next();
assertEquals(4L, tx.TransactionId());
assertNull(tx.Next());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotAppendCommittedTransactionsWhenTooFarAhead()
public virtual void ShouldNotAppendCommittedTransactionsWhenTooFarAhead()
{
// GIVEN
InMemoryClosableChannel channel = new InMemoryClosableChannel();
when(_logFile.Writer).thenReturn(channel);
TransactionAppender appender = Life.add(CreateTransactionAppender());
// WHEN
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final byte[] additionalHeader = new byte[]{1, 2, 5};
sbyte[] additionalHeader = new sbyte[] { 1, 2, 5 };
const int masterId = 2;
int authorId = 1;
const long timeStarted = 12345;
long latestCommittedTxWhenStarted = 4545;
long timeCommitted = timeStarted + 10;
PhysicalTransactionRepresentation transactionRepresentation = new PhysicalTransactionRepresentation(SingleCreateNodeCommand(0));
transactionRepresentation.SetHeader(additionalHeader, masterId, authorId, timeStarted, latestCommittedTxWhenStarted, timeCommitted, -1);
when(_transactionIdStore.LastCommittedTransactionId).thenReturn(latestCommittedTxWhenStarted);
LogEntryStart start = new LogEntryStart(0, 0, 0L, latestCommittedTxWhenStarted, null, LogPosition.UNSPECIFIED);
LogEntryCommit commit = new LogEntryCommit(latestCommittedTxWhenStarted + 2, 0L);
CommittedTransactionRepresentation transaction = new CommittedTransactionRepresentation(start, transactionRepresentation, commit);
try
{
appender.Append(new TransactionToApply(transaction.TransactionRepresentation, transaction.CommitEntry.TxId), _logAppendEvent);
fail("should have thrown");
}
catch (Exception e)
{
assertThat(e.Message, containsString("to be applied, but appending it ended up generating an"));
}
}
public TransactionRepresentationCommitProcess(TransactionAppender appender, StorageEngine storageEngine)
{
this._appender = appender;
this._storageEngine = storageEngine;
}
/// <summary>
/// Called by the DataSourceManager during start.
/// </summary>
public virtual void RegisterCommitProcessDependencies(TransactionAppender appender, StorageEngine applier)
{
_localCommit = new TransactionRepresentationCommitProcess(appender, applier);
}
internal StubTransactionCommitProcess(TransactionAppender appender, StorageEngine storageEngine) : base(appender, storageEngine)
{
}
internal Worker(TransactionAppender transactionAppender, TransactionRepresentationFactory factory, System.Func <bool> condition)
{
this._transactionAppender = transactionAppender;
this._factory = factory;
this._condition = condition;
}
