/// <summary> /// Initializes a new instance of the <see cref="BaseFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="createParameters">The create parameters.</param> public BaseFileAppender(string fileName, ICreateFileParameters createParameters) { this.CreateFileParameters = createParameters; this.FileName = fileName; this.OpenTime = DateTime.UtcNow; // to be consistent with timeToKill in FileTarget.AutoClosingTimerCallback this.LastWriteTime = DateTime.MinValue; }
public UnixMultiProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters) { int fd = Syscall.open(fileName, OpenFlags.O_CREAT | OpenFlags.O_WRONLY | OpenFlags.O_APPEND, (FilePermissions)(6 | (6 << 3) | (6 << 6))); if (fd == -1) { if (Stdlib.GetLastError() == Errno.ENOENT && parameters.CreateDirs) { string dirName = Path.GetDirectoryName(fileName); if (!Directory.Exists(dirName) && parameters.CreateDirs) { Directory.CreateDirectory(dirName); } fd = Syscall.open(fileName, OpenFlags.O_CREAT | OpenFlags.O_WRONLY | OpenFlags.O_APPEND, (FilePermissions)(6 | (6 << 3) | (6 << 6))); } } if (fd == -1) { UnixMarshal.ThrowExceptionForLastError(); } try { this.file = new UnixStream(fd, true); } catch { Syscall.close(fd); throw; } }
/// <summary> /// Initializes a new instance of the <see cref="MutexMultiProcessFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="parameters">The parameters.</param> public MutexMultiProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters) { try { _mutex = CreateSharableMutex("FileLock"); _fileStream = CreateFileStream(true); _fileCharacteristicsHelper = FileCharacteristicsHelper.CreateHelper(parameters.ForceManaged); } catch { if (_mutex != null) { _mutex.Close(); _mutex = null; } if (_fileStream != null) { _fileStream.Close(); _fileStream = null; } throw; } }
public UnixMultiProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters) { int fd = Syscall.open(fileName, OpenFlags.O_CREAT | OpenFlags.O_WRONLY | OpenFlags.O_APPEND, (FilePermissions)(6 | (6 << 3) | (6 << 6))); if (fd == -1) { if (Stdlib.GetLastError() == Errno.ENOENT && parameters.CreateDirs) { string dirName = Path.GetDirectoryName(fileName); if (!Directory.Exists(dirName) && parameters.CreateDirs) Directory.CreateDirectory(dirName); fd = Syscall.open(fileName, OpenFlags.O_CREAT | OpenFlags.O_WRONLY | OpenFlags.O_APPEND, (FilePermissions)(6 | (6 << 3) | (6 << 6))); } } if (fd == -1) UnixMarshal.ThrowExceptionForLastError(); try { this.file = new UnixStream(fd, true); } catch { Syscall.close(fd); throw; } }
/// <summary> /// Initializes a new instance of the <see cref="BaseMutexFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="createParameters">The create parameters.</param> public BaseMutexFileAppender(string fileName, ICreateFileParameters createParameters) : base(fileName, createParameters) { #if SupportsMutex ArchiveMutex = CreateArchiveMutex(); #endif }
/// <summary> /// Initializes a new instance of the <see cref="BaseFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="createParameters">The create parameters.</param> public BaseFileAppender(string fileName, ICreateFileParameters createParameters) { CreateFileParameters = createParameters; FileName = fileName; OpenTime = CurrentTimeGetter.Now; LastWriteTime = DateTime.MinValue; }
/// <summary> /// Initializes a new instance of the <see cref="MutexMultiProcessFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="parameters">The parameters.</param> public MutexMultiProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters) { try { mutex = new Mutex(false, GetMutexName(fileName)); file = CreateFileStream(true); } catch { if (mutex != null) { mutex.Close(); mutex = null; } if (file != null) { file.Close(); file = null; } throw; } }
/// <summary> /// Initializes a new instance of the <see cref="BaseFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="createParameters">The create parameters.</param> public BaseFileAppender(string fileName, ICreateFileParameters createParameters) { this.CreateFileParameters = createParameters; this.FileName = fileName; this.OpenTime = TimeSource.Current.Time.ToLocalTime(); this.LastWriteTime = DateTime.MinValue; }
/// <summary> /// Initializes a new instance of the <see cref="BaseFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="createParameters">The create parameters.</param> public BaseFileAppender(string fileName, ICreateFileParameters createParameters) { this.CreateFileParameters = createParameters; this.FileName = fileName; this.OpenTime = CurrentTimeGetter.Now; this.LastWriteTime = DateTime.MinValue; }
/// <summary> /// Initializes a new instance of the <see cref="SingleProcessFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="parameters">The parameters.</param> public SingleProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters) { var fileInfo = new FileInfo(fileName); _lastWriteTimeUtc = fileInfo.Exists ? fileInfo.GetLastWriteTimeUtc() : DateTime.UtcNow; _file = CreateFileStream(false); }
/// <summary> /// Initializes a new instance of the <see cref="MutexMultiProcessFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="parameters">The parameters.</param> public MutexMultiProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters) { try { this.mutex = CreateSharableMutex("FileLock"); this.fileStream = CreateFileStream(true); this.fileCharacteristicsHelper = FileCharacteristicsHelper.CreateHelper(parameters.ForceManaged); } catch { if (this.mutex != null) { this.mutex.Close(); this.mutex = null; } if (this.fileStream != null) { this.fileStream.Close(); this.fileStream = null; } throw; } }
/// <summary> /// Initializes a new instance of the <see cref="BaseFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="createParameters">The create parameters.</param> protected BaseFileAppender(string fileName, ICreateFileParameters createParameters) { CreateFileParameters = createParameters; FileName = fileName; OpenTimeUtc = DateTime.UtcNow; // to be consistent with timeToKill in FileTarget.AutoClosingTimerCallback LastWriteTimeUtc = DateTime.MinValue; CaptureLastWriteTime = createParameters.CaptureLastWriteTime; }
/// <summary> /// Initializes a new instance of the <see cref="CountingSingleProcessFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="parameters">The parameters.</param> public CountingSingleProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters) { var fileInfo = new FileInfo(fileName); _currentFileLength = fileInfo.Exists ? fileInfo.Length : 0; _file = CreateFileStream(false); }
/// <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]; }
/// <summary> /// Initializes a new instance of the <see cref="BaseMutexFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="createParameters">The create parameters.</param> protected BaseMutexFileAppender(string fileName, ICreateFileParameters createParameters) : base(fileName, createParameters) { if (createParameters.IsArchivingEnabled) { #if SupportsMutex ArchiveMutex = CreateArchiveMutex(); #endif } }
/// <summary> /// Initializes a new instance of the <see cref="CountingSingleProcessFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="parameters">The parameters.</param> public CountingSingleProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters) { var fileInfo = new FileInfo(fileName); _currentFileLength = fileInfo.Exists ? fileInfo.Length : 0; _file = CreateFileStream(false); _enableFileDeleteSimpleMonitor = parameters.EnableFileDeleteSimpleMonitor; _lastSimpleMonitorCheckTimeUtc = OpenTimeUtc; }
public UnixMultiProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters) { int fd = Syscall.open(fileName, OpenFlags.O_CREAT | OpenFlags.O_WRONLY | OpenFlags.O_APPEND, (FilePermissions)(6 | (6 << 3) | (6 << 6))); if (fd == -1) { if (Stdlib.GetLastError() == Errno.ENOENT && parameters.CreateDirs) { string dirName = Path.GetDirectoryName(fileName); if (!Directory.Exists(dirName) && parameters.CreateDirs) { Directory.CreateDirectory(dirName); } fd = Syscall.open(fileName, OpenFlags.O_CREAT | OpenFlags.O_WRONLY | OpenFlags.O_APPEND, (FilePermissions)(6 | (6 << 3) | (6 << 6))); } } if (fd == -1) { UnixMarshal.ThrowExceptionForLastError(); } try { bool fileExists = File.Exists(fileName); this.file = new UnixStream(fd, true); long filePosition = this.file.Position; if (fileExists || filePosition > 0) { this.CreationTimeUtc = File.GetCreationTimeUtc(this.FileName); if (this.CreationTimeUtc < DateTime.UtcNow - TimeSpan.FromSeconds(2) && filePosition == 0) { // File wasn't created "almost now". Thread.Sleep(50); // Having waited for a short amount of time usually means the file creation process has continued // code execution just enough to the above point where it has fixed up the creation time. this.CreationTimeUtc = File.GetCreationTimeUtc(this.FileName); } } else { // We actually created the file and eventually concurrent processes this.CreationTimeUtc = DateTime.UtcNow; File.SetCreationTimeUtc(this.FileName, this.CreationTimeUtc); } } catch { Syscall.close(fd); throw; } }
/// <summary> /// Initializes a new instance of the <see cref="BaseFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="createParameters">The create parameters.</param> public BaseFileAppender(string fileName, ICreateFileParameters createParameters) { this.CreateFileParameters = createParameters; this.FileName = fileName; this.OpenTime = DateTime.UtcNow; // to be consistent with timeToKill in FileTarget.AutoClosingTimerCallback this.LastWriteTime = DateTime.MinValue; this.CaptureLastWriteTime = createParameters.CaptureLastWriteTime; #if !SILVERLIGHT this.ArchiveMutex = CreateArchiveMutex(); #endif }
/// <summary> /// Initializes a new instance of the <see cref="BaseFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="createParameters">The create parameters.</param> public BaseFileAppender(string fileName, ICreateFileParameters createParameters) { this.CreateFileParameters = createParameters; this.FileName = fileName; this.OpenTime = DateTime.UtcNow; // to be consistent with timeToKill in FileTarget.AutoClosingTimerCallback this.LastWriteTime = DateTime.MinValue; this.CaptureLastWriteTime = createParameters.CaptureLastWriteTime; #if SupportsMutex this.ArchiveMutex = CreateArchiveMutex(); #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.OnChange += ExternalFileArchivingWatcher_OnChange; #endif }
/// <summary> /// Initializes a new instance of the <see cref="SingleProcessFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="parameters">The parameters.</param> public SingleProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters) { var fi = new FileInfo(fileName); if (fi.Exists) { this.FileTouched(fi.LastWriteTime); } else { this.FileTouched(); } this.file = CreateFileStream(false); }
/// <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 }
/// <summary> /// Initializes a new instance of the <see cref="BaseMutexFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="createParameters">The create parameters.</param> public BaseMutexFileAppender(string fileName, ICreateFileParameters createParameters) : base(fileName, createParameters) { #if SupportsMutex try { ArchiveMutex = CreateArchiveMutex(); } catch (SecurityException ex) { InternalLogger.Warn(ex, "Failed to create archive mutex"); } #endif }
/// <summary> /// Initializes a new instance of the <see cref="WindowsMultiProcessFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="parameters">The parameters.</param> public WindowsMultiProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters) { try { CreateAppendOnlyFile(fileName); fileCharacteristicsHelper = FileCharacteristicsHelper.CreateHelper(parameters.ForceManaged); } catch { if (fileStream != null) fileStream.Dispose(); fileStream = null; throw; } }
/// <summary> /// Initializes a new instance of the <see cref="CountingSingleProcessFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="parameters">The parameters.</param> public CountingSingleProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters) { var fi = new FileInfo(fileName); if (fi.Exists) { this.currentFileLength = fi.Length; } else { this.currentFileLength = 0; } this.file = this.CreateFileStream(false); }
/// <summary> /// Initializes a new instance of the <see cref="WindowsMultiProcessFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="parameters">The parameters.</param> public WindowsMultiProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters) { try { CreateAppendOnlyFile(fileName); } catch { if (_fileStream != null) { _fileStream.Dispose(); } _fileStream = null; throw; } }
/// <summary> /// Initializes a new instance of the <see cref="SingleProcessFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="parameters">The parameters.</param> public SingleProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters) { if (CaptureLastWriteTime) { var fileInfo = new FileInfo(fileName); if (fileInfo.Exists) { FileTouched(fileInfo.GetLastWriteTimeUtc()); } else { FileTouched(); } } this.file = CreateFileStream(false); }
public CountingSingleProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters) { FileInfo fi = new FileInfo(fileName); if (fi.Exists) { FileTouched(fi.LastWriteTime); _fileLength = fi.Length; } else { FileTouched(); _fileLength = 0; } _file = CreateFileStream(false); }
/// <summary> /// Initializes a new instance of the <see cref="SingleProcessFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="parameters">The parameters.</param> public SingleProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters) { var fileInfo = new FileInfo(fileName); if (fileInfo.Exists) { #if !SILVERLIGHT FileTouched(fileInfo.LastWriteTimeUtc); #else FileTouched(fileInfo.LastWriteTime); #endif } else { FileTouched(); } this.file = CreateFileStream(false); }
/// <summary> /// Initializes a new instance of the <see cref="WindowsMultiProcessFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="parameters">The parameters.</param> public WindowsMultiProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters) { try { CreateAppendOnlyFile(fileName); _fileCharacteristicsHelper = FileCharacteristicsHelper.CreateHelper(parameters.ForceManaged); } catch { if (_fileStream != null) { _fileStream.Dispose(); } _fileStream = null; throw; } }
/// <summary> /// Initializes a new instance of the <see cref="CountingSingleProcessFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="parameters">The parameters.</param> public CountingSingleProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters) { var fi = new FileInfo(fileName); if (fi.Exists) { this.FileTouched(fi.LastWriteTime); this.currentFileLength = fi.Length; } else { this.FileTouched(); this.currentFileLength = 0; } this.file = this.CreateFileStream(false); }
/// <summary> /// Initializes a new instance of the <see cref="BaseMutexFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="createParameters">The create parameters.</param> protected BaseMutexFileAppender(string fileName, ICreateFileParameters createParameters) : base(fileName, createParameters) { if (createParameters.IsArchivingEnabled) { if (PlatformDetector.SupportsSharableMutex) { #if SupportsMutex ArchiveMutex = CreateArchiveMutex(); #endif } else { InternalLogger.Debug("Mutex for file archive not supported"); } } }
/// <summary> /// Initializes a new instance of the <see cref="BaseMutexFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="createParameters">The create parameters.</param> protected BaseMutexFileAppender(string fileName, ICreateFileParameters createParameters) : base(fileName, createParameters) { if (createParameters.IsArchivingEnabled && createParameters.ConcurrentWrites) { if (MutexDetector.SupportsSharableMutex) { #if SupportsMutex ArchiveMutex = CreateArchiveMutex(); #endif } else { InternalLogger.Debug("{0}: Mutex for file archive not supported", CreateFileParameters); } } }
/// <summary> /// Initializes a new instance of the <see cref="CountingSingleProcessFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="parameters">The parameters.</param> public CountingSingleProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters) { var fileInfo = new FileInfo(fileName); if (fileInfo.Exists) { #if !SILVERLIGHT FileTouched(fileInfo.LastWriteTimeUtc); #else FileTouched(fileInfo.LastWriteTime); #endif this.currentFileLength = fileInfo.Length; } else { FileTouched(); this.currentFileLength = 0; } this.file = this.CreateFileStream(false); }
/// <summary> /// Initializes a new instance of the <see cref="CountingSingleProcessFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="parameters">The parameters.</param> public CountingSingleProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters) { var fileInfo = new FileInfo(fileName); if (fileInfo.Exists) { if (CaptureLastWriteTime) { FileTouched(fileInfo.GetLastWriteTimeUtc()); } _currentFileLength = fileInfo.Length; } else { FileTouched(); _currentFileLength = 0; } _file = CreateFileStream(false); }
public MutexMultiProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters) { try { _mutex = new Mutex(false, GetMutexName(fileName)); _file = CreateFileStream(true); } catch { if (_mutex != null) { _mutex.Close(); _mutex = null; } if (_file != null) { _file.Close(); _file = null; } throw; } }
/// <summary> /// Initializes a new instance of the <see cref="MutexMultiProcessFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="parameters">The parameters.</param> public MutexMultiProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters) { try { this.mutex = CreateSharableMutex(GetMutexName(fileName)); this.file = CreateFileStream(true); } catch { if (this.mutex != null) { this.mutex.Close(); this.mutex = null; } if (this.file != null) { this.file.Close(); this.file = null; } throw; } }
public BaseFileAppender Open(string fileName, ICreateFileParameters parameters) { return new UnixMultiProcessFileAppender(fileName, parameters); }
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(); }
/// <summary> /// Opens the appender for given file name and parameters. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="parameters">Creation parameters.</param> /// <returns> /// Instance of <see cref="BaseFileAppender" /> which can be used to write to the file. /// </returns> BaseFileAppender IFileAppenderFactory.Open(string fileName, ICreateFileParameters parameters) { return new CountingSingleProcessFileAppender(fileName, parameters); }
/// <summary> /// Initializes a new instance of the <see cref="SingleProcessFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="parameters">The parameters.</param> public SingleProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters) { this.file = CreateFileStream(false); }
/// <summary> /// Initializes a new instance of the <see cref="RetryingMultiProcessFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="parameters">The parameters.</param> public RetryingMultiProcessFileAppender(string fileName, ICreateFileParameters parameters) : base(fileName, parameters) { }
/// <summary> /// Opens the appender for given file name and parameters. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="parameters">Creation parameters.</param> /// <returns> /// Instance of <see cref="BaseFileAppender"/> which can be used to write to the file. /// </returns> BaseFileAppender IFileAppenderFactory.Open(string fileName, ICreateFileParameters parameters) { return new RetryingMultiProcessFileAppender(fileName, parameters); }
public BaseFileAppender(string fileName, ICreateFileParameters createParameters) { _fileName = fileName; _createParameters = createParameters; _openTime = CurrentTimeGetter.Now; _lastWriteTime = DateTime.MinValue; }