Reworked FileLock to fit our needs

@ejsmith please reivew this as we can revert if you don't like these
changes. I tried to get rid of cases were we were doing extra io calls
(https://blogs.msdn.microsoft.com/jaredpar/2009/12/10/the-file-system-is-unpredictable/)

Author: niemyjski

src/Exceptionless/Storage/LockBase.cs

@@ -1,36 +1,166 @@
 #if !PORTABLE && !NETSTANDARD1_2
 using System;
+using System.Collections.Concurrent;
+using System.Diagnostics;
 using System.IO;
+using System.Threading;
+using Exceptionless.Utility;
 
 namespace Exceptionless.Storage {
-    public sealed class LockFile : LockBase<LockFile> {
+    internal sealed class LockFile : IDisposable {
+        private static readonly ConcurrentDictionary<string, bool> _lockStatus = new ConcurrentDictionary<string, bool>(StringComparer.OrdinalIgnoreCase);
+
         /// <summary>
         /// Initializes a new instance of the <see cref="LockFile"/> class.
         /// </summary>
-        /// <param name="fileName">The file.</param>
-        public LockFile(string fileName) : base(fileName) {
-            FileName = fileName;
+        /// <param name="path"></param>
+        /// <param name="defaultTimeOutInSeconds"></param>
+        public LockFile(string path, int defaultTimeOutInSeconds = 30) {
+            if (String.IsNullOrEmpty(path))
+                throw new ArgumentNullException(nameof(path));
+
+            FileName = path;
+            DefaultTimeOutInSeconds = defaultTimeOutInSeconds;
         }
 
-        public override string GetLockFilePath() {
-            return FileName;
+        /// <summary>
+        /// Acquires a lock while waiting with the default timeout value.
+        /// </summary>
+        public void AcquireLock() {
+            AcquireLock(TimeSpan.FromSeconds(DefaultTimeOutInSeconds));
         }
 
         /// <summary>
-        /// The file that is being locked.
+        /// Acquires a lock in a specific amount of time.
         /// </summary>
-        public string FileName { get; private set; }
+        /// <param name="timeout">The time to wait for when trying to acquire a lock.</param>
+        public void AcquireLock(TimeSpan timeout) {
+            CreateLock(FileName, timeout);
+        }
 
         /// <summary>
-        /// Checks to see if the specific path is locked.
+        /// Acquires a lock in a specific amount of time.
         /// </summary>
-        /// <param name="path"></param>
-        /// <returns>Returns true if the lock has expired or the lock exists.</returns>
-        public static bool IsLocked(string path) {
+        /// <param name="path">The path to acquire a lock on.</param>
+        /// <param name="timeout">The time to wait for when trying to acquire a lock.</param>
+        /// <returns>A lock instance.</returns>
+        public static LockFile Acquire(string path, TimeSpan? timeout = null) {
+            var lockInstance = new LockFile(path);
+            lockInstance.AcquireLock(timeout ?? TimeSpan.FromSeconds(lockInstance.DefaultTimeOutInSeconds));
+            return lockInstance;
+        }
+
+        /// <summary>
+        /// Creates a lock file.
+        /// </summary>
+        /// <param name="path">The place to create the lock file.</param>
+        /// <param name="timeout">The amount of time to wait before a TimeoutException is thrown.</param>
+        private void CreateLock(string path, TimeSpan timeout) {
+            DateTime expire = DateTime.UtcNow.Add(timeout);
+
+            Retry:
+            while (File.Exists(path)) {
+                if (expire < DateTime.UtcNow)
+                    throw new TimeoutException($"The lock '{path}' timed out.");
+
+                if (IsLockExpired(path)) {
+                    Debug.WriteLine($"The lock '{path}' has expired on '{GetCreationTimeUtc(path)}' and wasn't cleaned up properly.");
+                    ReleaseLock();
+                } else {
+                    Debug.WriteLine($"Waiting for lock: {path}");
+                    Thread.Sleep(500);
+                }
+            }
+
+            // create file 
+            try {
+                using (var fs = new FileStream(path, FileMode.CreateNew, FileAccess.Write, FileShare.None))
+                    fs.Dispose();
+
+                _lockStatus[path] = true;
+            } catch (IOException) {
+                Debug.WriteLine($"Error creating lock: {path}");
+                goto Retry;
+            }
+
+            Debug.WriteLine(String.Format($"Created lock: {path}"));
+        }
+
+        /// <summary>
+        /// Releases the lock.
+        /// </summary>
+        public void ReleaseLock() {
+            RemoveLock(FileName);
+        }
+
+        /// <summary>
+        /// Releases the lock.
+        /// </summary>
+        /// <param name="path">The path to the lock file.</param>
+        private void RemoveLock(string path) {
+            Run.WithRetries(() => {
+                try {
+                    DeleteFile(path);
+                    _lockStatus[path] = false;
+                    Debug.WriteLine($"Deleted lock: {path}");
+                } catch (Exception) {
+                    Debug.WriteLine($"Error deleting lock: {path}");
+                    throw;
+                }
+            }, 5);
+        }
+
+        private void DeleteFile(string path) {
+            Run.WithRetries(() => {
+                try {
+                    File.Delete(path);
+#if !NETSTANDARD
+                } catch (DriveNotFoundException) {
+#endif
+                } catch (DirectoryNotFoundException) {
+                } catch (FileNotFoundException) { }
+            });
+        }
+
+        private DateTime GetCreationTimeUtc(string path) {
+            return Run.WithRetries(() => {
+                try {
+                    return File.GetCreationTimeUtc(path);
+#if !NETSTANDARD
+                } catch (DriveNotFoundException) {
+                    return DateTime.MinValue;
+#endif
+                } catch (DirectoryNotFoundException) {
+                    return DateTime.MinValue;
+                } catch (FileNotFoundException) {
+                    return DateTime.MinValue;
+                }
+            });
+        }
+
+        private bool IsLockExpired(string path) {
             if (String.IsNullOrEmpty(path))
-                return false;
+                throw new ArgumentNullException(nameof(path));
 
-            return !IsLockExpired(path) && File.Exists(path);
+            return (!_lockStatus.ContainsKey(path) || !_lockStatus[path]) 
+                && GetCreationTimeUtc(path) < DateTime.UtcNow.Subtract(TimeSpan.FromSeconds(DefaultTimeOutInSeconds * 10));
+        }
+
+        /// <summary>
+        /// The file that is being locked.
+        /// </summary>
+        public string FileName { get; }
+
+        /// <summary>
+        /// The default time to wait when trying to acquire a lock.
+        /// </summary>
+        public double DefaultTimeOutInSeconds { get; }
+
+        /// <summary>
+        /// Releases the lock.
+        /// </summary>
+        public void Dispose() {
+            ReleaseLock();
         }
     }
 }

src/Exceptionless/Storage/LockFile.cs

@@ -22,13 +22,13 @@ public void AcquireTimeOut() {
             Assert.Throws<TimeoutException>(() => LockFile.Acquire("test.lock", TimeSpan.FromSeconds(1)));
         }
 
-        [Fact(Skip = "Test requires 20 seconds to run.")]
+        [Fact]
         public void Acquire() {
             var thread1 = new Thread(s => {
                 _writer.WriteLine("[Thread: {0}] Lock 1 Entry", Thread.CurrentThread.ManagedThreadId);
                 using (var lock1 = LockFile.Acquire("Acquire.lock")) {
                     _writer.WriteLine("[Thread: {0}] Lock 1", Thread.CurrentThread.ManagedThreadId);
-                    Thread.Sleep(TimeSpan.FromSeconds(10));
+                    Thread.Sleep(TimeSpan.FromSeconds(2));
                 }
             });
             thread1.Start();
@@ -41,7 +41,7 @@ public void Acquire() {
             });
 
             thread2.Start();
-            Thread.Sleep(TimeSpan.FromSeconds(20));
+            Thread.Sleep(TimeSpan.FromSeconds(5));
         }
     }
 }