private static int[] FilterFileNames(IEnumerable <string> files, ActivityFilter filter)
{
return(files.Select((x, i) => new { Item = x, Index = i })
.Where(x => filter.DateRange.IsInRangeIncludingEndDate(ActivityLogFile.GetDate(x.Item)))
.Select(x => x.Index)
.ToArray());
}
private void RollOverIfDateBoundaryCrossing()
{
if (!_staticLogFileName || !_rollDate || !FileExists(_baseFileName))
{
return;
}
DateTime lastWriteTime;
using (SecurityContext.Impersonate(this))
{
lastWriteTime = System.IO.File.GetLastWriteTime(_baseFileName);
}
LogLog.Debug("RollingFileAppender: [" +
lastWriteTime.ToString(ActivityLogFile.FileDatePattern, DateTimeFormatInfo.InvariantInfo) + "] vs. [" +
_now.ToString(ActivityLogFile.FileDatePattern, DateTimeFormatInfo.InvariantInfo) + "]");
if (lastWriteTime.ToString(ActivityLogFile.FileDatePattern, DateTimeFormatInfo.InvariantInfo)
.Equals(_now.ToString(ActivityLogFile.FileDatePattern, DateTimeFormatInfo.InvariantInfo)))
{
return;
}
_scheduledFilename = ActivityLogFile.ComposeFileName(_baseFileName, lastWriteTime);
LogLog.Debug("RollingFileAppender: Initial roll over to [" + _scheduledFilename + "]");
RollOverTime(false);
LogLog.Debug("RollingFileAppender: curSizeRollBackups after rollOver at [" + _curSizeRollBackups + "]");
}
protected string GetNextOutputFileName(string fileName)
{
using (SecurityContext.Impersonate(this))
{
if (!_staticLogFileName)
{
fileName = fileName.Trim();
if (_rollDate)
{
fileName = ActivityLogFile.ComposeFileName(fileName, _now);
}
if (_countDirection >= 0)
{
fileName = ActivityLogFile.ComposeFileName(fileName, _dateTime.Now) + '.' + _curSizeRollBackups;
}
}
}
return(fileName);
}
protected void RollOverTime(bool fileIsOpen)
{
if (_staticLogFileName)
{
string str = _now.ToString(ActivityLogFile.FileDatePattern, DateTimeFormatInfo.InvariantInfo);
if (_scheduledFilename.Equals(File + str))
{
ErrorHandler.Error("Compare " + _scheduledFilename + " : " + File + str);
return;
}
if (fileIsOpen)
{
CloseFile();
}
for (int index = 1; index <= _curSizeRollBackups; ++index)
{
RollFile(File + '.' + index, _scheduledFilename + '.' + index);
}
RollFile(File, _scheduledFilename);
}
_curSizeRollBackups = 0;
using (SecurityContext.Impersonate(this))
{
_scheduledFilename = ActivityLogFile.ComposeFileName(File, _now);
}
if (!fileIsOpen)
{
return;
}
SafeOpenFile(_baseFileName, false);
}
public override void ActivateOptions()
{
if (IsTemplate)
{
return;
}
_now = _dateTime.Now;
_rollPoint = ComputeCheckPeriod(ActivityLogFile.FileDatePattern);
if (_rollPoint == RollPoint.InvalidRollPoint)
{
throw new ArgumentException("Invalid RollPoint, unable to parse [" + ActivityLogFile.FileDatePattern + "]");
}
_nextCheck = NextCheckDate(_now, _rollPoint);
if (SecurityContext == null)
{
SecurityContext = SecurityContextProvider.DefaultProvider.CreateSecurityContext(this);
}
using (SecurityContext.Impersonate(this))
{
File = ConvertToFullPath(File.Trim());
_baseFileName = File;
}
if (_rollDate && File != null && _scheduledFilename == null)
{
_scheduledFilename = ActivityLogFile.ComposeFileName(File, _now);
}
ExistingInit();
base.ActivateOptions();
Folder = ConvertToFullPath(Folder);
Closed = false;
}
protected virtual string[] GetFilesForLogger(Logger logger)
{
string logFileName = GetLogFilePathFromLogger(logger);
if (string.IsNullOrEmpty(logFileName))
{
return(Enumerable.Empty <string>().ToArray());
}
var directory = new DirectoryInfo(logFileName.GetDirectoryName());
if (!directory.Exists)
{
return(Enumerable.Empty <string>().ToArray());
}
return(new[] { logFileName }
.Concat(directory
.GetFiles(ActivityLogFile.GetWildcartPatternFor(logFileName))
.Select(x => x.FullName))
.OrderBy(ActivityLogFile.GetOrder)
.ToArray());
}
private IEnumerable <string> GetExistingFiles(string baseFilePath)
{
var list = new List <string>();
string path;
using (SecurityContext.Impersonate(this))
{
string fullPath = Path.GetFullPath(baseFilePath);
path = Path.GetDirectoryName(fullPath);
if (Directory.Exists(path))
{
string fileName = Path.GetFileName(fullPath);
string[] files = Directory.GetFiles(path, ActivityLogFile.GetWildcartPatternFor(fileName));
list.AddRange(files.Select(Path.GetFileName));
}
}
LogLog.Debug("RollingFileAppender: Searched for existing files in [" + path + "]");
return(list);
}
protected void RollOverRenameFiles(string baseFileName, DateTime timeStamp)
{
if (_maxSizeRollBackups == 0)
{
return;
}
FileInfo[] logFiles;
string directoryName;
string backupFileName;
using (SecurityContext.Impersonate(this))
{
directoryName = baseFileName.GetDirectoryName();
logFiles = new DirectoryInfo(directoryName)
.GetFiles(ActivityLogFile.GetWildcartPatternFor(baseFileName))
.OrderBy(x => ActivityLogFile.GetOrder(x.Name))
.ToArray();
backupFileName = ActivityLogFile.ComposeFileName(baseFileName, timeStamp);
}
if (_countDirection < 0)
{
if (_curSizeRollBackups == _maxSizeRollBackups)
{
DeleteFile(logFiles[_maxSizeRollBackups - 1].FullName);
--_curSizeRollBackups;
}
for (int index = _curSizeRollBackups; index > 0; --index)
{
FileInfo file = logFiles[index];
string newFileName;
using (SecurityContext.Impersonate(this))
{
newFileName = file.Name.GetFileNameWithoutExtension() + '.' + (index + 1);
}
RollFile(file.FullName, directoryName.Combine(newFileName));
}
++_curSizeRollBackups;
RollFile(baseFileName, directoryName.Combine(backupFileName + ".1"));
}
else
{
if (_curSizeRollBackups >= _maxSizeRollBackups && _maxSizeRollBackups > 0)
{
int num = _curSizeRollBackups - _maxSizeRollBackups;
if (_staticLogFileName)
{
++num;
}
DeleteFile(logFiles[num].FullName);
}
if (_staticLogFileName)
{
++_curSizeRollBackups;
RollFile(baseFileName, backupFileName + '.' + _curSizeRollBackups);
}
}
}
private void InitializeFromOneFile(string baseFile, string curFileName)
{
using (SecurityContext.Impersonate(this))
{
if (!curFileName.StartsWith(baseFile.GetFileNameWithoutExtension()) || curFileName.Equals(baseFile))
{
return;
}
}
int num1 = curFileName.LastIndexOf(".");
if (0 > num1)
{
return;
}
if (_staticLogFileName)
{
int num2 = curFileName.Length - num1;
string datePart;
using (SecurityContext.Impersonate(this))
{
datePart = ActivityLogFile.GetDatePart(curFileName);
}
if (baseFile.Length + num2 != curFileName.Length - datePart.Length - 1)
{
return;
}
}
if (_rollDate && !_staticLogFileName)
{
if (
!curFileName.StartsWith(baseFile +
_dateTime.Now.ToString(ActivityLogFile.FileDatePattern, DateTimeFormatInfo.InvariantInfo)))
{
LogLog.Debug("RollingFileAppender: Ignoring file [" + curFileName + "] because it is from a different date period");
return;
}
}
try
{
int val;
if (SystemInfo.TryParse(curFileName.Substring(num1 + 1), out val) && val > _curSizeRollBackups)
{
if (0 != _maxSizeRollBackups)
{
if (-1 == _maxSizeRollBackups)
{
_curSizeRollBackups = val;
}
else if (_countDirection >= 0)
{
_curSizeRollBackups = val;
}
else if (val <= _maxSizeRollBackups)
{
_curSizeRollBackups = val;
}
}
LogLog.Debug("RollingFileAppender: File name [" + curFileName + "] moves current count to [" + _curSizeRollBackups +
"]");
}
}
catch (FormatException)
{
LogLog.Debug("RollingFileAppender: Encountered a backup file not ending in .x [" + curFileName + "]");
}
}
