A lock file implementation applied to project GitVersionCore for resolving #1031

src/GitVersionCore.Tests/Helpers/TestFileSystem.cs

@@ -78,6 +78,11 @@ public IEnumerable<string> DirectoryEnumerateFiles(string directory, string sear
             throw new NotImplementedException();
         }
 
+        public FileStream Open(string path, FileMode mode, FileAccess access, FileShare share)
+        {
+            return new FileStream(path, mode, access, share);
+        }
+
         public Stream OpenWrite(string path)
         {
             return new TestStream(path, this);

src/GitVersionCore/Core/Abstractions/IFileSystem.cs

@@ -14,6 +14,7 @@ public interface IFileSystem
         void WriteAllText(string file, string fileContents);
         void WriteAllText(string file, string fileContents, Encoding encoding);
         IEnumerable<string> DirectoryEnumerateFiles(string directory, string searchPattern, SearchOption searchOption);
+        FileStream Open(string path, FileMode mode, FileAccess access, FileShare share);
         Stream OpenWrite(string path);
         Stream OpenRead(string path);
         void CreateDirectory(string path);

src/GitVersionCore/Core/FileSystem.cs

@@ -51,6 +51,11 @@ public IEnumerable<string> DirectoryEnumerateFiles(string directory, string sear
             return Directory.EnumerateFiles(directory, searchPattern, searchOption);
         }
 
+        public FileStream Open(string path, FileMode mode, FileAccess access, FileShare share)
+        {
+            return File.Open(path, mode, access, share);
+        }
+
         public Stream OpenWrite(string path)
         {
             return File.OpenWrite(path);

src/GitVersionCore/FileLocking/Abstractions/IFileLock.cs

@@ -0,0 +1,7 @@
+using System;
+
+namespace GitVersion.FileLocking
+{
+    public interface IFileLock : IDisposable
+    { }
+}

src/GitVersionCore/FileLocking/Abstractions/IFileLocker.cs

@@ -0,0 +1,7 @@
+namespace GitVersion.FileLocking
+{
+    public interface IFileLocker
+    {
+        FileLockUse WaitUntilAcquired();
+    }
+}

src/GitVersionCore/FileLocking/FileLockContext.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Threading;
+
+namespace GitVersion.FileLocking
+{
+
+#nullable enable
+
+    internal class FileLockContext
+    {
+        public FileStream? FileStream { get; }
+        public Exception? Error { get; }
+        public ManualResetEvent? ErrorUnlockDone { get; }
+
+        private readonly FileLocker fileLocker;
+        private object? decreaseLockUseLocker;
+
+        private FileLockContext(FileLocker fileLocker, object decreaseLockUseLocker)
+        {
+            this.fileLocker = fileLocker ?? throw new ArgumentNullException(nameof(fileLocker));
+            this.decreaseLockUseLocker = decreaseLockUseLocker;
+        }
+
+        public FileLockContext(FileLocker fileLocker, object decreaseLockUseLocker, FileStream fileStream)
+            : this(fileLocker, decreaseLockUseLocker)
+        {
+            fileStream = fileStream ?? throw new ArgumentNullException(nameof(fileStream));
+            FileStream = fileStream;
+        }
+
+        public FileLockContext(FileLocker fileLocker, object decreaseLockUseLocker, Exception error, ManualResetEvent errorUnlockDone)
+            : this(fileLocker, decreaseLockUseLocker)
+        {
+            Error = error ?? throw new ArgumentNullException(nameof(error));
+            ErrorUnlockDone = errorUnlockDone ?? throw new ArgumentNullException(nameof(errorUnlockDone));
+        }
+
+        public void DecreaseLockUse(bool decreaseToZero, string lockId)
+        {
+            if (FileStream == null) {
+                throw new InvalidOperationException("You cannot decrease lock use when no file stream has been assgined.");
+            }
+
+            var decreaseLockUseLocker = this.decreaseLockUseLocker;
+
+            if (decreaseLockUseLocker == null)
+                return;
+
+            // Why surround by lock?
+            // There is a race condition, when number of file lock uses
+            // is decrased to 0. It may not have invalidated the file
+            // stream yet. Now it can happen that the number of file lock
+            // uses is increased to 1 due to file lock, but right after another
+            // file unlock is about to decrease the number again to 0.
+            // There is the possiblity that the actual file lock gets released
+            // two times accidentally.
+            lock (decreaseLockUseLocker)
+            {
+                if (!(FileStream.CanRead || FileStream.CanWrite))
+                {
+                    Trace.WriteLine($"{FileLocker.CurrentThreadWithLockIdPrefix(lockId)} Lock use has been invalidated before. Skip decreasing lock use.", FileLocker.TraceCategory);
+                    return;
+                }
+
+                var locksInUse = fileLocker.DecreaseLockUse(decreaseToZero, lockId);
+
+                if (0 == locksInUse)
+                {
+                    this.decreaseLockUseLocker = null;
+                }
+            }
+        }
+    }
+}

src/GitVersionCore/FileLocking/FileLockContextExtensions.cs

@@ -0,0 +1,16 @@
+namespace GitVersion.FileLocking
+{
+
+#nullable enable
+
+    internal static class FileLockContextExtensions
+    {
+        public static bool IsErroneous(this FileLockContext? fileLockContext)
+        {
+            if (fileLockContext?.Error is null)
+                return false;
+
+            return true;
+        }
+    }
+}

src/GitVersionCore/FileLocking/FileLockUse.cs

@@ -0,0 +1,36 @@
+using System;
+using System.ComponentModel;
+using System.IO;
+
+namespace GitVersion.FileLocking
+{
+
+#nullable enable
+
+    public struct FileLockUse : IDisposable
+    {
+        public FileStream FileStream => fileLockContext.FileStream!;
+
+        private readonly FileLockContext fileLockContext;
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public readonly string LockId;
+
+        internal FileLockUse(FileLockContext fileLockContext, string LockId)
+        {
+            this.fileLockContext = fileLockContext ?? throw new ArgumentNullException(nameof(fileLockContext));
+
+            if (fileLockContext.FileStream is null)
+            {
+                throw new ArgumentException("File stream context has invalid file stream.");
+            }
+
+            this.LockId = LockId;
+        }
+
+        public void Dispose()
+        {
+            // When stream not closed, we can decrease lock use.
+            fileLockContext.DecreaseLockUse(false, LockId);
+        }
+    }
+}