//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)); }