NLog · 304NotModified · Sep 18, 2016 · Sep 17, 2016 · Sep 18, 2016 · Sep 18, 2016
diff --git a/src/NLog/Internal/FileAppenders/BaseFileAppender.cs b/src/NLog/Internal/FileAppenders/BaseFileAppender.cs
@@ -39,9 +39,14 @@ namespace NLog.Internal.FileAppenders
    using System.IO;
    using System.Runtime.InteropServices;
    using NLog.Common;
-    using NLog.Config;
    using NLog.Internal;
-    using NLog.Time;
+    using System.Threading;
+#if !SILVERLIGHT
+    using System.Security.AccessControl;
+    using System.Security.Principal;
+    using System.Security.Cryptography;
+#endif
+    using System.Text;

    /// <summary>
    /// Base class for optimized file appenders.
@@ -63,6 +68,9 @@ public BaseFileAppender(string fileName, ICreateFileParameters createParameters)
            this.OpenTime = DateTime.UtcNow; // to be consistent with timeToKill in FileTarget.AutoClosingTimerCallback
            this.LastWriteTime = DateTime.MinValue;
            this.CaptureLastWriteTime = createParameters.CaptureLastWriteTime;
+#if !SILVERLIGHT
+            this.ArchiveMutex = CreateArchiveMutex();
+#endif
        }

        protected bool CaptureLastWriteTime { get; private set; }
@@ -97,6 +105,14 @@ public BaseFileAppender(string fileName, ICreateFileParameters createParameters)
        /// <value>The file creation parameters.</value>
        public ICreateFileParameters CreateFileParameters { get; private set; }

+#if !SILVERLIGHT
+        /// <summary>
+        /// Gets the mutually-exclusive lock for archiving files.
+        /// </summary>
+        /// <value>The mutex for archiving.</value>
+        public Mutex ArchiveMutex { get; private set; }
+#endif
+
        /// <summary>
        /// Writes the specified bytes.
        /// </summary>
@@ -158,6 +174,78 @@ protected void FileTouched(DateTime dateTime)
            this.LastWriteTime = dateTime;
        }

+#if !SILVERLIGHT
+        /// <summary>
+        /// Creates a mutually-exclusive lock for archiving files.
+        /// </summary>
+        /// <returns>A <see cref="Mutex"/> object which can be used for controlling the archiving of files.</returns>
+        protected virtual Mutex CreateArchiveMutex()
+        {
+            return new Mutex();
+        }
+
+        /// <summary>
+        /// Creates a mutex for archiving that is sharable by more than one process.
+        /// </summary>
+        /// <returns>A <see cref="Mutex"/> object which can be used for controlling the archiving of files.</returns>
+        protected Mutex CreateSharableArchiveMutex()
+        {
+            return CreateSharableMutex("FileArchiveLock");
+        }
+
+        /// <summary>
+        /// Creates a mutex that is sharable by more than one process.
+        /// </summary>
+        /// <param name="mutexNamePrefix">The prefix to use for the name of the mutex.</param>
+        /// <returns>A <see cref="Mutex"/> object which is sharable by multiple processes.</returns>
+        protected Mutex CreateSharableMutex(string mutexNamePrefix)
+        {
+            // Creates a mutex sharable by more than one process
+            var mutexSecurity = new MutexSecurity();
+            var everyoneSid = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
+            mutexSecurity.AddAccessRule(new MutexAccessRule(everyoneSid, MutexRights.FullControl, AccessControlType.Allow));
+
+            // The constructor will either create new mutex or open
+            // an existing one, in a thread-safe manner
+            bool createdNew;
+            return new Mutex(false, GetMutexName(mutexNamePrefix), out createdNew, mutexSecurity);
+        }
+
+        private string GetMutexName(string mutexNamePrefix)
+        {
+            const string mutexNameFormatString = @"Global\NLog-File{0}-{1}";
+            const int maxMutexNameLength = 260;
+
+            string canonicalName = Path.GetFullPath(FileName).ToLowerInvariant();
+
+            // Mutex names must not contain a backslash, it's the namespace separator,
+            // but all other are OK
+            canonicalName = canonicalName.Replace('\\', '/');
+            string mutexName = string.Format(mutexNameFormatString, mutexNamePrefix, canonicalName);
+
+            // A mutex name must not exceed MAX_PATH (260) characters
+            if (mutexName.Length <= maxMutexNameLength)
+            {
+                return mutexName;
+            }
+
+            // The unusual case of the path being too long; let's hash the canonical name,
+            // so it can be safely shortened and still remain unique
+            string hash;
+            using (MD5 md5 = MD5.Create())
+            {
+                byte[] bytes = md5.ComputeHash(Encoding.UTF8.GetBytes(canonicalName));
+                hash = Convert.ToBase64String(bytes);
+            }
+
+            // The hash makes the name unique, but also add the end of the path,
+            // so the end of the name tells us which file it is (for debugging)
+            mutexName = string.Format(mutexNameFormatString, mutexNamePrefix, hash);
+            int cutOffIndex = canonicalName.Length - (maxMutexNameLength - mutexName.Length);
+            return mutexName + canonicalName.Substring(cutOffIndex);
+        }
+#endif
+
        /// <summary>
        /// Creates the file stream.
        /// </summary>

