Use "Local" mutex; put ReleaseMutex() in finally

Author: isra-fel

src/Accounts/Authentication.ResourceManager/ProtectedFileProvider.cs

@@ -41,7 +41,7 @@ public abstract class ProtectedFileProvider : IFileProvider, IDisposable
         /// Use a Mutex to prevent cross-process file I/O
         /// </summary>
         /// <returns></returns>
-        private static readonly Mutex _initializationLock = new Mutex(false, @"Global\AzurePowerShellProtectedFileProviderInit");
+        private static readonly Mutex _initializationLock = new Mutex(false, @"Local\AzurePowerShellProtectedFileProviderInit");
         public string FilePath { get; set; }
 
         protected IDataStore DataStore { get; set; }
@@ -93,16 +93,21 @@ public StreamWriter CreateWriter()
         protected virtual void InitializeStream()
         {
             _initializationLock.WaitOne();
-            if (_stream == null)
+            try
             {
-                Stream stream;
-                if (!TryGetStreamLock(AcquireLock, FilePath, out stream))
+                if (_stream == null)
                 {
-                    _initializationLock.ReleaseMutex();
-                    throw new UnauthorizedAccessException(string.Format(Resources.FileLockFailure, FilePath));
+                    Stream stream;
+                    if (!TryGetStreamLock(AcquireLock, FilePath, out stream))
+                    {
+                        throw new UnauthorizedAccessException(string.Format(Resources.FileLockFailure, FilePath));
+                    }
+                    _stream = stream;
                 }
+            }
+            finally
+            {
                 _initializationLock.ReleaseMutex();
-                _stream = stream;
             }
         }
 

src/Accounts/Authentication/Authentication/ProtectedFileTokenCache.cs

@@ -46,7 +46,7 @@ public class ProtectedFileTokenCache : TokenCache, IAzureTokenCache
         /// <summary>
         /// A mutex to prevent IO to token cache file across threads / processes.
         /// </summary>
-        private static readonly Mutex fileLock = new Mutex(false, @"Global\AzurePowerShellAdalTokenCacheFile");
+        private static readonly Mutex fileLock = new Mutex(false, @"Local\AzurePowerShellAdalTokenCacheFile");
 
         private static readonly Lazy<ProtectedFileTokenCache> instance = new Lazy<ProtectedFileTokenCache>(() => new ProtectedFileTokenCache());
 
@@ -134,26 +134,32 @@ private void ReadFileIntoCache(string cacheFileName = null)
             }
 
             fileLock.WaitOne();
-            if (_store.FileExists(cacheFileName))
+            try
             {
-                var existingData = _store.ReadFileAsBytes(cacheFileName);
-                if (existingData != null)
+                if (_store.FileExists(cacheFileName))
                 {
-#if !NETSTANDARD
-                    try
-                    {
-                        Deserialize(ProtectedData.Unprotect(existingData, null, DataProtectionScope.CurrentUser));
-                    }
-                    catch (CryptographicException)
+                    var existingData = _store.ReadFileAsBytes(cacheFileName);
+                    if (existingData != null)
                     {
-                        _store.DeleteFile(cacheFileName);
-                    }
+#if !NETSTANDARD
+                        try
+                        {
+                            Deserialize(ProtectedData.Unprotect(existingData, null, DataProtectionScope.CurrentUser));
+                        }
+                        catch (CryptographicException)
+                        {
+                            _store.DeleteFile(cacheFileName);
+                        }
 #else
-                    Deserialize(existingData);
+                        Deserialize(existingData);
 #endif
+                    }
                 }
             }
-            fileLock.ReleaseMutex();
+            finally
+            {
+                fileLock.ReleaseMutex();
+            }
         }
 
         private void WriteCacheIntoFile(string cacheFileName = null)
@@ -170,22 +176,30 @@ private void WriteCacheIntoFile(string cacheFileName = null)
 #endif
 
             fileLock.WaitOne();
-            if (HasStateChanged)
+            try
             {
-                _store.WriteFile(cacheFileName, dataToWrite);
-                HasStateChanged = false;
+                if (HasStateChanged)
+                {
+                    _store.WriteFile(cacheFileName, dataToWrite);
+                    HasStateChanged = false;
+                }
+            }
+            finally
+            {
+                fileLock.ReleaseMutex();
             }
-            fileLock.ReleaseMutex();
         }
 
         private void EnsureCacheFile(string cacheFileName = null)
         {
             fileLock.WaitOne();
-            if (_store.FileExists(cacheFileName))
+            try
             {
-                var existingData = _store.ReadFileAsBytes(cacheFileName);
-                if (existingData != null)
+                if (_store.FileExists(cacheFileName))
                 {
+                    var existingData = _store.ReadFileAsBytes(cacheFileName);
+                    if (existingData != null)
+                    {
 #if !NETSTANDARD
                         try
                         {
@@ -196,19 +210,23 @@ private void EnsureCacheFile(string cacheFileName = null)
                             _store.DeleteFile(cacheFileName);
                         }
 #else
-                    Deserialize(existingData);
+                        Deserialize(existingData);
 #endif
+                    }
                 }
-            }
 
-            // Eagerly create cache file.
+                // Eagerly create cache file.
 #if !NETSTANDARD
                 var dataToWrite = ProtectedData.Protect(Serialize(), null, DataProtectionScope.CurrentUser);
 #else
-            var dataToWrite = Serialize();
+                var dataToWrite = Serialize();
 #endif
-            _store.WriteFile(cacheFileName, dataToWrite);
-            fileLock.ReleaseMutex();
+                _store.WriteFile(cacheFileName, dataToWrite);
+            }
+            finally
+            {
+                fileLock.ReleaseMutex();
+            }
         }
     }
 }