/// <summary>
/// Initializes a new instance of the <see cref="FileAppenderCache"/> class.
/// </summary>
/// <remarks>
/// The size of the list should be positive. No validations are performed during initialisation as it is an
/// intenal class.
/// </remarks>
/// <param name="size">Total number of appenders allowed in list.</param>
/// <param name="appenderFactory">Factory used to create each appender.</param>
/// <param name="createFileParams">Parameters used for creating a file.</param>
public FileAppenderCache(int size, IFileAppenderFactory appenderFactory, ICreateFileParameters createFileParams)
{
Size = size;
Factory = appenderFactory;
CreateFileParameters = createFileParams;
appenders = new BaseFileAppender[Size];
}
public void FileAppenderCache_GetFileCharacteristics_Windows()
{
if (NLog.Internal.PlatformDetector.IsDesktopWin32)
{
IFileAppenderFactory appenderFactory = WindowsMultiProcessFileAppender.TheFactory;
ICreateFileParameters fileTarget = new FileTarget()
{
ArchiveNumbering = ArchiveNumberingMode.Date
};
FileAppenderCache_GetFileCharacteristics(appenderFactory, fileTarget);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="FileAppenderCache"/> class.
/// </summary>
/// <remarks>
/// The size of the list should be positive. No validations are performed during initialisation as it is an
/// intenal class.
/// </remarks>
/// <param name="size">Total number of appenders allowed in list.</param>
/// <param name="appenderFactory">Factory used to create each appender.</param>
/// <param name="createFileParams">Parameters used for creating a file.</param>
public FileAppenderCache(int size, IFileAppenderFactory appenderFactory, ICreateFileParameters createFileParams)
{
Size = size;
Factory = appenderFactory;
CreateFileParameters = createFileParams;
appenders = new BaseFileAppender[Size];
#if !SILVERLIGHT && !__IOS__ && !__ANDROID__
externalFileArchivingWatcher.OnChange += ExternalFileArchivingWatcher_OnChange;
#endif
}
/// <summary>
/// Initializes a new instance of the <see cref="FileAppenderCache"/> class.
/// </summary>
/// <remarks>
/// The size of the list should be positive. No validations are performed during initialisation as it is an
/// intenal class.
/// </remarks>
/// <param name="size">Total number of appenders allowed in list.</param>
/// <param name="appenderFactory">Factory used to create each appender.</param>
/// <param name="createFileParams">Parameters used for creating a file.</param>
public FileAppenderCache(int size, IFileAppenderFactory appenderFactory, ICreateFileParameters createFileParams)
{
Size = size;
Factory = appenderFactory;
CreateFileParameters = createFileParams;
appenders = new BaseFileAppender[Size];
#if !SILVERLIGHT && !__IOS__ && !__ANDROID__
externalFileArchivingWatcher.FileChanged += ExternalFileArchivingWatcher_OnFileChanged;
#endif
}
/// <summary>
/// Initializes a new instance of the <see cref="FileAppenderCache"/> class.
/// </summary>
/// <remarks>
/// The size of the list should be positive. No validations are performed during initialisation as it is an
/// intenal class.
/// </remarks>
/// <param name="size">Total number of appenders allowed in list.</param>
/// <param name="appenderFactory">Factory used to create each appender.</param>
/// <param name="createFileParams">Parameters used for creating a file.</param>
public FileAppenderCache(int size, IFileAppenderFactory appenderFactory, ICreateFileParameters createFileParams)
{
Size = size;
Factory = appenderFactory;
CreateFileParameters = createFileParams;
_appenders = new BaseFileAppender[Size];
_autoClosingTimer = new Timer(AutoClosingTimerCallback, null, Timeout.Infinite, Timeout.Infinite);
#if !SILVERLIGHT && !__IOS__ && !__ANDROID__ && !NETSTANDARD1_3
_externalFileArchivingWatcher.FileChanged += ExternalFileArchivingWatcher_OnFileChanged;
#endif
}
private void FileAppenderCache_GetFileCharacteristics(IFileAppenderFactory appenderFactory, ICreateFileParameters fileParameters)
{
// Invoke GetFileCharacteristics() on an Empty FileAppenderCache.
FileAppenderCache emptyCache = FileAppenderCache.Empty;
Assert.Null(emptyCache.GetFileCreationTimeSource("file.txt"));
Assert.Null(emptyCache.GetFileLastWriteTimeUtc("file.txt"));
Assert.Null(emptyCache.GetFileLength("file.txt"));
FileAppenderCache cache = new FileAppenderCache(3, appenderFactory, fileParameters);
// Invoke GetFileCharacteristics() on non-empty FileAppenderCache - Before allocating any appenders.
Assert.Null(emptyCache.GetFileCreationTimeSource("file.txt"));
Assert.Null(emptyCache.GetFileLastWriteTimeUtc("file.txt"));
Assert.Null(emptyCache.GetFileLength("file.txt"));
String tempFile = Path.Combine(
Path.GetTempPath(),
Path.Combine(Guid.NewGuid().ToString(), "file.txt")
);
// Allocate an appender.
BaseFileAppender appender = cache.AllocateAppender(tempFile);
appender.Write(StringToBytes("NLog test string."));
//
// Note: Encoding is ASSUMED to be Unicode. There is no explicit reference to which encoding will be used
// for the file.
//
// File information should be returned.
var fileCreationTimeUtc = cache.GetFileCreationTimeSource(tempFile);
Assert.NotNull(fileCreationTimeUtc);
Assert.True(fileCreationTimeUtc > Time.TimeSource.Current.FromSystemTime(DateTime.UtcNow.AddMinutes(-2)), "creationtime is wrong");
var fileLastWriteTimeUtc = cache.GetFileLastWriteTimeUtc(tempFile);
Assert.NotNull(fileLastWriteTimeUtc);
Assert.True(fileLastWriteTimeUtc > DateTime.UtcNow.AddMinutes(-2), "lastwrite is wrong");
Assert.Equal(34, cache.GetFileLength(tempFile));
// Clean up.
appender.Flush();
appender.Close();
}
public void FileAppenderCache_GetFileInfo()
{
DateTime lastWriteTime;
long fileLength;
// Invoke GetFileInfo() on an Empty FileAppenderCache.
FileAppenderCache emptyCache = FileAppenderCache.Empty;
emptyCache.GetFileInfo("file.txt", out lastWriteTime, out fileLength);
// Default values will be returned.
Assert.True(lastWriteTime == DateTime.MinValue);
Assert.True(fileLength == -1);
IFileAppenderFactory appenderFactory = SingleProcessFileAppender.TheFactory;
ICreateFileParameters fileTarget = new FileTarget();
FileAppenderCache cache = new FileAppenderCache(3, appenderFactory, fileTarget);
// Invoke GetFileInfo() on non-empty FileAppenderCache - Before allocating any appenders.
cache.GetFileInfo("file.txt", out lastWriteTime, out fileLength);
// Default values will be returned.
Assert.True(lastWriteTime == DateTime.MinValue);
Assert.True(fileLength == -1);
String tempFile = Path.Combine(
Path.GetTempPath(),
Path.Combine(Guid.NewGuid().ToString(), "file.txt")
);
// Allocate an appender.
BaseFileAppender appender = cache.AllocateAppender(tempFile);
appender.Write(StringToBytes("NLog test string."));
//
// Note: Encoding is ASSUMED to be Unicode. There is no explicit reference to which encoding will be used
// for the file.
//
// File information should be returned.
cache.GetFileInfo(tempFile, out lastWriteTime, out fileLength);
Assert.False(lastWriteTime == DateTime.MinValue);
Assert.True(fileLength == 34);
// Clean up.
appender.Flush();
appender.Close();
}
public void FileAppenderCache_GetFileCharacteristics()
{
// Invoke GetFileCharacteristics() on an Empty FileAppenderCache.
FileAppenderCache emptyCache = FileAppenderCache.Empty;
Assert.Null(emptyCache.GetFileCharacteristics("file.txt"));
IFileAppenderFactory appenderFactory = SingleProcessFileAppender.TheFactory;
ICreateFileParameters fileTarget = new FileTarget();
FileAppenderCache cache = new FileAppenderCache(3, appenderFactory, fileTarget);
// Invoke GetFileCharacteristics() on non-empty FileAppenderCache - Before allocating any appenders.
Assert.Null(cache.GetFileCharacteristics("file.txt"));
String tempFile = Path.Combine(
Path.GetTempPath(),
Path.Combine(Guid.NewGuid().ToString(), "file.txt")
);
// Allocate an appender.
BaseFileAppender appender = cache.AllocateAppender(tempFile);
appender.Write(StringToBytes("NLog test string."));
//
// Note: Encoding is ASSUMED to be Unicode. There is no explicit reference to which encoding will be used
// for the file.
//
// File information should be returned.
var fileCharacteristics = cache.GetFileCharacteristics(tempFile);
Assert.NotNull(fileCharacteristics);
Assert.NotEqual(DateTime.MinValue, fileCharacteristics.CreationTimeUtc);
Assert.Equal(34, fileCharacteristics.FileLength);
// Clean up.
appender.Flush();
appender.Close();
}
/// <summary>
/// Initializes file logging by creating data structures that
/// enable efficient multi-file logging.
/// </summary>
public override void Initialize()
{
base.Initialize ();
if (!KeepFileOpen)
{
_appenderFactory = RetryingMultiProcessFileAppender.TheFactory;
}
else
{
if (_archiveAboveSize != -1 || _archiveEvery != ArchiveEveryMode.None)
{
if (NetworkWrites)
{
_appenderFactory = RetryingMultiProcessFileAppender.TheFactory;
}
else if (ConcurrentWrites)
{
#if NETCF
_appenderFactory = RetryingMultiProcessFileAppender.TheFactory;
#elif MONO
//
// mono on Windows uses mutexes, on Unix - special appender
//
if (PlatformDetector.IsCurrentOSCompatibleWith(RuntimeOS.Unix))
_appenderFactory = UnixMultiProcessFileAppender.TheFactory;
else
_appenderFactory = MutexMultiProcessFileAppender.TheFactory;
#else
_appenderFactory = MutexMultiProcessFileAppender.TheFactory;
#endif
}
else
{
_appenderFactory = CountingSingleProcessFileAppender.TheFactory;
}
}
else
{
if (NetworkWrites)
{
_appenderFactory = RetryingMultiProcessFileAppender.TheFactory;
}
else if (ConcurrentWrites)
{
#if NETCF
_appenderFactory = RetryingMultiProcessFileAppender.TheFactory;
#elif MONO
//
// mono on Windows uses mutexes, on Unix - special appender
//
if (PlatformDetector.IsCurrentOSCompatibleWith(RuntimeOS.Unix))
_appenderFactory = UnixMultiProcessFileAppender.TheFactory;
else
_appenderFactory = MutexMultiProcessFileAppender.TheFactory;
#else
_appenderFactory = MutexMultiProcessFileAppender.TheFactory;
#endif
}
else
{
_appenderFactory = SingleProcessFileAppender.TheFactory;
}
}
}
_recentAppenders = new BaseFileAppender[OpenFileCacheSize];
if ((OpenFileCacheSize > 0 || EnableFileDelete) && OpenFileCacheTimeout > 0)
{
_autoClosingTimer = new Timer(new TimerCallback(this.AutoClosingTimerCallback), null, OpenFileCacheTimeout * 1000, OpenFileCacheTimeout * 1000);
}
// Console.Error.WriteLine("Name: {0} Factory: {1}", this.Name, _appenderFactory.GetType().FullName);
}
/// <summary>
/// Initializes file logging by creating data structures that
/// enable efficient multi-file logging.
/// </summary>
protected override void InitializeTarget()
{
base.InitializeTarget();
if (!KeepFileOpen)
{
appenderFactory = RetryingMultiProcessFileAppender.TheFactory;
}
else
{
if (ArchiveAboveSize != -1 || ArchiveEvery != FileArchivePeriod.None)
{
if (NetworkWrites)
{
appenderFactory = RetryingMultiProcessFileAppender.TheFactory;
}
else if (ConcurrentWrites)
{
#if NET_CF || SILVERLIGHT
this.appenderFactory = RetryingMultiProcessFileAppender.TheFactory;
#elif MONO
//
// mono on Windows uses mutexes, on Unix - special appender
//
if (PlatformDetector.IsUnix)
{
this.appenderFactory = UnixMultiProcessFileAppender.TheFactory;
}
else
{
this.appenderFactory = MutexMultiProcessFileAppender.TheFactory;
}
#else
appenderFactory = MutexMultiProcessFileAppender.TheFactory;
#endif
}
else
{
appenderFactory = CountingSingleProcessFileAppender.TheFactory;
}
}
else
{
if (NetworkWrites)
{
appenderFactory = RetryingMultiProcessFileAppender.TheFactory;
}
else if (ConcurrentWrites)
{
#if NET_CF || SILVERLIGHT
this.appenderFactory = RetryingMultiProcessFileAppender.TheFactory;
#elif MONO
//
// mono on Windows uses mutexes, on Unix - special appender
//
if (PlatformDetector.IsUnix)
{
this.appenderFactory = UnixMultiProcessFileAppender.TheFactory;
}
else
{
this.appenderFactory = MutexMultiProcessFileAppender.TheFactory;
}
#else
appenderFactory = MutexMultiProcessFileAppender.TheFactory;
#endif
}
else
{
appenderFactory = SingleProcessFileAppender.TheFactory;
}
}
}
recentAppenders = new BaseFileAppender[OpenFileCacheSize];
if ((OpenFileCacheSize > 0 || EnableFileDelete) && OpenFileCacheTimeout > 0)
{
autoClosingTimer = new Timer(
AutoClosingTimerCallback,
null,
OpenFileCacheTimeout*1000,
OpenFileCacheTimeout*1000);
}
// Console.Error.WriteLine("Name: {0} Factory: {1}", this.Name, this.appenderFactory.GetType().FullName);
}
/// <summary>
/// Initializes file logging by creating data structures that
/// enable efficient multi-file logging.
/// </summary>
protected override void InitializeTarget()
{
base.InitializeTarget();
this.appenderFactory = GetFileAppenderFactory();
this.fileAppenderCache = new FileAppenderCache(this.OpenFileCacheSize, this.appenderFactory, this);
RefreshArchiveFilePatternToWatch();
if ((this.OpenFileCacheSize > 0 || this.EnableFileDelete) && this.OpenFileCacheTimeout > 0)
{
this.autoClosingTimer = new Timer(
this.AutoClosingTimerCallback,
null,
this.OpenFileCacheTimeout * 1000,
this.OpenFileCacheTimeout * 1000);
}
}
/// <summary>
/// Initializes file logging by creating data structures that
/// enable efficient multi-file logging.
/// </summary>
protected override void InitializeTarget()
{
base.InitializeTarget();
if (!this.KeepFileOpen)
{
this.appenderFactory = RetryingMultiProcessFileAppender.TheFactory;
}
else
{
if (this.ArchiveAboveSize != -1 || this.ArchiveEvery != FileArchivePeriod.None)
{
if (this.NetworkWrites)
{
this.appenderFactory = RetryingMultiProcessFileAppender.TheFactory;
}
else if (this.ConcurrentWrites)
{
#if NET_CF || SILVERLIGHT
this.appenderFactory = RetryingMultiProcessFileAppender.TheFactory;
#elif MONO
//
// mono on Windows uses mutexes, on Unix - special appender
//
if (PlatformDetector.IsCurrentOSCompatibleWith(RuntimeOS.Unix))
{
this.appenderFactory = UnixMultiProcessFileAppender.TheFactory;
}
else
{
this.appenderFactory = MutexMultiProcessFileAppender.TheFactory;
}
#else
this.appenderFactory = MutexMultiProcessFileAppender.TheFactory;
#endif
}
else
{
this.appenderFactory = CountingSingleProcessFileAppender.TheFactory;
}
}
else
{
if (this.NetworkWrites)
{
this.appenderFactory = RetryingMultiProcessFileAppender.TheFactory;
}
else if (this.ConcurrentWrites)
{
#if NET_CF || SILVERLIGHT
this.appenderFactory = RetryingMultiProcessFileAppender.TheFactory;
#elif MONO
//
// mono on Windows uses mutexes, on Unix - special appender
//
if (PlatformDetector.IsCurrentOSCompatibleWith(RuntimeOS.Unix))
{
this.appenderFactory = UnixMultiProcessFileAppender.TheFactory;
}
else
{
this.appenderFactory = MutexMultiProcessFileAppender.TheFactory;
}
#else
this.appenderFactory = MutexMultiProcessFileAppender.TheFactory;
#endif
}
else
{
this.appenderFactory = SingleProcessFileAppender.TheFactory;
}
}
}
this.recentAppenders = new BaseFileAppender[this.OpenFileCacheSize];
if ((this.OpenFileCacheSize > 0 || this.EnableFileDelete) && this.OpenFileCacheTimeout > 0)
{
this.autoClosingTimer = new Timer(
this.AutoClosingTimerCallback,
null,
this.OpenFileCacheTimeout * 1000,
this.OpenFileCacheTimeout * 1000);
}
// Console.Error.WriteLine("Name: {0} Factory: {1}", this.Name, this.appenderFactory.GetType().FullName);
}
/// <summary>
/// Initializes file logging by creating data structures that
/// enable efficient multi-file logging.
/// </summary>
protected override void InitializeTarget()
{
base.InitializeTarget();
this.appenderFactory = GetFileAppenderFactory();
this.recentAppenders = new BaseFileAppender[this.OpenFileCacheSize];
if ((this.OpenFileCacheSize > 0 || this.EnableFileDelete) && this.OpenFileCacheTimeout > 0)
{
this.autoClosingTimer = new Timer(
this.AutoClosingTimerCallback,
null,
this.OpenFileCacheTimeout * 1000,
this.OpenFileCacheTimeout * 1000);
}
// Console.Error.WriteLine("Name: {0} Factory: {1}", this.Name, this.appenderFactory.GetType().FullName);
}
private void FileAppenderCache_GetFileCharacteristics(IFileAppenderFactory appenderFactory, ICreateFileParameters fileParameters)
{
// Invoke GetFileCharacteristics() on an Empty FileAppenderCache.
FileAppenderCache emptyCache = FileAppenderCache.Empty;
Assert.Null(emptyCache.GetFileCreationTimeUtc("file.txt", false));
Assert.Null(emptyCache.GetFileLastWriteTimeUtc("file.txt", false));
Assert.Null(emptyCache.GetFileLength("file.txt", false));
FileAppenderCache cache = new FileAppenderCache(3, appenderFactory, fileParameters);
// Invoke GetFileCharacteristics() on non-empty FileAppenderCache - Before allocating any appenders.
Assert.Null(emptyCache.GetFileCreationTimeUtc("file.txt", false));
Assert.Null(emptyCache.GetFileLastWriteTimeUtc("file.txt", false));
Assert.Null(emptyCache.GetFileLength("file.txt", false));
String tempFile = Path.Combine(
Path.GetTempPath(),
Path.Combine(Guid.NewGuid().ToString(), "file.txt")
);
// Allocate an appender.
BaseFileAppender appender = cache.AllocateAppender(tempFile);
appender.Write(StringToBytes("NLog test string."));
//
// Note: Encoding is ASSUMED to be Unicode. There is no explicit reference to which encoding will be used
// for the file.
//
// File information should be returned.
var fileCreationTimeUtc = cache.GetFileCreationTimeUtc(tempFile, false);
Assert.NotNull(fileCreationTimeUtc);
Assert.True(fileCreationTimeUtc > DateTime.UtcNow.AddMinutes(-2),"creationtime is wrong");
var fileLastWriteTimeUtc = cache.GetFileLastWriteTimeUtc(tempFile, false);
Assert.NotNull(fileLastWriteTimeUtc);
Assert.True(fileLastWriteTimeUtc > DateTime.UtcNow.AddMinutes(-2), "lastwrite is wrong");
Assert.Equal(34, cache.GetFileLength(tempFile, false));
// Clean up.
appender.Flush();
appender.Close();
}
public void FileAppenderCache_GetFileCharacteristics_Multi()
{
IFileAppenderFactory appenderFactory = MutexMultiProcessFileAppender.TheFactory;
ICreateFileParameters fileTarget = new FileTarget() { ArchiveNumbering = ArchiveNumberingMode.Date, ForceManaged = true };
FileAppenderCache_GetFileCharacteristics(appenderFactory, fileTarget);
}
public void FileAppenderCache_GetFileCharacteristics_Single()
{
IFileAppenderFactory appenderFactory = SingleProcessFileAppender.TheFactory;
ICreateFileParameters fileTarget = new FileTarget() { ArchiveNumbering = ArchiveNumberingMode.Date };
FileAppenderCache_GetFileCharacteristics(appenderFactory, fileTarget);
}
/// <summary>
/// Initializes file logging by creating data structures that
/// enable efficient multi-file logging.
/// </summary>
public override void Initialize()
{
base.Initialize();
if (!KeepFileOpen)
{
_appenderFactory = RetryingMultiProcessFileAppender.TheFactory;
}
else
{
if (_archiveAboveSize != -1 || _archiveEvery != ArchiveEveryMode.None)
{
if (NetworkWrites)
{
_appenderFactory = RetryingMultiProcessFileAppender.TheFactory;
}
else if (ConcurrentWrites)
{
#if NETCF
_appenderFactory = RetryingMultiProcessFileAppender.TheFactory;
#elif MONO
//
// mono on Windows uses mutexes, on Unix - special appender
//
if (PlatformDetector.IsCurrentOSCompatibleWith(RuntimeOS.Unix))
{
_appenderFactory = UnixMultiProcessFileAppender.TheFactory;
}
else
{
_appenderFactory = MutexMultiProcessFileAppender.TheFactory;
}
#else
_appenderFactory = MutexMultiProcessFileAppender.TheFactory;
#endif
}
else
{
_appenderFactory = CountingSingleProcessFileAppender.TheFactory;
}
}
else
{
if (NetworkWrites)
{
_appenderFactory = RetryingMultiProcessFileAppender.TheFactory;
}
else if (ConcurrentWrites)
{
#if NETCF
_appenderFactory = RetryingMultiProcessFileAppender.TheFactory;
#elif MONO
//
// mono on Windows uses mutexes, on Unix - special appender
//
if (PlatformDetector.IsCurrentOSCompatibleWith(RuntimeOS.Unix))
{
_appenderFactory = UnixMultiProcessFileAppender.TheFactory;
}
else
{
_appenderFactory = MutexMultiProcessFileAppender.TheFactory;
}
#else
_appenderFactory = MutexMultiProcessFileAppender.TheFactory;
#endif
}
else
{
_appenderFactory = SingleProcessFileAppender.TheFactory;
}
}
}
_recentAppenders = new BaseFileAppender[OpenFileCacheSize];
if ((OpenFileCacheSize > 0 || EnableFileDelete) && OpenFileCacheTimeout > 0)
{
_autoClosingTimer = new Timer(new TimerCallback(this.AutoClosingTimerCallback), null, OpenFileCacheTimeout * 1000, OpenFileCacheTimeout * 1000);
}
// Console.Error.WriteLine("Name: {0} Factory: {1}", this.Name, _appenderFactory.GetType().FullName);
}
