Quite a large patch, but looks sensible.
>-----Original Message-----
>From: Dominik Psenner [mailto:dpsen...@gmail.com]
>Sent: Tuesday, January 22, 2013 2:41 PM
>To: log4net-dev@logging.apache.org
>Subject: [PATCH 1 of 5] Step 1: refactoring
>
>Trivial changes to tabs and spaces, formatting etc.
>
>diff -r b430bc3cc0f4 -r dc18d71a5304 src/Appender/RollingFileAppender.cs
>--- a/src/Appender/RollingFileAppender.cs Tue Jan 22 14:27:20 2013
+0100
>+++ b/src/Appender/RollingFileAppender.cs Tue Jan 22 14:31:05 2013
+0100
>@@ -1,10 +1,10 @@
> #region Apache License
> //
>-// Licensed to the Apache Software Foundation (ASF) under one or more
>+// Licensed to the Apache Software Foundation (ASF) under one or more
> // contributor license agreements. See the NOTICE file distributed with
>-// this work for additional information regarding copyright ownership.
>+// this work for additional information regarding copyright ownership.
> // The ASF licenses this file to you under the Apache License, Version 2.0
>-// (the "License"); you may not use this file except in compliance with
>+// (the "License"); you may not use this file except in compliance with
> // the License. You may obtain a copy of the License at
> //
> // http://www.apache.org/licenses/LICENSE-2.0
>@@ -31,12 +31,12 @@
> // The following sounds good, and I though it was the case, but
after
> // further testing on Windows I have not been able to confirm it.
>
>- /// On the Windows platform if another process has a write lock on
>the file
>+ /// On the Windows platform if another process has a write lock on
>the file
> /// that is to be deleted, but allows shared read access to the file
>then the
>- /// file can be moved, but cannot be deleted. If the other process
>also allows
>- /// shared delete access to the file then the file will be deleted
>once that
>+ /// file can be moved, but cannot be deleted. If the other process
>also allows
>+ /// shared delete access to the file then the file will be deleted
>once that
> /// process closes the file. If it is necessary to open the log file
>or any
>- /// of the backup files outside of this appender for either read or
>+ /// of the backup files outside of this appender for either read or
> /// write access please ensure that read and delete share modes are
>enabled.
> #endif
>
>@@ -68,34 +68,34 @@
> /// <item>Infinite number of backups by file size <see
>cref="MaxSizeRollBackups"/></item>
> /// </list>
> /// </para>
>- ///
>+ ///
> /// <note>
> /// <para>
>- /// For large or infinite numbers of backup files a <see
>cref="CountDirection"/>
>+ /// For large or infinite numbers of backup files a <see
>cref="CountDirection"/>
> /// greater than zero is highly recommended, otherwise all the
backup
>files need
> /// to be renamed each time a new backup is created.
> /// </para>
> /// <para>
>- /// When Date/Time based rolling is used setting <see
>cref="StaticLogFileName"/>
>+ /// When Date/Time based rolling is used setting <see
>cref="StaticLogFileName"/>
> /// to <see langword="true"/> will reduce the number of file
>renamings to few or none.
> /// </para>
> /// </note>
>- ///
>+ ///
> /// <note type="caution">
> /// <para>
> /// Changing <see cref="StaticLogFileName"/> or <see
>cref="CountDirection"/> without clearing
>- /// the log file directory of backup files will cause unexpected and
>unwanted side effects.
>+ /// the log file directory of backup files will cause unexpected and
>unwanted side effects.
> /// </para>
> /// </note>
>- ///
>+ ///
> /// <para>
> /// If Date/Time based rolling is enabled this appender will attempt
>to roll existing files
> /// in the directory without a Date/Time tag based on the last write
>date of the base log file.
>- /// The appender only rolls the log file when a message is logged.
If
>Date/Time based rolling
>+ /// The appender only rolls the log file when a message is logged.
If
>Date/Time based rolling
> /// is enabled then the appender will not roll the log file at the
>Date/Time boundary but
> /// at the point when the next message is logged after the boundary
>has been crossed.
> /// </para>
>- ///
>+ ///
> /// <para>
> /// The <see cref="RollingFileAppender"/> extends the <see
>cref="FileAppender"/> and
> /// has the same behavior when opening the log file.
>@@ -110,7 +110,7 @@
> /// When rolling a backup file necessitates deleting an older backup
>file the
> /// file to be deleted is moved to a temporary name before being
>deleted.
> /// </para>
>- ///
>+ ///
> /// <note type="caution">
> /// <para>
> /// A maximum number of backup files when rolling on date/time
>boundaries is not supported.
>@@ -123,10 +123,10 @@
> /// <author>Douglas de la Torre</author>
> /// <author>Edward Smit</author>
> public class RollingFileAppender : FileAppender
>- {
>- #region Public Enums
>+ {
>+ #region Public Enums
>
>- /// <summary>
>+ /// <summary>
> /// Style of rolling to use
> /// </summary>
> /// <remarks>
>@@ -231,7 +231,7 @@
> /// Default constructor.
> /// </para>
> /// </remarks>
>- public RollingFileAppender()
>+ public RollingFileAppender()
> {
> }
>
>@@ -240,9 +240,9 @@
> #region Public Instance Properties
>
> #if !NET_1_0 && !CLI_1_0 && !NETCF
>- /// <summary>
>+ /// <summary>
> /// Gets or sets the strategy for determining the current
date
>and time. The default
>- /// implementation is to use LocalDateTime which internally
>calls through to DateTime.Now.
>+ /// implementation is to use LocalDateTime which internally
>calls through to DateTime.Now.
> /// DateTime.UtcNow may be used on frameworks newer than
.NET
>1.0 by specifying
> /// <see cref="RollingFileAppender.UniversalDateTime"/>.
> /// </summary>
>@@ -253,19 +253,19 @@
> /// <para>
> /// Gets or sets the <see
>cref="RollingFileAppender.IDateTime"/> used to return the current date and
>time.
> /// </para>
>- /// <para>
>- /// There are two built strategies for determining the current
>date and time,
>+ /// <para>
>+ /// There are two built strategies for determining the
current
>date and time,
> /// <see cref="RollingFileAppender.LocalDateTime"/>
>- /// and <see cref="RollingFileAppender.UniversalDateTime"/>.
>- /// </para>
>- /// <para>
>+ /// and <see cref="RollingFileAppender.UniversalDateTime"/>.
>+ /// </para>
>+ /// <para>
> /// The default strategy is <see
>cref="RollingFileAppender.LocalDateTime"/>.
> /// </para>
> /// </remarks>
> #else
>- /// <summary>
>+ /// <summary>
> /// Gets or sets the strategy for determining the current
date
>and time. The default
>- /// implementation is to use LocalDateTime which internally
>calls through to DateTime.Now.
>+ /// implementation is to use LocalDateTime which internally
>calls through to DateTime.Now.
> /// </summary>
> /// <value>
> /// An implementation of the <see
>cref="RollingFileAppender.IDateTime"/> interface which returns the current
>date and time.
>@@ -274,12 +274,12 @@
> /// <para>
> /// Gets or sets the <see
>cref="RollingFileAppender.IDateTime"/> used to return the current date and
>time.
> /// </para>
>- /// <para>
>+ /// <para>
> /// The default strategy is <see
>cref="RollingFileAppender.LocalDateTime"/>.
> /// </para>
> /// </remarks>
> #endif
>- public IDateTime DateTimeStrategy
>+ public IDateTime DateTimeStrategy
> {
> get { return m_dateTime; }
> set { m_dateTime = value; }
>@@ -290,12 +290,12 @@
> /// when rolling over on date.
> /// </summary>
> /// <value>
>- /// The date pattern to be used for generating file names
when
>rolling
>+ /// The date pattern to be used for generating file names
when
>rolling
> /// over on date.
> /// </value>
> /// <remarks>
> /// <para>
>- /// Takes a string in the same format as expected by
>+ /// Takes a string in the same format as expected by
> /// <see cref="log4net.DateFormatter.SimpleDateFormatter"
/>.
> /// </para>
> /// <para>
>@@ -308,7 +308,7 @@
> get { return m_datePattern; }
> set { m_datePattern = value; }
> }
>-
>+
> /// <summary>
> /// Gets or sets the maximum number of backup files that are
>kept before
> /// the oldest is erased.
>@@ -319,16 +319,16 @@
> /// </value>
> /// <remarks>
> /// <para>
>- /// If set to zero, then there will be no backup files and
the
>log file
>- /// will be truncated when it reaches <see
>cref="MaxFileSize"/>.
>+ /// If set to zero, then there will be no backup files and
the
>log file
>+ /// will be truncated when it reaches <see
>cref="MaxFileSize"/>.
> /// </para>
> /// <para>
>- /// If a negative number is supplied then no deletions will
be
>made. Note
>- /// that this could result in very slow performance as a
large
>number of
>+ /// If a negative number is supplied then no deletions will
be
>made. Note
>+ /// that this could result in very slow performance as a
large
>number of
> /// files are rolled over unless <see
cref="CountDirection"/>
>is used.
> /// </para>
> /// <para>
>- /// The maximum applies to <b>each</b> time based group of
>files and
>+ /// The maximum applies to <b>each</b> time based group of
>files and
> /// <b>not</b> the total.
> /// </para>
> /// </remarks>
>@@ -337,20 +337,20 @@
> get { return m_maxSizeRollBackups; }
> set { m_maxSizeRollBackups = value; }
> }
>-
>+
> /// <summary>
> /// Gets or sets the maximum size that the output file is
>allowed to reach
> /// before being rolled over to backup files.
> /// </summary>
> /// <value>
>- /// The maximum size in bytes that the output file is
allowed
>to reach before being
>+ /// The maximum size in bytes that the output file is
allowed
>to reach before being
> /// rolled over to backup files.
> /// </value>
> /// <remarks>
> /// <para>
> /// This property is equivalent to <see
>cref="MaximumFileSize"/> except
> /// that it is required for differentiating the setter
taking a
>- /// <see cref="long"/> argument from the setter taking a
<see
>cref="string"/>
>+ /// <see cref="long"/> argument from the setter taking a
<see
>cref="string"/>
> /// argument.
> /// </para>
> /// <para>
>@@ -362,20 +362,20 @@
> get { return m_maxFileSize; }
> set { m_maxFileSize = value; }
> }
>-
>+
> /// <summary>
> /// Gets or sets the maximum size that the output file is
>allowed to reach
> /// before being rolled over to backup files.
> /// </summary>
> /// <value>
>- /// The maximum size that the output file is allowed to
reach
>before being
>+ /// The maximum size that the output file is allowed to
reach
>before being
> /// rolled over to backup files.
> /// </value>
> /// <remarks>
> /// <para>
> /// This property allows you to specify the maximum size
with
>the
>- /// suffixes "KB", "MB" or "GB" so that the size is
interpreted
>being
>- /// expressed respectively in kilobytes, megabytes or
>gigabytes.
>+ /// suffixes "KB", "MB" or "GB" so that the size is
interpreted
>being
>+ /// expressed respectively in kilobytes, megabytes or
>gigabytes.
> /// </para>
> /// <para>
> /// For example, the value "10KB" will be interpreted as
10240
>bytes.
>@@ -396,7 +396,7 @@
> }
>
> /// <summary>
>- /// Gets or sets the rolling file count direction.
>+ /// Gets or sets the rolling file count direction.
> /// </summary>
> /// <value>
> /// The rolling file count direction.
>@@ -413,7 +413,7 @@
> /// <para>
> /// <see cref="CountDirection" /> >= 0 does the opposite
>i.e.
> /// log.1 is the first backup made, log.5 is the 5th backup
>made, etc.
>- /// For infinite backups use <see cref="CountDirection" />
>>= 0 to reduce
>+ /// For infinite backups use <see cref="CountDirection" />
>>= 0 to reduce
> /// rollover costs.
> /// </para>
> /// <para>The default file count direction is -1.</para>
>@@ -423,7 +423,7 @@
> get { return m_countDirection; }
> set { m_countDirection = value; }
> }
>-
>+
> /// <summary>
> /// Gets or sets the rolling style.
> /// </summary>
>@@ -445,7 +445,7 @@
> set
> {
> m_rollingStyle = value;
>- switch (m_rollingStyle)
>+ switch (m_rollingStyle)
> {
> case RollingMode.Once:
> m_rollDate = false;
>@@ -467,30 +467,30 @@
> case RollingMode.Composite:
> m_rollDate = true;
> m_rollSize = true;
>- break;
>+ break;
> }
> }
> }
>
>- /// <summary>
>- /// Gets or sets a value indicating whether to preserve the file
>name extension when rolling.
>- /// </summary>
>- /// <value>
>- /// <c>true</c> if the file name extension should be preserved.
>- /// </value>
>- /// <remarks>
>- /// <para>
>- /// By default file.log is rolled to file.log.yyyy-MM-dd or
>file.log.curSizeRollBackup.
>- /// However, under Windows the new file name will loose any
>program associations as the
>- /// extension is changed. Optionally file.log can be renamed to
>file.yyyy-MM-dd.log or
>- /// file.curSizeRollBackup.log to maintain any program
>associations.
>- /// </para>
>- /// </remarks>
>- public bool PreserveLogFileNameExtension
>- {
>- get { return m_preserveLogFileNameExtension; }
>- set { m_preserveLogFileNameExtension = value; }
>- }
>+ /// <summary>
>+ /// Gets or sets a value indicating whether to preserve the
>file name extension when rolling.
>+ /// </summary>
>+ /// <value>
>+ /// <c>true</c> if the file name extension should be
preserved.
>+ /// </value>
>+ /// <remarks>
>+ /// <para>
>+ /// By default file.log is rolled to file.log.yyyy-MM-dd or
>file.log.curSizeRollBackup.
>+ /// However, under Windows the new file name will loose any
>program associations as the
>+ /// extension is changed. Optionally file.log can be renamed
to
>file.yyyy-MM-dd.log or
>+ /// file.curSizeRollBackup.log to maintain any program
>associations.
>+ /// </para>
>+ /// </remarks>
>+ public bool PreserveLogFileNameExtension
>+ {
>+ get { return m_preserveLogFileNameExtension; }
>+ set { m_preserveLogFileNameExtension = value; }
>+ }
>
> /// <summary>
> /// Gets or sets a value indicating whether to always log to
>@@ -507,7 +507,7 @@
> /// file.log.yyyy-mm-dd.curSizeRollBackup).
> /// </para>
> /// <para>
>- /// This will make time based rollovers with a large number
of
>backups
>+ /// This will make time based rollovers with a large number
of
>backups
> /// much faster as the appender it won't have to rename all
the
>backups!
> /// </para>
> /// </remarks>
>@@ -519,21 +519,21 @@
>
> #endregion Public Instance Properties
>
>- #region Private Static Fields
>+ #region Private Static Fields
>
>- /// <summary>
>- /// The fully qualified type of the RollingFileAppender class.
>- /// </summary>
>- /// <remarks>
>- /// Used by the internal logger to record the Type of the
>- /// log message.
>- /// </remarks>
>- private readonly static Type declaringType =
>typeof(RollingFileAppender);
>+ /// <summary>
>+ /// The fully qualified type of the RollingFileAppender
class.
>+ /// </summary>
>+ /// <remarks>
>+ /// Used by the internal logger to record the Type of the
>+ /// log message.
>+ /// </remarks>
>+ private readonly static Type declaringType =
>typeof(RollingFileAppender);
>
>- #endregion Private Static Fields
>+ #endregion Private Static Fields
>
>- #region Override implementation of FileAppender
>-
>+ #region Override implementation of FileAppender
>+
> /// <summary>
> /// Sets the quiet writer being used.
> /// </summary>
>@@ -541,7 +541,7 @@
> /// This method can be overridden by sub classes.
> /// </remarks>
> /// <param name="writer">the writer to set</param>
>- override protected void SetQWForFiles(TextWriter writer)
>+ override protected void SetQWForFiles(TextWriter writer)
> {
> QuietWriter = new CountingQuietTextWriter(writer,
>ErrorHandler);
> }
>@@ -557,12 +557,12 @@
> /// is need and then appends to the file last.
> /// </para>
> /// </remarks>
>- override protected void Append(LoggingEvent loggingEvent)
>+ override protected void Append(LoggingEvent loggingEvent)
> {
> AdjustFileBeforeAppend();
> base.Append(loggingEvent);
> }
>-
>+
> /// <summary>
> /// Write out an array of logging events.
> /// </summary>
>@@ -574,7 +574,7 @@
> /// is need and then appends to the file last.
> /// </para>
> /// </remarks>
>- override protected void Append(LoggingEvent[] loggingEvents)
>+ override protected void Append(LoggingEvent[] loggingEvents)
> {
> AdjustFileBeforeAppend();
> base.Append(loggingEvents);
>@@ -592,21 +592,21 @@
> /// </remarks>
> virtual protected void AdjustFileBeforeAppend()
> {
>- if (m_rollDate)
>+ if (m_rollDate)
> {
> DateTime n = m_dateTime.Now;
>- if (n >= m_nextCheck)
>+ if (n >= m_nextCheck)
> {
> m_now = n;
> m_nextCheck = NextCheckDate(m_now,
>m_rollPoint);
>-
>+
> RollOverTime(true);
> }
> }
>-
>- if (m_rollSize)
>+
>+ if (m_rollSize)
> {
>- if ((File != null) &&
>((CountingQuietTextWriter)QuietWriter).Count >= m_maxFileSize)
>+ if ((File != null) &&
>((CountingQuietTextWriter)QuietWriter).Count >= m_maxFileSize)
> {
> RollOverSize();
> }
>@@ -631,7 +631,7 @@
>
> // Calculate the current size of the file
> long currentCount = 0;
>- if (append)
>+ if (append)
> {
>
using(SecurityContext.Impersonate(this))
> {
>@@ -656,7 +656,7 @@
> }
> }
>
>- if (!m_staticLogFileName)
>+ if (!m_staticLogFileName)
> {
> m_scheduledFilename = fileName;
> }
>@@ -676,25 +676,25 @@
> /// <returns>the output file name</returns>
> /// <remarks>
> /// The output file name is based on the base fileName
>specified.
>- /// If <see cref="StaticLogFileName"/> is set then the
output
>+ /// If <see cref="StaticLogFileName"/> is set then the
output
> /// file name is the same as the base file passed in.
Otherwise
> /// the output file depends on the date pattern, on the
count
> /// direction or both.
> /// </remarks>
> protected string GetNextOutputFileName(string fileName)
> {
>- if (!m_staticLogFileName)
>+ if (!m_staticLogFileName)
> {
> fileName = fileName.Trim();
>
> if (m_rollDate)
> {
>- fileName = CombinePath(fileName,
>m_now.ToString(m_datePattern,
>System.Globalization.DateTimeFormatInfo.InvariantInfo));
>+ fileName = CombinePath(fileName,
>m_now.ToString(m_datePattern,
>System.Globalization.DateTimeFormatInfo.InvariantInfo));
> }
>
>- if (m_countDirection >= 0)
>+ if (m_countDirection >= 0)
> {
>- fileName = CombinePath(fileName, "." +
>m_curSizeRollBackups);
>+ fileName = CombinePath(fileName, "."
+
>m_curSizeRollBackups);
> }
> }
>
>@@ -711,7 +711,7 @@
> private void DetermineCurSizeRollBackups()
> {
> m_curSizeRollBackups = 0;
>-
>+
> string fullPath = null;
> string fileName = null;
>
>@@ -735,14 +735,14 @@
> /// <returns></returns>
> private string GetWildcardPatternForFile(string
baseFileName)
> {
>- if (m_preserveLogFileNameExtension)
>- {
>- return Path.GetFileNameWithoutExtension(baseFileName) +
>".*" + Path.GetExtension(baseFileName);
>- }
>- else
>- {
>- return baseFileName + '*';
>- }
>+ if (m_preserveLogFileNameExtension)
>+ {
>+ return
>Path.GetFileNameWithoutExtension(baseFileName) + ".*" +
>Path.GetExtension(baseFileName);
>+ }
>+ else
>+ {
>+ return baseFileName + '*';
>+ }
> }
>
> /// <summary>
>@@ -767,10 +767,10 @@
> string baseFileName =
>Path.GetFileName(fullPath);
>
> string[] files =
>Directory.GetFiles(directory, GetWildcardPatternForFile(baseFileName));
>-
>+
> if (files != null)
> {
>- for (int i = 0; i <
files.Length; i++)
>+ for (int i = 0; i <
files.Length; i++)
> {
> string curFileName =
>Path.GetFileName(files[i]);
> if
>(curFileName.StartsWith(Path.GetFileNameWithoutExtension(baseFileName)))
>@@ -790,14 +790,15 @@
> /// </summary>
> private void RollOverIfDateBoundaryCrossing()
> {
>- if (m_staticLogFileName && m_rollDate)
>+ if (m_staticLogFileName && m_rollDate)
> {
>- if (FileExists(m_baseFileName))
>+ if (FileExists(m_baseFileName))
> {
> DateTime last;
>-
using(SecurityContext.Impersonate(this)) {
>+
using(SecurityContext.Impersonate(this))
>+ {
> #if !NET_1_0 && !CLI_1_0 && !NETCF
>- if (DateTimeStrategy is UniversalDateTime)
>+ if (DateTimeStrategy is
>UniversalDateTime)
> {
> last =
>System.IO.File.GetLastWriteTimeUtc(m_baseFileName);
> }
>@@ -806,12 +807,12 @@
> #endif
> last =
>System.IO.File.GetLastWriteTime(m_baseFileName);
> #if !NET_1_0 && !CLI_1_0 && !NETCF
>- }
>+ }
> #endif
>- }
>+ }
> LogLog.Debug(declaringType,
>"["+last.ToString(m_datePattern,System.Globalization.DateTimeFormatInfo.Inv
>ariantInfo)+"] vs.
>["+m_now.ToString(m_datePattern,System.Globalization.DateTimeFormatInfo.Inv
>ariantInfo)+"]");
>
>- if
>(!(last.ToString(m_datePattern,System.Globalization.DateTimeFormatInfo.Inva
>riantInfo).Equals(m_now.ToString(m_datePattern,
>System.Globalization.DateTimeFormatInfo.InvariantInfo))))
>+ if
>(!(last.ToString(m_datePattern,System.Globalization.DateTimeFormatInfo.Inva
>riantInfo).Equals(m_now.ToString(m_datePattern,
>System.Globalization.DateTimeFormatInfo.InvariantInfo))))
> {
> m_scheduledFilename =
m_baseFileName +
>last.ToString(m_datePattern,
>System.Globalization.DateTimeFormatInfo.InvariantInfo);
> LogLog.Debug(declaringType,
"Initial
>roll over to ["+m_scheduledFilename+"]");
>@@ -835,7 +836,7 @@
> /// </list>
> /// </para>
> /// </remarks>
>- protected void ExistingInit()
>+ protected void ExistingInit()
> {
> DetermineCurSizeRollBackups();
> RollOverIfDateBoundaryCrossing();
>@@ -878,29 +879,29 @@
> /// <param name="curFileName"></param>
> private void InitializeFromOneFile(string baseFile, string
>curFileName)
> {
>- if
>(curFileName.StartsWith(Path.GetFileNameWithoutExtension(baseFile)) ==
>false)
>+ if (!
>curFileName.StartsWith(Path.GetFileNameWithoutExtension(baseFile)))
> {
> // This is not a log file, so ignore
> return;
> }
>- if (curFileName.Equals(baseFile))
>+ if (curFileName.Equals(baseFile))
> {
> // Base log file is not an incremented
logfile (.1
>or .2, etc)
> return;
> }
>-
>- /*
>- if (m_staticLogFileName)
>+
>+ /*
>+ if (m_staticLogFileName)
> {
> int endLength = curFileName.Length - index;
>- if (baseFile.Length + endLength !=
>curFileName.Length)
>+ if (baseFile.Length + endLength !=
>curFileName.Length)
> {
> // file is probably
scheduledFilename + .x so
>I don't care
> return;
> }
> }
>- */
>-
>+ */
>+
> // Only look for files in the current roll point
> if (m_rollDate && !m_staticLogFileName)
> {
>@@ -910,48 +911,48 @@
> return;
> }
> }
>-
>- try
>+
>+ try
> {
> // Bump the counter up to the highest count
seen so
>far
>- int backup = GetBackUpIndex(curFileName);
>-
>- // caution: we might get a false positive when certain
>- // date patterns such as yyyyMMdd are used...those are
>- // valid number but aren't the kind of back up index
>- // we're looking for
>- if (backup > m_curSizeRollBackups)
>- {
>- if (0 == m_maxSizeRollBackups)
>- {
>- // Stay at zero when zero backups are desired
>- }
>- else if (-1 == m_maxSizeRollBackups)
>- {
>- // Infinite backups, so go as high as the highest
>value
>- m_curSizeRollBackups = backup;
>- }
>- else
>- {
>- // Backups limited to a finite number
>- if (m_countDirection >= 0)
>- {
>- // Go with the highest file when counting up
>- m_curSizeRollBackups = backup;
>- }
>- else
>- {
>- // Clip to the limit when counting down
>- if (backup <= m_maxSizeRollBackups)
>- {
>- m_curSizeRollBackups = backup;
>- }
>- }
>- }
>- LogLog.Debug(declaringType, "File name [" +
>curFileName + "] moves current count to [" + m_curSizeRollBackups + "]");
>- }
>- }
>- catch(FormatException)
>+ int backup = GetBackUpIndex(curFileName);
>+
>+ // caution: we might get a false positive
when
>certain
>+ // date patterns such as yyyyMMdd are
used...those
>are
>+ // valid number but aren't the kind of back
up
>index
>+ // we're looking for
>+ if (backup > m_curSizeRollBackups)
>+ {
>+ if (0 == m_maxSizeRollBackups)
>+ {
>+ // Stay at zero when zero
backups are
>desired
>+ }
>+ else if (-1 == m_maxSizeRollBackups)
>+ {
>+ // Infinite backups, so go
as high as
>the highest value
>+ m_curSizeRollBackups =
backup;
>+ }
>+ else
>+ {
>+ // Backups limited to a
finite number
>+ if (m_countDirection >= 0)
>+ {
>+ // Go with the
highest file when
>counting up
>+ m_curSizeRollBackups
= backup;
>+ }
>+ else
>+ {
>+ // Clip to the limit
when
>counting down
>+ if (backup <=
>m_maxSizeRollBackups)
>+ {
>+
m_curSizeRollBackups =
>backup;
>+ }
>+ }
>+ }
>+ LogLog.Debug(declaringType, "File
name [" +
>curFileName + "] moves current count to [" + m_curSizeRollBackups + "]");
>+ }
>+ }
>+ catch(FormatException)
> {
> //this happens when file.log ->
file.log.yyyy-MM-dd
>which is normal
> //when staticLogFileName == false
>@@ -959,38 +960,38 @@
> }
> }
>
>- /// <summary>
>- /// Attempts to extract a number from the end of the file name
>that indicates
>- /// the number of the times the file has been rolled over.
>- /// </summary>
>- /// <remarks>
>- /// Certain date pattern extensions like yyyyMMdd will be parsed
>as valid backup indexes.
>- /// </remarks>
>- /// <param name="curFileName"></param>
>- /// <returns></returns>
>- private int GetBackUpIndex(string curFileName)
>- {
>- int backUpIndex = -1;
>- string fileName = curFileName;
>+ /// <summary>
>+ /// Attempts to extract a number from the end of the file
name
>that indicates
>+ /// the number of the times the file has been rolled over.
>+ /// </summary>
>+ /// <remarks>
>+ /// Certain date pattern extensions like yyyyMMdd will be
>parsed as valid backup indexes.
>+ /// </remarks>
>+ /// <param name="curFileName"></param>
>+ /// <returns></returns>
>+ private int GetBackUpIndex(string curFileName)
>+ {
>+ int backUpIndex = -1;
>+ string fileName = curFileName;
>
>- if (m_preserveLogFileNameExtension)
>- {
>- fileName = Path.GetFileNameWithoutExtension(fileName);
>- }
>-
>- int index = fileName.LastIndexOf(".");
>- if (index > 0)
>- {
>- // if the "yyyy-MM-dd" component of file.log.yyyy-MM-dd is
>passed to TryParse
>- // it will gracefully fail and return backUpIndex will be
>0
>- SystemInfo.TryParse(fileName.Substring(index + 1), out
>backUpIndex);
>- }
>+ if (m_preserveLogFileNameExtension)
>+ {
>+ fileName =
>Path.GetFileNameWithoutExtension(fileName);
>+ }
>
>- return backUpIndex;
>- }
>+ int index = fileName.LastIndexOf(".");
>+ if (index > 0)
>+ {
>+ // if the "yyyy-MM-dd" component of
file.log.yyyy-
>MM-dd is passed to TryParse
>+ // it will gracefully fail and return
backUpIndex
>will be 0
>+ SystemInfo.TryParse(fileName.Substring(index
+ 1),
>out backUpIndex);
>+ }
>
>- /// <summary>
>- /// Takes a list of files and a base file name, and looks
for
>+ return backUpIndex;
>+ }
>+
>+ /// <summary>
>+ /// Takes a list of files and a base file name, and looks
for
> /// 'incremented' versions of the base file. Bumps the max
> /// count up to the highest count seen.
> /// </summary>
>@@ -1018,13 +1019,13 @@
> /// Essentially the date pattern is examined to determine
what
>the
> /// most suitable roll point is. The roll point chosen is
the
>roll point
> /// with the smallest period that can be detected using the
>date pattern
>- /// supplied. i.e. if the date pattern only outputs the
year,
>month, day
>+ /// supplied. i.e. if the date pattern only outputs the
year,
>month, day
> /// and hour then the smallest roll point that can be
detected
>would be
> /// and hourly roll point as minutes could not be detected.
> /// </remarks>
>- private RollPoint ComputeCheckPeriod(string datePattern)
>+ private RollPoint ComputeCheckPeriod(string datePattern)
> {
>- // s_date1970 is 1970-01-01 00:00:00 this is
>UniversalSortableDateTimePattern
>+ // s_date1970 is 1970-01-01 00:00:00 this is
>UniversalSortableDateTimePattern
> // (based on ISO 8601) using universal time. This
date is
>used for reference
> // purposes to calculate the resolution of the date
>pattern.
>
>@@ -1032,7 +1033,7 @@
> string r0 = s_date1970.ToString(datePattern,
>System.Globalization.DateTimeFormatInfo.InvariantInfo);
>
> // Check each type of rolling mode starting with the
>smallest increment.
>- for(int i = (int)RollPoint.TopOfMinute; i <=
>(int)RollPoint.TopOfMonth; i++)
>+ for(int i = (int)RollPoint.TopOfMinute; i <=
>(int)RollPoint.TopOfMonth; i++)
> {
> // Get string representation of next pattern
> string r1 = NextCheckDate(s_date1970,
>(RollPoint)i).ToString(datePattern,
>System.Globalization.DateTimeFormatInfo.InvariantInfo);
>@@ -1040,7 +1041,7 @@
> LogLog.Debug(declaringType, "Type = ["+i+"],
r0 =
>["+r0+"], r1 = ["+r1+"]");
>
> // Check if the string representations are
>different
>- if (r0 != null && r1 != null &&
!r0.Equals(r1))
>+ if (r0 != null && r1 != null &&
!r0.Equals(r1))
> {
> // Found highest precision roll
point
> return (RollPoint)i;
>@@ -1056,13 +1057,13 @@
> /// <remarks>
> /// <para>
> /// This is part of the <see cref="IOptionHandler"/> delayed
>object
>- /// activation scheme. The <see cref="ActivateOptions"/>
method
>must
>+ /// activation scheme. The <see cref="ActivateOptions"/>
method
>must
> /// be called on this object after the configuration
properties
>have
> /// been set. Until <see cref="ActivateOptions"/> is called
>this
>- /// object is in an undefined state and must not be used.
>+ /// object is in an undefined state and must not be used.
> /// </para>
> /// <para>
>- /// If any of the configuration properties are modified then
>+ /// If any of the configuration properties are modified then
> /// <see cref="ActivateOptions"/> must be called again.
> /// </para>
> /// <para>
>@@ -1071,14 +1072,14 @@
> /// the current number of backups.
> /// </para>
> /// </remarks>
>- override public void ActivateOptions()
>+ override public void ActivateOptions()
> {
> if (m_dateTime == null)
> {
> m_dateTime = new LocalDateTime();
> }
>
>- if (m_rollDate && m_datePattern != null)
>+ if (m_rollDate && m_datePattern != null)
> {
> m_now = m_dateTime.Now;
> m_rollPoint =
ComputeCheckPeriod(m_datePattern);
>@@ -1090,8 +1091,8 @@
>
> // next line added as this removes the name
check
>in rollOver
> m_nextCheck = NextCheckDate(m_now,
m_rollPoint);
>- }
>- else
>+ }
>+ else
> {
> if (m_rollDate)
> {
>@@ -1117,36 +1118,36 @@
>
> if (m_rollDate && File != null &&
m_scheduledFilename ==
>null)
> {
>- m_scheduledFilename = CombinePath(File,
>m_now.ToString(m_datePattern,
>System.Globalization.DateTimeFormatInfo.InvariantInfo));
>+ m_scheduledFilename = CombinePath(File,
>m_now.ToString(m_datePattern,
>System.Globalization.DateTimeFormatInfo.InvariantInfo));
> }
>
> ExistingInit();
>-
>+
> base.ActivateOptions();
> }
>
> #endregion
>-
>+
> #region Roll File
>
>- /// <summary>
>- ///
>- /// </summary>
>- /// <param name="path1"></param>
>- /// <param name="path2">.1, .2, .3, etc.</param>
>- /// <returns></returns>
>- private string CombinePath(string path1, string path2)
>- {
>- string extension = Path.GetExtension(path1);
>- if (m_preserveLogFileNameExtension && extension.Length > 0)
>- {
>- return Path.Combine(Path.GetDirectoryName(path1),
>Path.GetFileNameWithoutExtension(path1) + path2 + extension);
>- }
>- else
>- {
>- return path1 + path2;
>- }
>- }
>+ /// <summary>
>+ ///
>+ /// </summary>
>+ /// <param name="path1"></param>
>+ /// <param name="path2">.1, .2, .3, etc.</param>
>+ /// <returns></returns>
>+ private string CombinePath(string path1, string path2)
>+ {
>+ string extension = Path.GetExtension(path1);
>+ if (m_preserveLogFileNameExtension &&
extension.Length >
>0)
>+ {
>+ return
Path.Combine(Path.GetDirectoryName(path1),
>Path.GetFileNameWithoutExtension(path1) + path2 + extension);
>+ }
>+ else
>+ {
>+ return path1 + path2;
>+ }
>+ }
>
> /// <summary>
> /// Rollover the file(s) to date/time tagged file(s).
>@@ -1155,53 +1156,53 @@
> /// <remarks>
> /// <para>
> /// Rollover the file(s) to date/time tagged file(s).
>- /// Resets curSizeRollBackups.
>+ /// Resets curSizeRollBackups.
> /// If fileIsOpen is set then the new file is opened
(through
>SafeOpenFile).
> /// </para>
> /// </remarks>
>- protected void RollOverTime(bool fileIsOpen)
>+ protected void RollOverTime(bool fileIsOpen)
> {
>- if (m_staticLogFileName)
>+ if (m_staticLogFileName)
> {
> // Compute filename, but only if datePattern
is
>specified
>- if (m_datePattern == null)
>+ if (m_datePattern == null)
> {
> ErrorHandler.Error("Missing
DatePattern
>option in rollOver().");
> return;
> }
>-
>+
> //is the new file name equivalent to the
'current'
>one
> //something has gone wrong if we hit this --
we
>should only
> //roll over if the new file will be
different from
>the old
> string dateFormat =
m_now.ToString(m_datePattern,
>System.Globalization.DateTimeFormatInfo.InvariantInfo);
>- if (m_scheduledFilename.Equals(CombinePath(File,
>dateFormat)))
>+ if
(m_scheduledFilename.Equals(CombinePath(File,
>dateFormat)))
> {
>- ErrorHandler.Error("Compare " + m_scheduledFilename +
>" : " + CombinePath(File, dateFormat));
>+ ErrorHandler.Error("Compare " +
>m_scheduledFilename + " : " + CombinePath(File, dateFormat));
> return;
> }
>-
>+
> if (fileIsOpen)
> {
> // close current file, and rename it
to
>datedFilename
> this.CloseFile();
> }
>-
>+
> //we may have to roll over a large number of
>backups here
>- for (int i = 1; i <= m_curSizeRollBackups;
i++)
>+ for (int i = 1; i <= m_curSizeRollBackups;
i++)
> {
>- string from = CombinePath(File, "." + i);
>- string to = CombinePath(m_scheduledFilename, "." + i);
>+ string from = CombinePath(File, "."
+ i);
>+ string to =
CombinePath(m_scheduledFilename,
>"." + i);
> RollFile(from, to);
> }
>-
>+
> RollFile(File, m_scheduledFilename);
> }
>-
>+
> //We've cleared out the old date and are ready for
the
>new
>- m_curSizeRollBackups = 0;
>-
>+ m_curSizeRollBackups = 0;
>+
> //new scheduled name
>- m_scheduledFilename = CombinePath(File,
>m_now.ToString(m_datePattern,
>System.Globalization.DateTimeFormatInfo.InvariantInfo));
>+ m_scheduledFilename = CombinePath(File,
>m_now.ToString(m_datePattern,
>System.Globalization.DateTimeFormatInfo.InvariantInfo));
>
> if (fileIsOpen)
> {
>@@ -1209,7 +1210,7 @@
> SafeOpenFile(m_baseFileName, false);
> }
> }
>-
>+
> /// <summary>
> /// Renames file <paramref name="fromFile"/> to file
<paramref
>name="toFile"/>.
> /// </summary>
>@@ -1221,7 +1222,7 @@
> /// also checks for existence of target file and deletes if
it
>does.
> /// </para>
> /// </remarks>
>- protected void RollFile(string fromFile, string toFile)
>+ protected void RollFile(string fromFile, string toFile)
> {
> if (FileExists(fromFile))
> {
>@@ -1265,7 +1266,7 @@
> return System.IO.File.Exists(path);
> }
> }
>-
>+
> /// <summary>
> /// Deletes the specified file if it exists.
> /// </summary>
>@@ -1278,9 +1279,9 @@
> /// be deleted, but it still can be moved.
> /// </para>
> /// </remarks>
>- protected void DeleteFile(string fileName)
>+ protected void DeleteFile(string fileName)
> {
>- if (FileExists(fileName))
>+ if (FileExists(fileName))
> {
> // We may not have permission to delete the
file,
>or the file may be locked
>
>@@ -1327,7 +1328,7 @@
> }
> }
> }
>-
>+
> /// <summary>
> /// Implements file roll base on file size.
> /// </summary>
>@@ -1354,18 +1355,18 @@
> /// renamed if needed and no files are deleted.
> /// </para>
> /// </remarks>
>- protected void RollOverSize()
>+ protected void RollOverSize()
> {
> this.CloseFile(); // keep windows happy.
>-
>+
> LogLog.Debug(declaringType, "rolling over count
>["+((CountingQuietTextWriter)QuietWriter).Count+"]");
> LogLog.Debug(declaringType, "maxSizeRollBackups
>["+m_maxSizeRollBackups+"]");
> LogLog.Debug(declaringType, "curSizeRollBackups
>["+m_curSizeRollBackups+"]");
> LogLog.Debug(declaringType, "countDirection
>["+m_countDirection+"]");
>
> RollOverRenameFiles(File);
>-
>- if (!m_staticLogFileName && m_countDirection >= 0)
>+
>+ if (!m_staticLogFileName && m_countDirection >= 0)
> {
> m_curSizeRollBackups++;
> }
>@@ -1386,7 +1387,7 @@
> /// If <c>countDirection</c> < 0, then files
> /// {<c>File.1</c>, ..., <c>File.curSizeRollBackups -1</c>}
> /// are renamed to {<c>File.2</c>, ...,
>- /// <c>File.curSizeRollBackups</c>}.
>+ /// <c>File.curSizeRollBackups</c>}.
> /// </para>
> /// <para>
> /// If <c>maxSizeRollBackups</c> is equal to zero, then the
>@@ -1400,35 +1401,35 @@
> /// This is called by <see cref="RollOverSize"/> to rename
the
>files.
> /// </para>
> /// </remarks>
>- protected void RollOverRenameFiles(string baseFileName)
>+ protected void RollOverRenameFiles(string baseFileName)
> {
> // If maxBackups <= 0, then there is no file
renaming to
>be done.
>- if (m_maxSizeRollBackups != 0)
>+ if (m_maxSizeRollBackups != 0)
> {
>- if (m_countDirection < 0)
>+ if (m_countDirection < 0)
> {
> // Delete the oldest file, to keep
Windows
>happy.
>- if (m_curSizeRollBackups ==
>m_maxSizeRollBackups)
>+ if (m_curSizeRollBackups ==
>m_maxSizeRollBackups)
> {
>- DeleteFile(CombinePath(baseFileName, "." +
>m_maxSizeRollBackups));
>+
DeleteFile(CombinePath(baseFileName,
>"." + m_maxSizeRollBackups));
> m_curSizeRollBackups--;
> }
>-
>+
> // Map {(maxBackupIndex - 1), ...,
2, 1} to
>{maxBackupIndex, ..., 3, 2}
>- for (int i = m_curSizeRollBackups; i
>= 1; i-
>-)
>+ for (int i = m_curSizeRollBackups; i
>= 1; i-
>-)
> {
>- RollFile((CombinePath(baseFileName, "." + i)),
>(CombinePath(baseFileName, "." + (i + 1))));
>+
RollFile((CombinePath(baseFileName, "."
>+ i)), (CombinePath(baseFileName, "." + (i + 1))));
> }
>-
>+
> m_curSizeRollBackups++;
>
> // Rename fileName to fileName.1
>- RollFile(baseFileName, CombinePath(baseFileName,
>".1"));
>- }
>- else
>+ RollFile(baseFileName,
>CombinePath(baseFileName, ".1"));
>+ }
>+ else
> {
> //countDirection >= 0
>- if (m_curSizeRollBackups >=
>m_maxSizeRollBackups && m_maxSizeRollBackups > 0)
>+ if (m_curSizeRollBackups >=
>m_maxSizeRollBackups && m_maxSizeRollBackups > 0)
> {
> //delete the first and keep
counting
>up.
> int oldestFileIndex =
>m_curSizeRollBackups - m_maxSizeRollBackups;
>@@ -1446,20 +1447,20 @@
> if (!m_staticLogFileName)
> {
> int lastDotIndex =
>archiveFileBaseName.LastIndexOf(".");
>- if (lastDotIndex >=
0)
>+ if (lastDotIndex >=
0)
> {
>
archiveFileBaseName =
>archiveFileBaseName.Substring(0, lastDotIndex);
> }
> }
>
> // Delete the archive file
>- DeleteFile(CombinePath(archiveFileBaseName, "." +
>oldestFileIndex));
>+
> DeleteFile(CombinePath(archiveFileBaseName, "." + oldestFileIndex));
> }
>-
>- if (m_staticLogFileName)
>+
>+ if (m_staticLogFileName)
> {
> m_curSizeRollBackups++;
>- RollFile(baseFileName, CombinePath(baseFileName,
>"." + m_curSizeRollBackups));
>+ RollFile(baseFileName,
>CombinePath(baseFileName, "." + m_curSizeRollBackups));
> }
> }
> }
>@@ -1486,13 +1487,13 @@
> /// worth of time and get the start time of the next window
for
>the rollpoint.
> /// </para>
> /// </remarks>
>- protected DateTime NextCheckDate(DateTime currentDateTime,
>RollPoint rollPoint)
>+ protected DateTime NextCheckDate(DateTime currentDateTime,
>RollPoint rollPoint)
> {
> // Local variable to work on (this does not look
very
>efficient)
> DateTime current = currentDateTime;
>
> // Do slightly different things depending on what
the
>type of roll point we want.
>- switch(rollPoint)
>+ switch(rollPoint)
> {
> case RollPoint.TopOfMinute:
> current = current.AddMilliseconds(-
>current.Millisecond);
>@@ -1512,11 +1513,11 @@
> current = current.AddSeconds(-
>current.Second);
> current = current.AddMinutes(-
>current.Minute);
>
>- if (current.Hour < 12)
>+ if (current.Hour < 12)
> {
> current =
current.AddHours(12 -
>current.Hour);
>- }
>- else
>+ }
>+ else
> {
> current = current.AddHours(-
>current.Hour);
> current =
current.AddDays(1);
>@@ -1547,7 +1548,7 @@
> current = current.AddDays(1 -
current.Day);
>/* first day of month is 1 not 0 */
> current = current.AddMonths(1);
> break;
>- }
>+ }
> return current;
> }
>
>@@ -1563,38 +1564,38 @@
> private IDateTime m_dateTime = null;
>
> /// <summary>
>- /// The date pattern. By default, the pattern is set to
><c>".yyyy-MM-dd"</c>
>+ /// The date pattern. By default, the pattern is set to
><c>".yyyy-MM-dd"</c>
> /// meaning daily rollover.
> /// </summary>
> private string m_datePattern = ".yyyy-MM-dd";
>-
>+
> /// <summary>
> /// The actual formatted filename that is currently being
>written to
> /// or will be the file transferred to on roll over
> /// (based on staticLogFileName).
> /// </summary>
> private string m_scheduledFilename = null;
>-
>+
> /// <summary>
> /// The timestamp when we shall next recompute the filename.
> /// </summary>
> private DateTime m_nextCheck = DateTime.MaxValue;
>-
>+
> /// <summary>
> /// Holds date of last roll over
> /// </summary>
> private DateTime m_now;
>-
>+
> /// <summary>
> /// The type of rolling done
> /// </summary>
> private RollPoint m_rollPoint;
>-
>+
> /// <summary>
> /// The default maximum file size is 10MB
> /// </summary>
> private long m_maxFileSize = 10*1024*1024;
>-
>+
> /// <summary>
> /// There is zero backup files by default
> /// </summary>
>@@ -1604,12 +1605,12 @@
> /// How many sized based backups have been made so far
> /// </summary>
> private int m_curSizeRollBackups = 0;
>-
>+
> /// <summary>
>- /// The rolling file count direction.
>+ /// The rolling file count direction.
> /// </summary>
> private int m_countDirection = -1;
>-
>+
> /// <summary>
> /// The rolling mode used in this appender.
> /// </summary>
>@@ -1624,13 +1625,13 @@
> /// Cache flag set if we are rolling by size.
> /// </summary>
> private bool m_rollSize = true;
>-
>+
> /// <summary>
> /// Value indicating whether to always log to the same file.
> /// </summary>
> private bool m_staticLogFileName = true;
>-
>- /// <summary>
>+
>+ /// <summary>
> /// Value indicating whether to preserve the file name
>extension when rolling.
> /// </summary>
> private bool m_preserveLogFileNameExtension = false;
>@@ -1640,7 +1641,7 @@
> /// FileName provided in configuration. Used for rolling
>properly
> /// </summary>
> private string m_baseFileName;
>-
>+
> #endregion Private Instance Fields
>
> #region Static Members
>@@ -1697,7 +1698,7 @@
> }
>
> #if !NET_1_0 && !CLI_1_0 && !NETCF
>- /// <summary>
>+ /// <summary>
> /// Implementation of <see cref="IDateTime"/> that returns
the
>current time as the coordinated universal time (UTC).
> /// </summary>
> private class UniversalDateTime : IDateTime
>@@ -1718,6 +1719,6 @@
> }
> #endif
>
>- #endregion DateTime
>+ #endregion DateTime
> }
> }