diff --git a/src/NLog/Internal/FileAppenders/FileAppenderCache.cs b/src/NLog/Internal/FileAppenders/FileAppenderCache.cs
@@ -301,6 +301,14 @@ private BaseFileAppender GetAppender(string fileName)
            return null;
        }

+#if !SILVERLIGHT
+        public Mutex GetArchiveMutex(string fileName)
+        {
+            var appender = GetAppender(fileName);
+            return appender == null ? null : appender.ArchiveMutex;
+        }
+#endif
+
        public DateTime? GetFileCreationTimeUtc(string filePath, bool fallback)
        {
            var appender = GetAppender(filePath);
@@ -354,9 +362,7 @@ private BaseFileAppender GetAppender(string fileName)

            return result;
        }
-
-
-
+
        /// <summary>
        /// Closes the specified appender and removes it from the list. 
        /// </summary>

diff --git a/src/NLog/Internal/FileAppenders/MutexMultiProcessFileAppender.cs b/src/NLog/Internal/FileAppenders/MutexMultiProcessFileAppender.cs
@@ -35,15 +35,11 @@

 namespace NLog.Internal.FileAppenders
 {
+    using NLog.Common;
    using System;
    using System.IO;
    using System.Security;
-    using System.Security.AccessControl;
-    using System.Security.Cryptography;
-    using System.Security.Principal;
-    using System.Text;
    using System.Threading;
-    using NLog.Common;

    /// <summary>
    /// Provides a multiprocess-safe atomic file appends while
@@ -73,7 +69,7 @@ public MutexMultiProcessFileAppender(string fileName, ICreateFileParameters para
        {
            try
            {
-                this.mutex = CreateSharableMutex(GetMutexName(fileName));
+                this.mutex = CreateSharableMutex("FileLock");
                this.fileStream = CreateFileStream(true);
            }
            catch
@@ -187,51 +183,13 @@ private FileCharacteristics GetFileCharacteristics()
            return FileCharacteristicsHelper.Helper.GetFileCharacteristics(FileName, this.fileStream.SafeFileHandle.DangerousGetHandle());
        }

-        private static Mutex CreateSharableMutex(string name)
-        {
-            // Creates a mutex sharable by more than one process
-            var mutexSecurity = new MutexSecurity();
-            var everyoneSid = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
-            mutexSecurity.AddAccessRule(new MutexAccessRule(everyoneSid, MutexRights.FullControl, AccessControlType.Allow));
-
-            // The constructor will either create new mutex or open
-            // an existing one, in a thread-safe manner
-            bool createdNew;
-            return new Mutex(false, name, out createdNew, mutexSecurity);
-        }
-
-        private static string GetMutexName(string fileName)
+        /// <summary>
+        /// Creates a mutually-exclusive lock for archiving files.
+        /// </summary>
+        /// <returns>A <see cref="Mutex"/> object which can be used for controlling the archiving of files.</returns>
+        protected override Mutex CreateArchiveMutex()
        {
-            // The global kernel object namespace is used so the mutex
-            // can be shared among processes in all sessions
-            const string mutexNamePrefix = @"Global\NLog-FileLock-";
-            const int maxMutexNameLength = 260;
-
-            string canonicalName = Path.GetFullPath(fileName).ToLowerInvariant();
-
-            // Mutex names must not contain a backslash, it's the namespace separator,
-            // but all other are OK
-            canonicalName = canonicalName.Replace('\\', '/');
-
-            // A mutex name must not exceed MAX_PATH (260) characters
-            if (mutexNamePrefix.Length + canonicalName.Length <= maxMutexNameLength)
-            {
-                return mutexNamePrefix + canonicalName;
-            }
-
-            // The unusual case of the path being too long; let's hash the canonical name,
-            // so it can be safely shortened and still remain unique
-            string hash;
-            using (MD5 md5 = MD5.Create())
-            {
-                byte[] bytes = md5.ComputeHash(Encoding.UTF8.GetBytes(canonicalName));
-                hash = Convert.ToBase64String(bytes);
-            }
-
-            // The hash makes the name unique, but also add the end of the path,
-            // so the end of the name tells us which file it is (for debugging)
-            int cutOffIndex = canonicalName.Length - (maxMutexNameLength - mutexNamePrefix.Length - hash.Length);
-            return mutexNamePrefix + hash + canonicalName.Substring(cutOffIndex);
+            return CreateSharableArchiveMutex();
        }

        /// <summary>

diff --git a/src/NLog/Internal/FileAppenders/RetryingMultiProcessFileAppender.cs b/src/NLog/Internal/FileAppenders/RetryingMultiProcessFileAppender.cs
@@ -37,6 +37,7 @@ namespace NLog.Internal.FileAppenders
 {
    using System;
    using System.IO;
+    using System.Threading;

    /// <summary>
    /// Multi-process and multi-host file appender which attempts
@@ -120,6 +121,17 @@ public override void Close()
            return null;
        }

+#if !SILVERLIGHT
+        /// <summary>
+        /// Creates a mutually-exclusive lock for archiving files.
+        /// </summary>
+        /// <returns>A <see cref="Mutex"/> object which can be used for controlling the archiving of files.</returns>
+        protected override Mutex CreateArchiveMutex()
+        {
+            return CreateSharableArchiveMutex();
+        }
+#endif
+
        /// <summary>
        /// Factory class.
        /// </summary>

diff --git a/src/NLog/Targets/FileTarget.cs b/src/NLog/Targets/FileTarget.cs
@@ -1035,11 +1035,7 @@ private void ProcessLogEvent(LogEventInfo logEvent, string fileName, byte[] byte
 #if !SILVERLIGHT && !__IOS__ && !__ANDROID__
            this.fileAppenderCache.InvalidateAppendersForInvalidFiles();
 #endif
-            var archiveFile = this.GetArchiveFileName(fileName, logEvent, bytesToWrite.Length);
-            if (!string.IsNullOrEmpty(archiveFile))
-            {
-                this.DoAutoArchive(archiveFile, logEvent);
-            }
+            TryArchiveFile(fileName, logEvent, bytesToWrite.Length);

            // Clean up old archives if this is the first time a log record is being written to
            // this log file and the archiving system is date/time based.
@@ -1195,26 +1191,7 @@ private void RollArchivesForward(string fileName, string pattern, int archiveNum
            else
            {
                InternalLogger.Info("Roll archive {0} to {1}", fileName, newFileName);
-                try
-                {
-                    File.Move(fileName, newFileName);
-                }
-                catch (Exception ex)
-                {
-                    InternalLogger.Warn(ex, "Roll archive {0} to {1} failed", fileName, newFileName);
-                    //if failed due to a race condition (file exists suddenly), then retry with a new number.
-                    if (File.Exists(newFileName))
-                    {
-                        InternalLogger.Debug(ex, "Roll archive {0} to {1} failed because of a race condition. Retry with new name", fileName, newFileName);
-                        RollArchivesForward(newFileName, pattern, archiveNumber + 1);
-                    }
-                    else
-                    {
-                        throw;
-                    }
-                }
-
-
+                File.Move(fileName, newFileName);
            }
        }

@@ -1791,7 +1768,50 @@ private bool ShouldDeleteOldArchives()
        }

        /// <summary>
-        /// Gets the file name for archiving, or null if archiving should not occur.
+        /// Archives the file if it should be archived.
+        /// </summary>
+        /// <param name="fileName">The file name to check for.</param>
+        /// <param name="ev">Log event that the <see cref="FileTarget"/> instance is currently processing.</param>
+        /// <param name="upcomingWriteSize">The size in bytes of the next chunk of data to be written in the file.</param>
+        private void TryArchiveFile(string fileName, LogEventInfo ev, int upcomingWriteSize)
+        {
+            var archiveFile = this.GetArchiveFileName(fileName, ev, upcomingWriteSize);
+            if (!string.IsNullOrEmpty(archiveFile))
+            {
+#if !SILVERLIGHT
+                Mutex archiveMutex = this.fileAppenderCache.GetArchiveMutex(fileName);
+                try
+                {
+                    if (archiveMutex != null)
+                        archiveMutex.WaitOne();
+                }
+                catch (AbandonedMutexException)
+                {
+                    // ignore the exception, another process was killed without properly releasing the mutex
+                    // the mutex has been acquired, so proceed to writing
+                    // See: http://msdn.microsoft.com/en-us/library/system.threading.abandonedmutexexception.aspx
+                }
+#endif
+                try
+                {
+                    archiveFile = this.GetArchiveFileName(fileName, ev, upcomingWriteSize);
+                    if (!string.IsNullOrEmpty(archiveFile))
+                    {
+                        this.DoAutoArchive(archiveFile, ev);
+                    }
+                }
+                finally
+                {
+#if !SILVERLIGHT
+                    if (archiveMutex != null)
+                        archiveMutex.ReleaseMutex();
+#endif
+                }
+            }
+        }
+
+        /// <summary>
+        /// Indicates if the automatic archiving process should be executed.
        /// </summary>
        /// <param name="fileName">File name to be written.</param>
        /// <param name="ev">Log event that the <see cref="FileTarget"/> instance is currently processing.</param>
@@ -1804,7 +1824,7 @@ private string GetArchiveFileName(string fileName, LogEventInfo ev, int upcoming
            {
                return GetArchiveFileNameBasedOnFileSize(fileName, upcomingWriteSize) ??
                       GetArchiveFileNameBasedOnTime(fileName, ev);
-        }
+            }

            return null;
        }