//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void extractTransactionalInformationFromLogs(String path, java.io.File customLogLocation, org.neo4j.io.layout.DatabaseLayout databaseLayout, java.io.File storeDir) throws java.io.IOException
private void ExtractTransactionalInformationFromLogs(string path, File customLogLocation, DatabaseLayout databaseLayout, File storeDir)
{
LogService logService = new SimpleLogService(NullLogProvider.Instance, NullLogProvider.Instance);
File neoStore = databaseLayout.MetadataStore();
GraphDatabaseService database = (new TestGraphDatabaseFactory()).newEmbeddedDatabaseBuilder(storeDir).setConfig(logical_logs_location, path).newGraphDatabase();
for (int i = 0; i < 10; i++)
{
using (Transaction transaction = database.BeginTx())
{
Node node = database.CreateNode();
transaction.Success();
}
}
database.Shutdown();
MetaDataStore.setRecord(_pageCache, neoStore, MetaDataStore.Position.LAST_CLOSED_TRANSACTION_LOG_VERSION, MetaDataRecordFormat.FIELD_NOT_PRESENT);
Config config = Config.defaults(logical_logs_location, path);
StoreMigrator migrator = new StoreMigrator(_fileSystemRule.get(), _pageCache, config, logService, _jobScheduler);
LogPosition logPosition = migrator.ExtractTransactionLogPosition(neoStore, databaseLayout, 100);
File[] logFiles = customLogLocation.listFiles();
assertNotNull(logFiles);
assertEquals(0, logPosition.LogVersion);
assertEquals(logFiles[0].length(), logPosition.ByteOffset);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void reportProgressOnRecovery() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ReportProgressOnRecovery()
{
RecoveryService recoveryService = mock(typeof(RecoveryService), Answers.RETURNS_MOCKS);
CorruptedLogsTruncator logsTruncator = mock(typeof(CorruptedLogsTruncator));
RecoveryMonitor recoveryMonitor = mock(typeof(RecoveryMonitor));
TransactionCursor reverseTransactionCursor = mock(typeof(TransactionCursor));
TransactionCursor transactionCursor = mock(typeof(TransactionCursor));
CommittedTransactionRepresentation transactionRepresentation = mock(typeof(CommittedTransactionRepresentation));
int transactionsToRecover = 5;
int expectedMax = transactionsToRecover * 2;
int lastCommittedTransactionId = 14;
LogPosition recoveryStartPosition = LogPosition.start(0);
int firstTxIdAfterLastCheckPoint = 10;
RecoveryStartInformation startInformation = new RecoveryStartInformation(recoveryStartPosition, firstTxIdAfterLastCheckPoint);
when(reverseTransactionCursor.next()).thenAnswer(new NextTransactionAnswer(transactionsToRecover));
when(transactionCursor.next()).thenAnswer(new NextTransactionAnswer(transactionsToRecover));
when(reverseTransactionCursor.get()).thenReturn(transactionRepresentation);
when(transactionCursor.get()).thenReturn(transactionRepresentation);
when(transactionRepresentation.CommitEntry).thenReturn(new LogEntryCommit(lastCommittedTransactionId, 1L));
when(recoveryService.RecoveryStartInformation).thenReturn(startInformation);
when(recoveryService.GetTransactionsInReverseOrder(recoveryStartPosition)).thenReturn(reverseTransactionCursor);
when(recoveryService.GetTransactions(recoveryStartPosition)).thenReturn(transactionCursor);
AssertableProgressReporter progressReporter = new AssertableProgressReporter(expectedMax);
Recovery recovery = new Recovery(recoveryService, logsTruncator, new LifecycleAdapter(), recoveryMonitor, progressReporter, true);
Recovery.init();
progressReporter.Verify();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotFindLogPosition()
public virtual void ShouldNotFindLogPosition()
{
// given
const long txId = 1L;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.transaction.log.PhysicalLogicalTransactionStore.LogVersionLocator locator = new org.neo4j.kernel.impl.transaction.log.PhysicalLogicalTransactionStore.LogVersionLocator(txId);
PhysicalLogicalTransactionStore.LogVersionLocator locator = new PhysicalLogicalTransactionStore.LogVersionLocator(txId);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.transaction.log.LogPosition position = new org.neo4j.kernel.impl.transaction.log.LogPosition(1, 128);
LogPosition position = new LogPosition(1, 128);
// when
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final boolean result = locator.visit(position, firstTxIdInLog, lastTxIdInLog);
bool result = locator.Visit(position, _firstTxIdInLog, _lastTxIdInLog);
// then
assertTrue(result);
try
{
locator.LogPosition;
fail("should have thrown");
}
catch (NoSuchTransactionException e)
{
assertEquals("Unable to find transaction " + txId + " in any of my logical logs: " + "Couldn't find any log containing " + txId, e.Message);
}
}
public override void Checkpoint(CheckPoint checkpoint, LogPosition checkpointEntryPosition)
{
foreach (Monitor monitor in Monitors)
{
monitor.Checkpoint(checkpoint, checkpointEntryPosition);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void writeAndReadLastTxLogPosition() throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void WriteAndReadLastTxLogPosition()
{
StoreMigrator migrator = NewStoreMigrator();
LogPosition writtenLogPosition = new LogPosition(_random.nextLong(), _random.nextLong());
migrator.WriteLastTxLogPosition(_directory.databaseLayout(), writtenLogPosition);
LogPosition readLogPosition = migrator.ReadLastTxLogPosition(_directory.databaseLayout());
assertEquals(writtenLogPosition, readLogPosition);
}
/// <summary>
/// Truncate all transaction logs after provided position. Log version specified in a position will be
/// truncated to provided byte offset, any subsequent log files will be deleted. Backup copy of removed data will
/// be stored in separate archive. </summary>
/// <param name="positionAfterLastRecoveredTransaction"> position after last recovered transaction </param>
/// <exception cref="IOException"> </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void truncate(org.neo4j.kernel.impl.transaction.log.LogPosition positionAfterLastRecoveredTransaction) throws java.io.IOException
public virtual void Truncate(LogPosition positionAfterLastRecoveredTransaction)
{
long recoveredTransactionLogVersion = positionAfterLastRecoveredTransaction.LogVersion;
long recoveredTransactionOffset = positionAfterLastRecoveredTransaction.ByteOffset;
if (IsRecoveredLogCorrupted(recoveredTransactionLogVersion, recoveredTransactionOffset) || HaveMoreRecentLogFiles(recoveredTransactionLogVersion))
{
BackupCorruptedContent(recoveredTransactionLogVersion, recoveredTransactionOffset);
TruncateLogFiles(recoveredTransactionLogVersion, recoveredTransactionOffset);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldRecoverFromStartOfLogZeroIfThereAreNoCheckPointAndOldestLogIsVersionZero()
public virtual void ShouldRecoverFromStartOfLogZeroIfThereAreNoCheckPointAndOldestLogIsVersionZero()
{
// given
when(_tailScanner.TailInformation).thenReturn(new LogTailInformation(true, 10L, INITIAL_LOG_VERSION, _currentLogVersion, LogEntryVersion.CURRENT));
// when
RecoveryStartInformation recoveryStartInformation = (new RecoveryStartInformationProvider(_tailScanner, _monitor)).get();
// then
verify(_monitor).noCheckPointFound();
assertEquals(LogPosition.start(INITIAL_LOG_VERSION), recoveryStartInformation.RecoveryPosition);
assertEquals(10L, recoveryStartInformation.FirstTxIdAfterLastCheckPoint);
assertTrue(recoveryStartInformation.RecoveryRequired);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldReturnUnspecifiedIfNothingHasBeenMarked()
public virtual void ShouldReturnUnspecifiedIfNothingHasBeenMarked()
{
// given
//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();
// when
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.transaction.log.LogPosition logPosition = marker.newPosition();
LogPosition logPosition = marker.NewPosition();
// given
assertEquals(LogPosition.UNSPECIFIED, logPosition);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldReturnLogPositionToRecoverFromIfNeeded()
public virtual void ShouldReturnLogPositionToRecoverFromIfNeeded()
{
// given
LogPosition checkPointLogPosition = new LogPosition(1L, 4242);
when(_tailScanner.TailInformation).thenReturn(new LogTailInformation(new CheckPoint(checkPointLogPosition), true, 10L, _logVersion, _currentLogVersion, LogEntryVersion.CURRENT));
// when
RecoveryStartInformation recoveryStartInformation = (new RecoveryStartInformationProvider(_tailScanner, _monitor)).get();
// then
verify(_monitor).commitsAfterLastCheckPoint(checkPointLogPosition, 10L);
assertEquals(checkPointLogPosition, recoveryStartInformation.RecoveryPosition);
assertEquals(10L, recoveryStartInformation.FirstTxIdAfterLastCheckPoint);
assertTrue(recoveryStartInformation.RecoveryRequired);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldReturnTheMarkedPosition()
public virtual void ShouldReturnTheMarkedPosition()
{
// given
//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();
// when
marker.Mark(1, 2);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.transaction.log.LogPosition logPosition = marker.newPosition();
LogPosition logPosition = marker.NewPosition();
// given
assertEquals(new LogPosition(1, 2), logPosition);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldClearTheCache()
public virtual void ShouldClearTheCache()
{
// given
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final RaftLogMetadataCache cache = new RaftLogMetadataCache(2);
RaftLogMetadataCache cache = new RaftLogMetadataCache(2);
const long index = 12L;
const long term = 12L;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.transaction.log.LogPosition position = new org.neo4j.kernel.impl.transaction.log.LogPosition(3, 4);
LogPosition position = new LogPosition(3, 4);
// when
cache.CacheMetadata(index, term, position);
cache.Clear();
RaftLogMetadataCache.RaftLogEntryMetadata metadata = cache.GetMetadata(index);
// then
assertNull(metadata);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldFindLogPosition() throws org.neo4j.kernel.impl.transaction.log.NoSuchTransactionException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldFindLogPosition()
{
// given
const long txId = 42L;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.transaction.log.PhysicalLogicalTransactionStore.LogVersionLocator locator = new org.neo4j.kernel.impl.transaction.log.PhysicalLogicalTransactionStore.LogVersionLocator(txId);
PhysicalLogicalTransactionStore.LogVersionLocator locator = new PhysicalLogicalTransactionStore.LogVersionLocator(txId);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.transaction.log.LogPosition position = new org.neo4j.kernel.impl.transaction.log.LogPosition(1, 128);
LogPosition position = new LogPosition(1, 128);
// when
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final boolean result = locator.visit(position, firstTxIdInLog, lastTxIdInLog);
bool result = locator.Visit(position, _firstTxIdInLog, _lastTxIdInLog);
// then
assertFalse(result);
assertEquals(position, locator.LogPosition);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public static void removeCheckPointFromTxLog(org.neo4j.io.fs.FileSystemAbstraction fileSystem, java.io.File databaseDirectory) throws java.io.IOException
public static void RemoveCheckPointFromTxLog(FileSystemAbstraction fileSystem, File databaseDirectory)
{
LogFiles logFiles = LogFilesBuilder.logFilesBasedOnlyBuilder(databaseDirectory, fileSystem).build();
LogEntryReader <ReadableClosablePositionAwareChannel> logEntryReader = new VersionAwareLogEntryReader <ReadableClosablePositionAwareChannel>();
LogTailScanner tailScanner = new LogTailScanner(logFiles, logEntryReader, new Monitors());
LogTailScanner.LogTailInformation logTailInformation = tailScanner.TailInformation;
if (logTailInformation.CommitsAfterLastCheckpoint())
{
// done already
return;
}
// let's assume there is at least a checkpoint
assertNotNull(logTailInformation.LastCheckPoint);
LogPosition logPosition = logTailInformation.LastCheckPoint.LogPosition;
File logFile = logFiles.GetLogFileForVersion(logPosition.LogVersion);
fileSystem.Truncate(logFile, logPosition.ByteOffset);
}
public RecoveryStartInformation(LogPosition recoveryPosition, long firstTxIdAfterLastCheckPoint)
{
this._firstTxIdAfterLastCheckPoint = firstTxIdAfterLastCheckPoint;
this._recoveryPosition = recoveryPosition;
}
public RaftLogEntryMetadata(long entryTerm, LogPosition startPosition)
{
Objects.requireNonNull(startPosition);
this.EntryTermConflict = entryTerm;
this.StartPositionConflict = startPosition;
}
public virtual RaftLogEntryMetadata CacheMetadata(long logIndex, long entryTerm, LogPosition position)
{
RaftLogEntryMetadata result = new RaftLogEntryMetadata(entryTerm, position);
_raftLogEntryCache.put(logIndex, result);
return(result);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.neo4j.kernel.impl.transaction.log.TransactionCursor getTransactionsInReverseOrder(org.neo4j.kernel.impl.transaction.log.LogPosition position) throws java.io.IOException
public override TransactionCursor GetTransactionsInReverseOrder(LogPosition position)
{
return(_logicalTransactionStore.getTransactionsInReverseOrder(position));
}
public override void TransactionsRecovered(CommittedTransactionRepresentation lastRecoveredTransaction, LogPosition positionAfterLastRecoveredTransaction)
{
long recoveredTransactionLogVersion = positionAfterLastRecoveredTransaction.LogVersion;
long recoveredTransactionOffset = positionAfterLastRecoveredTransaction.ByteOffset;
if (lastRecoveredTransaction != null)
{
LogEntryCommit commitEntry = lastRecoveredTransaction.CommitEntry;
_transactionIdStore.setLastCommittedAndClosedTransactionId(commitEntry.TxId, LogEntryStart.checksum(lastRecoveredTransaction.StartEntry), commitEntry.TimeWritten, recoveredTransactionOffset, recoveredTransactionLogVersion);
}
_logVersionRepository.CurrentLogVersion = recoveredTransactionLogVersion;
}
public override void RecoveryRequired(LogPosition recoveryPosition)
{
RecoveryWasPerformed = true;
}
