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