//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void bigFileLatestCheckpointFindsStartAfter() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void BigFileLatestCheckpointFindsStartAfter()
{
long firstTxAfterCheckpoint = int.MaxValue + 4L;
LogTailScanner tailScanner = new FirstTxIdConfigurableTailScanner(firstTxAfterCheckpoint, _logFiles, _reader, _monitors);
LogEntryStart startEntry = new LogEntryStart(1, 2, 3L, 4L, new sbyte[] { 5, 6 }, new LogPosition(_endLogVersion, int.MaxValue + 17L));
CheckPoint checkPoint = new CheckPoint(new LogPosition(_endLogVersion, 16L));
LogTailInformation logTailInformation = tailScanner.CheckpointTailInformation(_endLogVersion, startEntry, _endLogVersion, _latestLogEntryVersion, checkPoint, false);
AssertLatestCheckPoint(true, true, firstTxAfterCheckpoint, _endLogVersion, logTailInformation);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public boolean next() throws java.io.IOException
public override bool Next()
{
// Clear the previous deserialized transaction so that it won't have to be kept in heap while deserializing
// the next one. Could be problematic if both are really big.
_current = null;
while (true)
{
if (!_logEntryCursor.next())
{
return(false);
}
LogEntry entry = _logEntryCursor.get();
if (entry is CheckPoint)
{
// this is a good position anyhow
_channel.getCurrentPosition(_lastGoodPositionMarker);
continue;
}
Debug.Assert(entry is LogEntryStart, "Expected Start entry, read " + entry + " instead");
LogEntryStart startEntry = entry.As();
LogEntryCommit commitEntry;
IList <StorageCommand> entries = new List <StorageCommand>();
while (true)
{
if (!_logEntryCursor.next())
{
return(false);
}
entry = _logEntryCursor.get();
if (entry is LogEntryCommit)
{
commitEntry = entry.As();
break;
}
LogEntryCommand command = entry.As();
entries.Add(command.Command);
}
PhysicalTransactionRepresentation transaction = new PhysicalTransactionRepresentation(entries);
transaction.SetHeader(startEntry.AdditionalHeader, startEntry.MasterId, startEntry.LocalId, startEntry.TimeWritten, startEntry.LastCommittedTxWhenTransactionStarted, commitEntry.TimeWritten, -1);
_current = new CommittedTransactionRepresentation(startEntry, transaction, commitEntry);
_channel.getCurrentPosition(_lastGoodPositionMarker);
return(true);
}
}
//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 shouldTellTransactionIdStoreAfterSuccessfulRecovery() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldTellTransactionIdStoreAfterSuccessfulRecovery()
{
// GIVEN
File file = _logFiles.getLogFileForVersion(_logVersion);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.transaction.log.LogPositionMarker marker = new org.neo4j.kernel.impl.transaction.log.LogPositionMarker();
LogPositionMarker marker = new LogPositionMarker();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final byte[] additionalHeaderData = new byte[0];
sbyte[] additionalHeaderData = new sbyte[0];
const int masterId = 0;
const int authorId = 1;
const long transactionId = 4;
const long commitTimestamp = 5;
WriteSomeData(file, pair =>
{
LogEntryWriter writer = pair.first();
Consumer <LogPositionMarker> consumer = pair.other();
// last committed tx
writer.writeStartEntry(masterId, authorId, 2L, 3L, additionalHeaderData);
writer.writeCommitEntry(transactionId, commitTimestamp);
consumer.accept(marker);
return(true);
});
// WHEN
bool recoveryRequired = Recover(_storeDir, _logFiles);
// THEN
assertTrue(recoveryRequired);
long[] lastClosedTransaction = _transactionIdStore.LastClosedTransaction;
assertEquals(transactionId, lastClosedTransaction[0]);
assertEquals(LogEntryStart.checksum(additionalHeaderData, masterId, authorId), _transactionIdStore.LastCommittedTransaction.checksum());
assertEquals(commitTimestamp, _transactionIdStore.LastCommittedTransaction.commitTimestamp());
assertEquals(_logVersion, lastClosedTransaction[1]);
assertEquals(marker.ByteOffset, lastClosedTransaction[2]);
}
//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"));
}
}
private static bool StartEntryMakesSense(LogEntryStart entry)
{
return(ServerIdMakesSense(entry.LocalId) && ServerIdMakesSense(entry.MasterId) && TimeMakesSense(entry.TimeWritten));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private LogTailInformation findLogTail() throws java.io.IOException
private LogTailInformation FindLogTail()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final long highestLogVersion = logFiles.getHighestLogVersion();
long highestLogVersion = _logFiles.HighestLogVersion;
long version = highestLogVersion;
long versionToSearchForCommits = highestLogVersion;
LogEntryStart latestStartEntry = null;
long oldestStartEntryTransaction = -1;
long oldestVersionFound = -1;
LogEntryVersion latestLogEntryVersion = null;
bool startRecordAfterCheckpoint = false;
bool corruptedTransactionLogs = false;
while (version >= _logFiles.LowestLogVersion && version >= INITIAL_LOG_VERSION)
{
oldestVersionFound = version;
CheckPoint latestCheckPoint = null;
try
{
using (LogVersionedStoreChannel channel = _logFiles.openForVersion(version), ReadAheadLogChannel readAheadLogChannel = new ReadAheadLogChannel(channel), LogEntryCursor cursor = new LogEntryCursor(_logEntryReader, readAheadLogChannel))
{
LogEntry entry;
long maxEntryReadPosition = 0;
while (cursor.Next())
{
entry = cursor.Get();
// Collect data about latest checkpoint
if (entry is CheckPoint)
{
latestCheckPoint = entry.As();
}
else if (entry is LogEntryCommit)
{
if (oldestStartEntryTransaction == NoTransactionId)
{
oldestStartEntryTransaction = (( LogEntryCommit )entry).TxId;
}
}
else if (entry is LogEntryStart)
{
LogEntryStart startEntry = entry.As();
if (version == versionToSearchForCommits)
{
latestStartEntry = startEntry;
}
startRecordAfterCheckpoint = true;
}
// Collect data about latest entry version, only in first log file
if (version == versionToSearchForCommits || latestLogEntryVersion == null)
{
latestLogEntryVersion = entry.Version;
}
maxEntryReadPosition = readAheadLogChannel.Position();
}
if (HasUnreadableBytes(channel, maxEntryReadPosition))
{
corruptedTransactionLogs = true;
}
}
}
catch (Exception e) when(e is Exception || e is ClosedByInterruptException)
{
// These should not be parsing errors
throw e;
}
catch (Exception t)
{
_monitor.corruptedLogFile(version, t);
if (_failOnCorruptedLogFiles)
{
throwUnableToCleanRecover(t);
}
corruptedTransactionLogs = true;
}
if (latestCheckPoint != null)
{
return(CheckpointTailInformation(highestLogVersion, latestStartEntry, oldestVersionFound, latestLogEntryVersion, latestCheckPoint, corruptedTransactionLogs));
}
version--;
// if we have found no commits in the latest log, keep searching in the next one
if (latestStartEntry == null)
{
versionToSearchForCommits--;
}
}
return(new LogTailInformation(corruptedTransactionLogs || startRecordAfterCheckpoint, oldestStartEntryTransaction, oldestVersionFound, highestLogVersion, latestLogEntryVersion));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: protected LogTailInformation checkpointTailInformation(long highestLogVersion, org.neo4j.kernel.impl.transaction.log.entry.LogEntryStart latestStartEntry, long oldestVersionFound, org.neo4j.kernel.impl.transaction.log.entry.LogEntryVersion latestLogEntryVersion, org.neo4j.kernel.impl.transaction.log.entry.CheckPoint latestCheckPoint, boolean corruptedTransactionLogs) throws java.io.IOException
protected internal virtual LogTailInformation CheckpointTailInformation(long highestLogVersion, LogEntryStart latestStartEntry, long oldestVersionFound, LogEntryVersion latestLogEntryVersion, CheckPoint latestCheckPoint, bool corruptedTransactionLogs)
{
LogPosition checkPointLogPosition = latestCheckPoint.LogPosition;
ExtractedTransactionRecord transactionRecord = ExtractFirstTxIdAfterPosition(checkPointLogPosition, highestLogVersion);
long firstTxIdAfterPosition = transactionRecord.Id;
bool startRecordAfterCheckpoint = (firstTxIdAfterPosition != NoTransactionId) || ((latestStartEntry != null) && (latestStartEntry.StartPosition.CompareTo(latestCheckPoint.LogPosition) >= 0));
bool corruptedLogs = transactionRecord.Failure || corruptedTransactionLogs;
return(new LogTailInformation(latestCheckPoint, corruptedLogs || startRecordAfterCheckpoint, firstTxIdAfterPosition, oldestVersionFound, highestLogVersion, latestLogEntryVersion));
}
