void CloseFile()
{
if (_currentFile != null)
{
(_currentFile as IDisposable)?.Dispose();
_currentFile = null;
}
_nextCheckpoint = null;
}
/// <summary> Closes the file. </summary>
private void CloseFile()
{
if (this.currentFile != null)
{
(this.currentFile as IDisposable)?.Dispose();
this.currentFile = null;
}
this.nextCheckpoint = null;
}
/// <summary>
/// Copies the <see cref="IFileSource"/> to an <see cref="IFileSink"/>.
/// </summary>
/// <param name="sourceFileSource">The source file source.</param>
/// <param name="targetFileSink">The target file sink.</param>
public static void CopyTo(this IFileSource sourceFileSource, IFileSink targetFileSink)
{
foreach (string file in sourceFileSource.Files)
{
using (Stream inputStream = sourceFileSource.OpenFile(file))
using (Stream outputStream = targetFileSink.CreateFile(file))
{
inputStream.CopyTo(outputStream);
}
}
}
void OpenFile(DateTime now, int?minSequence = null)
{
var currentCheckpoint = _roller.GetCurrentCheckpoint(now);
// We only try periodically because repeated failures
// to open log files REALLY slow an app down.
_nextCheckpoint = _roller.GetNextCheckpoint(now) ?? now.AddMinutes(30);
var existingFiles = Enumerable.Empty <string>();
try
{
existingFiles = Directory.GetFiles(_roller.LogFileDirectory, _roller.DirectorySearchPattern)
.Select(Path.GetFileName);
}
catch (DirectoryNotFoundException) { }
var latestForThisCheckpoint = _roller
.SelectMatches(existingFiles)
.Where(m => m.DateTime == currentCheckpoint)
.OrderByDescending(m => m.SequenceNumber)
.FirstOrDefault();
var sequence = latestForThisCheckpoint?.SequenceNumber;
if (minSequence != null)
{
if (sequence == null || sequence.Value < minSequence.Value)
{
sequence = minSequence;
}
}
const int maxAttempts = 3;
for (var attempt = 0; attempt < maxAttempts; attempt++)
{
_roller.GetLogFilePath(now, sequence, out var path);
try
{
_currentFile = _shared ?
(IFileSink) new SharedFileSink(path, _textFormatter, _fileSizeLimitBytes, _encoding) :
new FileSink(path, _textFormatter, _fileSizeLimitBytes, _encoding, _buffered);
_currentFileSequence = sequence;
}
catch (IOException ex)
{
if (IOErrors.IsLockedFile(ex))
{
SelfLog.WriteLine("File target {0} was locked, attempting to open next in sequence (attempt {1})", path, attempt + 1);
sequence = (sequence ?? 0) + 1;
continue;
}
throw;
}
ApplyRetentionPolicy(path);
return;
}
}
/// <summary> Opens the file. </summary>
/// <exception cref="DirectoryNotFoundException">
/// Thrown when the requested directory is not
/// present.
/// </exception>
/// <exception cref="IOException"> Thrown when an IO failure occurred. </exception>
/// <param name="now"> The now. </param>
/// <param name="minSequence"> (Optional) The minimum sequence. </param>
private void OpenFile(DateTime now, int?minSequence = null)
{
var currentCheckpoint = this.pathRoller.GetCurrentCheckpoint(now);
// We only try periodically because repeated failures
// to open log files REALLY slow an app down.
this.nextCheckpoint = this.pathRoller.GetNextCheckpoint(now) ?? now.AddMinutes(30);
var existingFiles = Enumerable.Empty <string>();
try
{
if (Directory.Exists(this.pathRoller.LogFileDirectory))
{
existingFiles = Directory.GetFiles(
this.pathRoller.LogFileDirectory,
this.pathRoller.DirectorySearchPattern).Select(Path.GetFileName);
}
}
catch (DirectoryNotFoundException)
{
SelfLog.WriteLine("Temporary log directory is not found");
throw;
}
var latestForThisCheckpoint = this.pathRoller.SelectMatches(existingFiles)
.Where(m => m.DateTime == currentCheckpoint).OrderByDescending(m => m.SequenceNumber).FirstOrDefault();
var sequence = latestForThisCheckpoint?.SequenceNumber;
if (minSequence != null && (sequence == null || sequence.Value < minSequence.Value))
{
sequence = minSequence;
}
const int MaxAttempts = 3;
for (var attempt = 0; attempt < MaxAttempts; attempt++)
{
this.pathRoller.GetLogFilePath(now, sequence, out var path);
try
{
this.currentFile = new FileSink(
path,
this.textFormatter,
this.fileSizeLimitBytes,
this.encoding,
this.buffered,
this.fileLifecycleHooks);
this.currentFileName = path;
this.currentFileSequence = sequence;
}
catch (IOException ex)
{
if (!IoErrors.IsLockedFile(ex))
{
throw;
}
SelfLog.WriteLine(
"File target {0} was locked, attempting to open next in sequence (attempt {1})",
path,
attempt + 1);
sequence = (sequence ?? 0) + 1;
continue;
}
this.ApplyRetentionPolicy(path);
return;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TsSymbolWriter"/> class.
/// </summary>
/// <param name="fileSink">The file sink.</param>
public TsSymbolWriter(IFileSink fileSink)
{
this.fileSink = fileSink;
}
void OpenFile(DateTime now, int?minSequence = null)
{
var currentCheckpoint = _roller.GetCurrentCheckpoint(now);
// We only try periodically because repeated failures
// to open log files REALLY slow an app down.
var existingFiles = Enumerable.Empty <string>();
try
{
if (Directory.Exists(_roller.LogFileDirectory))
{
existingFiles = Directory.GetFiles(_roller.LogFileDirectory, _roller.DirectorySearchPattern)
.Select(Path.GetFileName);
}
}
catch (DirectoryNotFoundException)
{
}
var latestForThisCheckpoint = _roller
.SelectMatches(existingFiles)
.Where(m => m.DateTime == currentCheckpoint)
.OrderByDescending(m => m.SequenceNumber)
.FirstOrDefault();
var sequence = latestForThisCheckpoint?.SequenceNumber;
if (_keepFilename)
{
//Sequence number calculation is wrong when keeping filename. If there is an existing log file, latestForThisCheckpoint won't be null but will report
// a sequence number of 0 because filename will be (log.txt), if there are two files: sequence number will report 1 (log.txt, log-001.txt).
// But it should report 1 in the first case and 2 in the second case.
//
if (sequence == null)
{
if (latestForThisCheckpoint != null)
{
sequence = 1;
}
}
else
{
sequence++;
}
}
if (minSequence != null)
{
if (sequence == null || sequence.Value < minSequence.Value)
{
sequence = minSequence;
}
}
if (_keepFilename)
{
const int maxAttempts = 3;
// if current file exists we rename it with rolling date
//we lock this portion of the code to avoid another process in shared mode to move the file
//at the same time we are moving it. It might result in a missing file exception, because the second thread will try to move a file that has
//been already moved.
lock (_syncLock)
{
_roller.GetLogFilePath(out var currentPath);
var fileInfo = new FileInfo(currentPath);
//we check of we have reach file size limit, if not we keep the same file. If we dont have roll on file size enable, we will create a new file as soon as one exists even if it is empty.
if (File.Exists(currentPath) && MustRoll(now) && (_rollOnFileSizeLimit ? fileInfo.Length >= _fileSizeLimitBytes : fileInfo.Length > 0))
{
for (var attempt = 0; attempt < maxAttempts; attempt++)
{
_roller.GetLogFilePath(_useLastWriteAsTimestamp ? fileInfo.LastWriteTime : now,
sequence, out var path);
try
{
System.IO.File.Move(currentPath, path);
_currentFileSequence = sequence;
}
catch (IOException ex)
{
if (IOErrors.IsLockedFile(ex) || File.Exists(path))
{
SelfLog.WriteLine(
"File target {0} was locked or exists, attempting to open next in sequence (attempt {1})",
path, attempt + 1);
sequence = (sequence ?? 0) + 1;
continue;
}
throw;
}
break;
}
}
//now we open the current file
try
{
_currentFile = _shared
?
#pragma warning disable 618
(IFileSink) new SharedFileSink(currentPath, _textFormatter, _fileSizeLimitBytes, _encoding)
:
#pragma warning restore 618
new FileSink(currentPath, _textFormatter, _fileSizeLimitBytes, _encoding, _buffered, _hooks);
}
catch (IOException ex)
{
if (IOErrors.IsLockedFile(ex))
{
SelfLog.WriteLine("File target {0} was locked, this should not happen", currentPath);
}
throw;
}
ApplyRetentionPolicy(currentPath);
}
}
else
{
const int maxAttempts = 3;
for (var attempt = 0; attempt < maxAttempts; attempt++)
{
_roller.GetLogFilePath(now, sequence, out var path);
try
{
_currentFile = _shared
?
#pragma warning disable 618
(IFileSink) new SharedFileSink(path, _textFormatter, _fileSizeLimitBytes, _encoding)
:
#pragma warning restore 618
new FileSink(path, _textFormatter, _fileSizeLimitBytes, _encoding, _buffered, _hooks);
_currentFileSequence = sequence;
}
catch (IOException ex)
{
if (IOErrors.IsLockedFile(ex))
{
SelfLog.WriteLine(
"File target {0} was locked, attempting to open next in sequence (attempt {1})", path,
attempt + 1);
sequence = (sequence ?? 0) + 1;
continue;
}
throw;
}
ApplyRetentionPolicy(path);
return;
}
}
_nextCheckpoint = _roller.GetNextCheckpoint(now) ?? now.AddMinutes(30);
}
/// <summary>
/// Initializes a new instance of the <see cref="AuditingFileSink"/> class.
/// </summary>
/// <param name="fileSink">The file sink.</param>
public AuditingFileSink(IFileSink fileSink)
{
this.fileSink = fileSink;
}
