logging-log4net-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Dominik Psenner <dpsen...@gmail.com>
Subject [PATCH 1 of 5] Step 1: refactoring
Date Tue, 22 Jan 2013 13:41:05 GMT
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" /> &gt;= 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" /> &gt;= 0 to reduce

+		/// For infinite backups use <see cref="CountDirection" /> &gt;= 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.InvariantInfo)+"]
vs. ["+m_now.ToString(m_datePattern,System.Globalization.DateTimeFormatInfo.InvariantInfo)+"]");
 
-					if (!(last.ToString(m_datePattern,System.Globalization.DateTimeFormatInfo.InvariantInfo).Equals(m_now.ToString(m_datePattern,
System.Globalization.DateTimeFormatInfo.InvariantInfo)))) 
+					if (!(last.ToString(m_datePattern,System.Globalization.DateTimeFormatInfo.InvariantInfo).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> &lt; 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
 	}
 }

Mime
View raw message