//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void execute() throws java.io.IOException, org.neo4j.commandline.admin.CommandFailed
public virtual void Execute()
{
if (!_fs.fileExists(_fromDatabasePath))
{
throw new System.ArgumentException(format("Source directory does not exist [%s]", _fromDatabasePath));
}
try
{
Validators.CONTAINS_EXISTING_DATABASE.validate(_fromDatabasePath);
}
catch (System.ArgumentException)
{
throw new System.ArgumentException(format("Source directory is not a database backup [%s]", _fromDatabasePath));
}
if (_fs.fileExists(_toDatabaseDir) && !_forceOverwrite)
{
throw new System.ArgumentException(format("Database with name [%s] already exists at %s", _toDatabaseName, _toDatabaseDir));
}
checkLock(DatabaseLayout.of(_toDatabaseDir).StoreLayout);
_fs.deleteRecursively(_toDatabaseDir);
if (!isSameOrChildFile(_toDatabaseDir, _transactionLogsDirectory))
{
_fs.deleteRecursively(_transactionLogsDirectory);
}
LogFiles backupLogFiles = LogFilesBuilder.logFilesBasedOnlyBuilder(_fromDatabasePath, _fs).build();
RestoreDatabaseFiles(backupLogFiles, _fromDatabasePath.listFiles());
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private org.neo4j.kernel.impl.transaction.log.ReadableLogChannel openLogFile(org.neo4j.io.fs.FileSystemAbstraction fs, int version) throws java.io.IOException
internal virtual ReadableLogChannel OpenLogFile(FileSystemAbstraction fs, int version)
{
LogFiles logFiles = LogFilesBuilder.logFilesBasedOnlyBuilder(WorkingDirectory, fs).build();
PhysicalLogVersionedStoreChannel channel = logFiles.OpenForVersion(version);
return(new ReadAheadLogChannel(channel, new ReaderLogVersionBridge(logFiles)));
}
public LogRotationImpl(LogRotation_Monitor monitor, LogFiles logFiles, DatabaseHealth databaseHealth)
{
this._monitor = monitor;
this._logFiles = logFiles;
this._databaseHealth = databaseHealth;
this._logFile = logFiles.LogFile;
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldSuppressFailureToCloseChannelInFailedAttemptToReadHeaderAfterOpen() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldSuppressFailureToCloseChannelInFailedAttemptToReadHeaderAfterOpen()
{
// GIVEN a file which returns 1/2 log header size worth of bytes
FileSystemAbstraction fs = mock(typeof(FileSystemAbstraction));
LogFiles logFiles = LogFilesBuilder.builder(_directory.databaseLayout(), fs).withTransactionIdStore(_transactionIdStore).withLogVersionRepository(_logVersionRepository).build();
int logVersion = 0;
File logFile = logFiles.GetLogFileForVersion(logVersion);
StoreChannel channel = mock(typeof(StoreChannel));
when(channel.read(any(typeof(ByteBuffer)))).thenReturn(LogHeader.LOG_HEADER_SIZE / 2);
when(fs.FileExists(logFile)).thenReturn(true);
when(fs.Open(eq(logFile), any(typeof(OpenMode)))).thenReturn(channel);
doThrow(typeof(IOException)).when(channel).close();
// WHEN
try
{
logFiles.OpenForVersion(logVersion);
fail("Should have failed");
}
catch (IncompleteLogHeaderException e)
{
// THEN good
verify(channel).close();
assertEquals(1, e.Suppressed.length);
assertTrue(e.Suppressed[0] is IOException);
}
}
internal ThresholdBasedPruneStrategy(FileSystemAbstraction fileSystem, LogFiles logFiles, Threshold threshold)
{
this._fileSystem = fileSystem;
this._files = logFiles;
this._logFileInformation = _files.LogFileInformation;
this._threshold = threshold;
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldWriteSomeDataIntoTheLog() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldWriteSomeDataIntoTheLog()
{
// GIVEN
string name = "log";
FileSystemAbstraction fs = _fileSystemRule.get();
LogFiles logFiles = LogFilesBuilder.builder(_directory.databaseLayout(), fs).withTransactionIdStore(_transactionIdStore).withLogVersionRepository(_logVersionRepository).build();
_life.start();
_life.add(logFiles);
// WHEN
FlushablePositionAwareChannel writer = logFiles.LogFile.Writer;
LogPositionMarker positionMarker = new LogPositionMarker();
writer.GetCurrentPosition(positionMarker);
int intValue = 45;
long longValue = 4854587;
writer.PutInt(intValue);
writer.PutLong(longValue);
writer.PrepareForFlush().flush();
// THEN
using (ReadableClosableChannel reader = logFiles.LogFile.getReader(positionMarker.NewPosition()))
{
assertEquals(intValue, reader.Int);
assertEquals(longValue, reader.Long);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public ReadOnlyTransactionStore(org.neo4j.io.pagecache.PageCache pageCache, org.neo4j.io.fs.FileSystemAbstraction fs, org.neo4j.io.layout.DatabaseLayout fromDatabaseLayout, org.neo4j.kernel.configuration.Config config, org.neo4j.kernel.monitoring.Monitors monitors) throws java.io.IOException
public ReadOnlyTransactionStore(PageCache pageCache, FileSystemAbstraction fs, DatabaseLayout fromDatabaseLayout, Config config, Monitors monitors)
{
TransactionMetadataCache transactionMetadataCache = new TransactionMetadataCache();
LogEntryReader <ReadableClosablePositionAwareChannel> logEntryReader = new VersionAwareLogEntryReader <ReadableClosablePositionAwareChannel>();
LogFiles logFiles = LogFilesBuilder.activeFilesBuilder(fromDatabaseLayout, fs, pageCache).withLogEntryReader(logEntryReader).withConfig(config).build();
_physicalStore = new PhysicalLogicalTransactionStore(logFiles, transactionMetadataCache, logEntryReader, monitors, true);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public TemporaryStoreDirectory(org.neo4j.io.fs.FileSystemAbstraction fs, org.neo4j.io.pagecache.PageCache pageCache, java.io.File parent) throws java.io.IOException
public TemporaryStoreDirectory(FileSystemAbstraction fs, PageCache pageCache, File parent)
{
this._tempStoreDir = new File(parent, TEMP_COPY_DIRECTORY_NAME);
this._tempDatabaseLayout = DatabaseLayout.of(_tempStoreDir, GraphDatabaseSettings.DEFAULT_DATABASE_NAME);
_storeFiles = new StoreFiles(fs, pageCache, (directory, name) => true);
_tempLogFiles = LogFilesBuilder.logFilesBasedOnlyBuilder(_tempDatabaseLayout.databaseDirectory(), fs).build();
_storeFiles.delete(_tempStoreDir, _tempLogFiles);
}
public PhysicalLogicalTransactionStore(LogFiles logFiles, TransactionMetadataCache transactionMetadataCache, LogEntryReader <ReadableClosablePositionAwareChannel> logEntryReader, Monitors monitors, bool failOnCorruptedLogFiles)
{
this._logFiles = logFiles;
this._logFile = logFiles.LogFile;
this._transactionMetadataCache = transactionMetadataCache;
this._logEntryReader = logEntryReader;
this._monitors = monitors;
this._failOnCorruptedLogFiles = failOnCorruptedLogFiles;
}
internal NeoStoreTransactionLogModule(LogicalTransactionStore logicalTransactionStore, LogFiles logFiles, LogRotation logRotation, CheckPointerImpl checkPointer, TransactionAppender appender, SynchronizedArrayIdOrderingQueue explicitIndexTransactionOrdering)
{
this._logicalTransactionStore = logicalTransactionStore;
this._logFiles = logFiles;
this._logRotation = logRotation;
this._checkPointer = checkPointer;
this._appender = appender;
this._explicitIndexTransactionOrdering = explicitIndexTransactionOrdering;
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void setUp()
public virtual void SetUp()
{
_fs = mock(typeof(FileSystemAbstraction));
_logFiles = mock(typeof(LogFiles));
doAnswer(inv => new File((inv.Arguments[0]).ToString())).when(_logFiles).getLogFileForVersion(anyLong());
_logProvider = NullLogProvider.Instance;
_clock = mock(typeof(Clock));
_factory = mock(typeof(LogPruneStrategyFactory));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public static java.io.File[] filterNeostoreLogicalLog(org.neo4j.kernel.impl.transaction.log.files.LogFiles logFiles, org.neo4j.io.fs.FileSystemAbstraction fileSystem, LogHook<org.neo4j.kernel.impl.transaction.log.entry.LogEntry> filter) throws java.io.IOException
public static File[] FilterNeostoreLogicalLog(LogFiles logFiles, FileSystemAbstraction fileSystem, LogHook <LogEntry> filter)
{
File[] files = logFiles.LogFilesConflict();
foreach (File file in files)
{
FilterTransactionLogFile(fileSystem, file, filter);
}
return(files);
}
/// <summary>
/// Analyzes transactions found in log file(s) specified by {@code storeDirOrLogFile} calling methods on the supplied
/// <seealso cref="Monitor"/> for each encountered data item.
/// </summary>
/// <param name="fileSystem"> <seealso cref="FileSystemAbstraction"/> to find the files on. </param>
/// <param name="storeDirOrLogFile"> <seealso cref="File"/> pointing either to a directory containing transaction log files, or directly
/// pointing to a single transaction log file to analyze. </param>
/// <param name="invalidLogEntryHandler"> <seealso cref="InvalidLogEntryHandler"/> to pass in to the internal <seealso cref="LogEntryReader"/>. </param>
/// <param name="monitor"> <seealso cref="Monitor"/> receiving call-backs for all <seealso cref="Monitor.transaction(LogEntry[]) transactions"/>,
/// <seealso cref="Monitor.checkpoint(CheckPoint, LogPosition) checkpoints"/> and <seealso cref="Monitor.logFile(File, long) log file transitions"/>
/// encountered during the analysis. </param>
/// <exception cref="IOException"> on I/O error. </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public static void analyze(org.neo4j.io.fs.FileSystemAbstraction fileSystem, java.io.File storeDirOrLogFile, org.neo4j.kernel.impl.transaction.log.entry.InvalidLogEntryHandler invalidLogEntryHandler, Monitor monitor) throws java.io.IOException
public static void Analyze(FileSystemAbstraction fileSystem, File storeDirOrLogFile, InvalidLogEntryHandler invalidLogEntryHandler, Monitor monitor)
{
File firstFile;
LogVersionBridge bridge;
ReadAheadLogChannel channel;
LogEntryReader <ReadableClosablePositionAwareChannel> entryReader;
LogPositionMarker positionMarker;
if (storeDirOrLogFile.Directory)
{
// Use natural log version bridging if a directory is supplied
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.transaction.log.files.LogFiles logFiles = org.neo4j.kernel.impl.transaction.log.files.LogFilesBuilder.logFilesBasedOnlyBuilder(storeDirOrLogFile, fileSystem).build();
LogFiles logFiles = LogFilesBuilder.logFilesBasedOnlyBuilder(storeDirOrLogFile, fileSystem).build();
bridge = new ReaderLogVersionBridgeAnonymousInnerClass(logFiles, monitor, channel);
long lowestLogVersion = logFiles.LowestLogVersion;
if (lowestLogVersion < 0)
{
throw new System.InvalidOperationException(format("Transaction logs at '%s' not found.", storeDirOrLogFile));
}
firstFile = logFiles.GetLogFileForVersion(lowestLogVersion);
monitor.LogFile(firstFile, lowestLogVersion);
}
else
{
// Use no bridging, simply reading this single log file if a file is supplied
firstFile = storeDirOrLogFile;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.transaction.log.files.LogFiles logFiles = org.neo4j.kernel.impl.transaction.log.files.LogFilesBuilder.logFilesBasedOnlyBuilder(storeDirOrLogFile, fileSystem).build();
LogFiles logFiles = LogFilesBuilder.logFilesBasedOnlyBuilder(storeDirOrLogFile, fileSystem).build();
monitor.LogFile(firstFile, logFiles.GetLogVersion(firstFile));
bridge = NO_MORE_CHANNELS;
}
channel = new ReadAheadLogChannel(openVersionedChannel(fileSystem, firstFile), bridge);
entryReader = new VersionAwareLogEntryReader <ReadableClosablePositionAwareChannel>(new RecordStorageCommandReaderFactory(), invalidLogEntryHandler);
positionMarker = new LogPositionMarker();
using (TransactionLogEntryCursor cursor = new TransactionLogEntryCursor(new LogEntryCursor(entryReader, channel)))
{
channel.GetCurrentPosition(positionMarker);
while (cursor.Next())
{
LogEntry[] tx = cursor.Get();
if (tx.Length == 1 && tx[0].Type == CHECK_POINT)
{
monitor.Checkpoint(tx[0].As(), positionMarker.NewPosition());
}
else
{
monitor.Transaction(tx);
}
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void appendDropTransactionToTransactionLog(java.io.File databaseDirectory, org.neo4j.kernel.impl.transaction.CommittedTransactionRepresentation dropTransaction) throws java.io.IOException
private void AppendDropTransactionToTransactionLog(File databaseDirectory, CommittedTransactionRepresentation dropTransaction)
{
LogFiles logFiles = LogFilesBuilder.logFilesBasedOnlyBuilder(databaseDirectory, Fs).build();
File logFile = logFiles.GetLogFileForVersion(logFiles.HighestLogVersion);
StoreChannel writeStoreChannel = Fs.open(logFile, OpenMode.READ_WRITE);
writeStoreChannel.Position(writeStoreChannel.size());
using (PhysicalFlushableChannel writeChannel = new PhysicalFlushableChannel(writeStoreChannel))
{
(new LogEntryWriter(writeChannel)).serialize(dropTransaction);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void writePartialTx(java.io.File storeDir) throws java.io.IOException
private void WritePartialTx(File storeDir)
{
using (PageCache pageCache = this.PageCache.getPageCache(_fs))
{
LogFiles logFiles = LogFilesBuilder.activeFilesBuilder(DatabaseLayout.of(storeDir), _fs, pageCache).build();
using (Lifespan ignored = new Lifespan(logFiles))
{
LogEntryWriter writer = new LogEntryWriter(logFiles.LogFile.Writer);
writer.WriteStartEntry(0, 0, 0x123456789ABCDEFL, logFiles.LogFileInformation.LastEntryId + 1, new sbyte[] { 0 });
}
}
}
private GraphDatabaseAPI NewDb(string logPruning, int rotateEveryNTransactions)
{
this._rotateEveryNTransactions = rotateEveryNTransactions;
_fs = new EphemeralFileSystemAbstraction();
TestGraphDatabaseFactory gdf = new TestGraphDatabaseFactory();
gdf.FileSystem = new UncloseableDelegatingFileSystemAbstraction(_fs);
GraphDatabaseBuilder builder = gdf.NewImpermanentDatabaseBuilder();
builder.setConfig(keep_logical_logs, logPruning);
this._db = ( GraphDatabaseAPI )builder.NewGraphDatabase();
_files = _db.DependencyResolver.resolveDependency(typeof(LogFiles));
return(_db);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public boolean isRecoveryRequiredAt(org.neo4j.io.layout.DatabaseLayout databaseLayout) throws java.io.IOException
public virtual bool IsRecoveryRequiredAt(DatabaseLayout databaseLayout)
{
// We need config to determine where the logical log files are
if (!NeoStores.isStorePresent(_pageCache, databaseLayout))
{
return(false);
}
LogEntryReader <ReadableClosablePositionAwareChannel> reader = new VersionAwareLogEntryReader <ReadableClosablePositionAwareChannel>();
LogFiles logFiles = LogFilesBuilder.activeFilesBuilder(databaseLayout, _fs, _pageCache).withConfig(_config).withLogEntryReader(reader).build();
LogTailScanner tailScanner = new LogTailScanner(logFiles, reader, _monitors);
return((new RecoveryStartInformationProvider(tailScanner, NO_MONITOR)).get().RecoveryRequired);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldReadOlderLogs() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldReadOlderLogs()
{
// GIVEN
FileSystemAbstraction fs = _fileSystemRule.get();
LogFiles logFiles = LogFilesBuilder.builder(_directory.databaseLayout(), fs).withTransactionIdStore(_transactionIdStore).withLogVersionRepository(_logVersionRepository).build();
_life.start();
_life.add(logFiles);
// WHEN
LogFile logFile = logFiles.LogFile;
FlushablePositionAwareChannel writer = logFile.Writer;
LogPositionMarker positionMarker = new LogPositionMarker();
writer.GetCurrentPosition(positionMarker);
LogPosition position1 = positionMarker.NewPosition();
int intValue = 45;
long longValue = 4854587;
sbyte[] someBytes = someBytes(40);
writer.PutInt(intValue);
writer.PutLong(longValue);
writer.Put(someBytes, someBytes.Length);
writer.PrepareForFlush().flush();
writer.GetCurrentPosition(positionMarker);
LogPosition position2 = positionMarker.NewPosition();
long longValue2 = 123456789L;
writer.PutLong(longValue2);
writer.Put(someBytes, someBytes.Length);
writer.PrepareForFlush().flush();
// THEN
using (ReadableClosableChannel reader = logFile.GetReader(position1))
{
assertEquals(intValue, reader.Int);
assertEquals(longValue, reader.Long);
assertArrayEquals(someBytes, ReadBytes(reader, 40));
}
using (ReadableClosableChannel reader = logFile.GetReader(position2))
{
assertEquals(longValue2, reader.Long);
assertArrayEquals(someBytes, ReadBytes(reader, 40));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldOpenInFreshDirectoryAndFinallyAddHeader() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldOpenInFreshDirectoryAndFinallyAddHeader()
{
// GIVEN
string name = "log";
FileSystemAbstraction fs = _fileSystemRule.get();
LogFiles logFiles = LogFilesBuilder.builder(_directory.databaseLayout(), fs).withTransactionIdStore(_transactionIdStore).withLogVersionRepository(_logVersionRepository).build();
// WHEN
_life.start();
_life.add(logFiles);
_life.shutdown();
// THEN
File file = LogFilesBuilder.logFilesBasedOnlyBuilder(_directory.databaseDir(), fs).build().getLogFileForVersion(1L);
LogHeader header = readLogHeader(fs, file);
assertEquals(1L, header.LogVersion);
assertEquals(2L, header.LastCommittedTxId);
}
//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 WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void restoreDatabaseFiles(org.neo4j.kernel.impl.transaction.log.files.LogFiles backupLogFiles, java.io.File[] files) throws java.io.IOException
private void RestoreDatabaseFiles(LogFiles backupLogFiles, File[] files)
{
if (files != null)
{
foreach (File file in files)
{
if (file.Directory)
{
File destination = new File(_toDatabaseDir, file.Name);
_fs.mkdirs(destination);
_fs.copyRecursively(file, destination);
}
else
{
_fs.copyToDirectory(file, backupLogFiles.IsLogFile(file) ? _transactionLogsDirectory : _toDatabaseDir);
}
}
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void skipLogFileWithoutHeader() throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void SkipLogFileWithoutHeader()
{
FileSystemAbstraction fs = _fileSystemRule.get();
LogFiles logFiles = LogFilesBuilder.builder(_directory.databaseLayout(), fs).withTransactionIdStore(_transactionIdStore).withLogVersionRepository(_logVersionRepository).build();
_life.add(logFiles);
_life.start();
// simulate new file without header presence
_logVersionRepository.incrementAndGetVersion();
fs.Create(logFiles.GetLogFileForVersion(_logVersionRepository.CurrentLogVersion)).close();
_transactionIdStore.transactionCommitted(5L, 5L, 5L);
PhysicalLogicalTransactionStore.LogVersionLocator versionLocator = new PhysicalLogicalTransactionStore.LogVersionLocator(4L);
logFiles.Accept(versionLocator);
LogPosition logPosition = versionLocator.LogPosition;
assertEquals(1, logPosition.LogVersion);
}
/// <summary>
/// Utility method for creating a <seealso cref="ReversedMultiFileTransactionCursor"/> with a <seealso cref="LogFile"/> as the source of
/// <seealso cref="TransactionCursor"/> for each log version.
/// </summary>
/// <param name="logFile"> <seealso cref="LogFile"/> to supply log entries forming transactions. </param>
/// <param name="backToPosition"> <seealso cref="LogPosition"/> to read backwards to. </param>
/// <param name="failOnCorruptedLogFiles"> fail reading from log files as soon as first error is encountered </param>
/// <param name="monitor"> reverse transaction cursor monitor </param>
/// <returns> a <seealso cref="TransactionCursor"/> which returns transactions from the end of the log stream and backwards to
/// and including transaction starting at <seealso cref="LogPosition"/>. </returns>
/// <exception cref="IOException"> on I/O error. </exception>
public static TransactionCursor FromLogFile(LogFiles logFiles, LogFile logFile, LogPosition backToPosition, bool failOnCorruptedLogFiles, ReversedTransactionCursorMonitor monitor)
{
long highestVersion = logFiles.HighestLogVersion;
LogEntryReader <ReadableClosablePositionAwareChannel> logEntryReader = new VersionAwareLogEntryReader <ReadableClosablePositionAwareChannel>();
ThrowingFunction <LogPosition, TransactionCursor, IOException> factory = position =>
{
ReadableLogChannel channel = logFile.GetReader(position, NO_MORE_CHANNELS);
if (channel is ReadAheadLogChannel)
{
// This is a channel which can be positioned explicitly and is the typical case for such channels
// Let's take advantage of this fact and use a bit smarter reverse implementation
return(new ReversedSingleFileTransactionCursor(( ReadAheadLogChannel )channel, logEntryReader, failOnCorruptedLogFiles, monitor));
}
// Fall back to simply eagerly reading each single log file and reversing in memory
return(eagerlyReverse(new PhysicalTransactionCursor <>(channel, logEntryReader)));
};
return(new ReversedMultiFileTransactionCursor(factory, highestVersion, backToPosition));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void appendCheckpoint(org.neo4j.kernel.impl.transaction.log.entry.LogEntryVersion logVersion) throws java.io.IOException
private void AppendCheckpoint(LogEntryVersion logVersion)
{
PageCache pageCache = _pageCacheRule.getPageCache(_fs);
VersionAwareLogEntryReader <ReadableClosablePositionAwareChannel> logEntryReader = new VersionAwareLogEntryReader <ReadableClosablePositionAwareChannel>();
LogFiles logFiles = LogFilesBuilder.activeFilesBuilder(_storeDirectory.databaseLayout(), _fs, pageCache).withLogEntryReader(logEntryReader).build();
LogTailScanner tailScanner = new LogTailScanner(logFiles, logEntryReader, new Monitors());
LogTailScanner.LogTailInformation tailInformation = tailScanner.TailInformation;
using (Lifespan lifespan = new Lifespan(logFiles))
{
FlushablePositionAwareChannel channel = logFiles.LogFile.Writer;
LogPosition logPosition = tailInformation.LastCheckPoint.LogPosition;
// Fake record
channel.Put(logVersion.byteCode()).put(CHECK_POINT).putLong(logPosition.LogVersion).putLong(logPosition.ByteOffset);
channel.PrepareForFlush().flush();
}
}
//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);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldVisitLogFile() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldVisitLogFile()
{
// GIVEN
string name = "log";
FileSystemAbstraction fs = _fileSystemRule.get();
LogFiles logFiles = LogFilesBuilder.builder(_directory.databaseLayout(), fs).withTransactionIdStore(_transactionIdStore).withLogVersionRepository(_logVersionRepository).build();
_life.start();
_life.add(logFiles);
LogFile logFile = logFiles.LogFile;
FlushablePositionAwareChannel writer = logFile.Writer;
LogPositionMarker mark = new LogPositionMarker();
writer.GetCurrentPosition(mark);
for (int i = 0; i < 5; i++)
{
writer.Put(( sbyte )i);
}
writer.PrepareForFlush();
// WHEN/THEN
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicBoolean called = new java.util.concurrent.atomic.AtomicBoolean();
AtomicBoolean called = new AtomicBoolean();
logFile.Accept(channel =>
{
for (int i = 0; i < 5; i++)
{
assertEquals(( sbyte )i, channel.get());
}
called.set(true);
return(true);
}, mark.NewPosition());
assertTrue(called.get());
}
/// <summary>
/// Parses a configuration value for log specifying log pruning. It has one of these forms:
/// <ul>
/// <li>all</li>
/// <li>[number][unit] [type]</li>
/// </ul>
/// For example:
/// <ul>
/// <li>100M size - For keeping last 100 megabytes of log data</li>
/// <li>20 pcs - For keeping last 20 non-empty log files</li>
/// <li>7 days - For keeping last 7 days worth of log data</li>
/// <li>1k hours - For keeping last 1000 hours worth of log data</li>
/// </ul>
/// </summary>
internal virtual LogPruneStrategy StrategyFromConfigValue(FileSystemAbstraction fileSystem, LogFiles logFiles, Clock clock, string configValue)
{
ThresholdConfigValue value = parse(configValue);
if (value == ThresholdConfigValue.NO_PRUNING)
{
return(NO_PRUNING);
}
Threshold thresholdToUse = GetThresholdByType(fileSystem, clock, value, configValue);
return(new ThresholdBasedPruneStrategy(fileSystem, logFiles, thresholdToUse));
}
/// <summary>
/// Opens a <seealso cref="LogEntryCursor"/> over all log files found in the storeDirectory
/// </summary>
/// <param name="fs"> <seealso cref="FileSystemAbstraction"/> to find {@code storeDirectory} in. </param>
/// <param name="logFiles"> the physical log files to read from </param>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public static org.neo4j.kernel.impl.transaction.log.LogEntryCursor openLogs(final org.neo4j.io.fs.FileSystemAbstraction fs, org.neo4j.kernel.impl.transaction.log.files.LogFiles logFiles) throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
public static LogEntryCursor OpenLogs(FileSystemAbstraction fs, LogFiles logFiles)
{
File firstFile = logFiles.GetLogFileForVersion(logFiles.LowestLogVersion);
return(OpenLogEntryCursor(fs, firstFile, new ReaderLogVersionBridge(logFiles)));
}
public ReaderLogVersionBridgeAnonymousInnerClass(LogFiles logFiles, Org.Neo4j.tools.dump.TransactionLogAnalyzer.Monitor monitor, ReadAheadLogChannel channel) : base(logFiles)
{
this._monitor = monitor;
this._channel = channel;
this._logFiles = logFiles;
}
private static BatchingTransactionAppender CreateBatchingTransactionAppender(TransactionIdStore transactionIdStore, TransactionMetadataCache transactionMetadataCache, LogFiles logFiles)
{
Log log = NullLog.Instance;
KernelEventHandlers kernelEventHandlers = new KernelEventHandlers(log);
DatabasePanicEventGenerator panicEventGenerator = new DatabasePanicEventGenerator(kernelEventHandlers);
DatabaseHealth databaseHealth = new DatabaseHealth(panicEventGenerator, log);
LogRotationImpl logRotation = new LogRotationImpl(NOOP_LOGROTATION_MONITOR, logFiles, databaseHealth);
return(new BatchingTransactionAppender(logFiles, logRotation, transactionMetadataCache, transactionIdStore, IdOrderingQueue.BYPASS, databaseHealth));
}
