Merge pull request #435 from IvanMurzak/fix/unity-domain-reload-freeze

IvanMurzak · web-flow · commit 1496aa8cb16d · 2026-01-27T08:55:43.000-08:00
Replace SemaphoreSlim with lock for file access
diff --git a/Unity-MCP-Plugin/Assets/root/Runtime/Unity/Logs/BufferedFileLogStorage.cs b/Unity-MCP-Plugin/Assets/root/Runtime/Unity/Logs/BufferedFileLogStorage.cs
@@ -53,8 +53,7 @@ public override void Flush()
                     nameof(Flush));
                 return;
             }
-            _fileLock.Wait();
-            try
+            lock (_fileMutex)
             {
                 // Flush buffered entries to file
                 if (_logEntriesBufferLength > 0)
@@ -66,21 +65,16 @@ public override void Flush()
                 }
                 fileWriteStream?.Flush();
             }
-            finally
-            {
-                _fileLock.Release();
-            }
         }
-        public override async Task FlushAsync()
+        public override Task FlushAsync()
         {
             if (_isDisposed.Value)
             {
                 _logger.LogWarning("{method} called but already disposed, ignored.",
                     nameof(FlushAsync));
-                return;
+                return Task.CompletedTask;
             }
-            await _fileLock.WaitAsync();
-            try
+            lock (_fileMutex)
             {
                 // Flush buffered entries to file
                 if (_logEntriesBufferLength > 0)
@@ -90,14 +84,9 @@ public override async Task FlushAsync()
                     base.AppendInternal(entriesToFlush);
                     _logEntriesBufferLength = 0;
                 }
-
-                if (fileWriteStream != null)
-                    await fileWriteStream.FlushAsync();
-            }
-            finally
-            {
-                _fileLock.Release();
+                fileWriteStream?.Flush();
             }
+            return Task.CompletedTask;
         }
 
         protected override void AppendInternal(params LogEntry[] entries)
@@ -137,8 +126,7 @@ public override void Clear()
                     nameof(Clear));
                 return;
             }
-            _fileLock.Wait();
-            try
+            lock (_fileMutex)
             {
                 fileWriteStream?.Close();
                 fileWriteStream?.Dispose();
@@ -151,10 +139,6 @@ public override void Clear()
                 if (File.Exists(filePath))
                     _logger.LogError("Failed to delete cache file: {file}", filePath);
             }
-            finally
-            {
-                _fileLock.Release();
-            }
         }
 
         public override LogEntry[] Query(
@@ -169,15 +153,10 @@ public override LogEntry[] Query(
                     nameof(Query));
                 return Array.Empty<LogEntry>();
             }
-            _fileLock.Wait();
-            try
+            lock (_fileMutex)
             {
                 return QueryInternal(maxEntries, logTypeFilter, includeStackTrace, lastMinutes);
             }
-            finally
-            {
-                _fileLock.Release();
-            }
         }
 
         protected override LogEntry[] QueryInternal(
diff --git a/Unity-MCP-Plugin/Assets/root/Runtime/Unity/Logs/FileLogStorage.cs b/Unity-MCP-Plugin/Assets/root/Runtime/Unity/Logs/FileLogStorage.cs
@@ -15,7 +15,6 @@
 using System.Linq;
 using System.Text.Json;
 using System.Text.Json.Serialization;
-using System.Threading;
 using System.Threading.Tasks;
 using com.IvanMurzak.McpPlugin.Common;
 using com.IvanMurzak.ReflectorNet;
@@ -36,7 +35,7 @@ public class FileLogStorage : ILogStorage, IDisposable
         protected readonly string _directoryPath;
         protected readonly string _requestedFileName;
         protected readonly JsonSerializerOptions _jsonOptions;
-        protected readonly SemaphoreSlim _fileLock = new(1, 1);
+        protected readonly object _fileMutex = new();
         protected readonly int _fileBufferSize;
         protected readonly long _maxFileSizeBytes;
         protected readonly ThreadSafeBool _isDisposed = new(false);
@@ -140,34 +139,32 @@ public virtual void Flush()
                     nameof(Flush));
                 return;
             }
-            _fileLock.Wait();
-            try
+            lock (_fileMutex)
             {
                 fileWriteStream?.Flush();
             }
-            finally
-            {
-                _fileLock.Release();
-            }
         }
-        public virtual async Task FlushAsync()
+        public virtual Task FlushAsync()
         {
             if (_isDisposed.Value)
             {
                 _logger.LogWarning("{method} called but already disposed, ignored.",
                     nameof(FlushAsync));
-                return;
-            }
-            await _fileLock.WaitAsync();
-            try
-            {
-                if (fileWriteStream != null)
-                    await fileWriteStream.FlushAsync();
+                return Task.CompletedTask;
             }
-            finally
+            return Task.Run(() =>
             {
-                _fileLock.Release();
-            }
+                if (_isDisposed.Value)
+                {
+                    _logger.LogWarning("{method} called but already disposed, ignored.",
+                        nameof(FlushAsync));
+                    return;
+                }
+                lock (_fileMutex)
+                {
+                    fileWriteStream?.Flush();
+                }
+            });
         }
 
         public virtual Task AppendAsync(params LogEntry[] entries)
@@ -178,16 +175,17 @@ public virtual Task AppendAsync(params LogEntry[] entries)
                     nameof(AppendAsync));
                 return Task.CompletedTask;
             }
-            return Task.Run(async () =>
+            return Task.Run(() =>
             {
-                await _fileLock.WaitAsync();
-                try
+                if (_isDisposed.Value)
                 {
-                    AppendInternal(entries);
+                    _logger.LogWarning("{method} called but already disposed, ignored.",
+                        nameof(AppendAsync));
+                    return;
                 }
-                finally
+                lock (_fileMutex)
                 {
-                    _fileLock.Release();
+                    AppendInternal(entries);
                 }
             });
         }
@@ -200,15 +198,10 @@ public virtual void Append(params LogEntry[] entries)
                     nameof(Append));
                 return;
             }
-            _fileLock.Wait();
-            try
+            lock (_fileMutex)
             {
                 AppendInternal(entries);
             }
-            finally
-            {
-                _fileLock.Release();
-            }
         }
 
         protected virtual void AppendInternal(params LogEntry[] entries)
@@ -272,8 +265,7 @@ public virtual void Clear()
                     nameof(Clear));
                 return;
             }
-            _fileLock.Wait();
-            try
+            lock (_fileMutex)
             {
                 fileWriteStream?.Dispose();
                 fileWriteStream = null;
@@ -284,10 +276,6 @@ public virtual void Clear()
                 if (File.Exists(filePath))
                     _logger.LogError("Failed to delete cache file: {file}", filePath);
             }
-            finally
-            {
-                _fileLock.Release();
-            }
         }
 
         public virtual Task<LogEntry[]> QueryAsync(
@@ -317,15 +305,10 @@ public virtual LogEntry[] Query(
                     nameof(Query));
                 return Array.Empty<LogEntry>();
             }
-            _fileLock.Wait();
-            try
+            lock (_fileMutex)
             {
                 return QueryInternal(maxEntries, logTypeFilter, includeStackTrace, lastMinutes);
             }
-            finally
-            {
-                _fileLock.Release();
-            }
         }
 
         protected virtual LogEntry[] QueryInternal(
@@ -460,8 +443,6 @@ public virtual void Dispose()
                 fileWriteStream = null;
             }
 
-            _fileLock.Dispose();
-
             GC.SuppressFinalize(this);
         }
 

Original file line number	Diff line number	Diff line change
`@@ -53,8 +53,7 @@ public override void Flush()`
`53`	`53`	`nameof(Flush));`
`54`	`54`	`return;`
`55`	`55`	`}`
`56`		`- _fileLock.Wait();`
`57`		`- try`
	`56`	`+ lock (_fileMutex)`
`58`	`57`	`{`
`59`	`58`	`// Flush buffered entries to file`
`60`	`59`	`if (_logEntriesBufferLength > 0)`
`@@ -66,21 +65,16 @@ public override void Flush()`
`66`	`65`	`}`
`67`	`66`	`fileWriteStream?.Flush();`
`68`	`67`	`}`
`69`		`- finally`
`70`		`- {`
`71`		`- _fileLock.Release();`
`72`		`- }`
`73`	`68`	`}`
`74`		`- public override async Task FlushAsync()`
	`69`	`+ public override Task FlushAsync()`
`75`	`70`	`{`
`76`	`71`	`if (_isDisposed.Value)`
`77`	`72`	`{`
`78`	`73`	`_logger.LogWarning("{method} called but already disposed, ignored.",`
`79`	`74`	`nameof(FlushAsync));`
`80`		`- return;`
	`75`	`+ return Task.CompletedTask;`
`81`	`76`	`}`
`82`		`- await _fileLock.WaitAsync();`
`83`		`- try`
	`77`	`+ lock (_fileMutex)`
`84`	`78`	`{`
`85`	`79`	`// Flush buffered entries to file`
`86`	`80`	`if (_logEntriesBufferLength > 0)`
`@@ -90,14 +84,9 @@ public override async Task FlushAsync()`
`90`	`84`	`base.AppendInternal(entriesToFlush);`
`91`	`85`	`_logEntriesBufferLength = 0;`
`92`	`86`	`}`
`93`		`-`
`94`		`- if (fileWriteStream != null)`
`95`		`- await fileWriteStream.FlushAsync();`
`96`		`- }`
`97`		`- finally`
`98`		`- {`
`99`		`- _fileLock.Release();`
	`87`	`+ fileWriteStream?.Flush();`
`100`	`88`	`}`
	`89`	`+ return Task.CompletedTask;`
`101`	`90`	`}`
`102`	`91`
`103`	`92`	`protected override void AppendInternal(params LogEntry[] entries)`
`@@ -137,8 +126,7 @@ public override void Clear()`
`137`	`126`	`nameof(Clear));`
`138`	`127`	`return;`
`139`	`128`	`}`
`140`		`- _fileLock.Wait();`
`141`		`- try`
	`129`	`+ lock (_fileMutex)`
`142`	`130`	`{`
`143`	`131`	`fileWriteStream?.Close();`
`144`	`132`	`fileWriteStream?.Dispose();`
`@@ -151,10 +139,6 @@ public override void Clear()`
`151`	`139`	`if (File.Exists(filePath))`
`152`	`140`	`_logger.LogError("Failed to delete cache file: {file}", filePath);`
`153`	`141`	`}`
`154`		`- finally`
`155`		`- {`
`156`		`- _fileLock.Release();`
`157`		`- }`
`158`	`142`	`}`
`159`	`143`
`160`	`144`	`public override LogEntry[] Query(`
`@@ -169,15 +153,10 @@ public override LogEntry[] Query(`
`169`	`153`	`nameof(Query));`
`170`	`154`	`return Array.Empty<LogEntry>();`
`171`	`155`	`}`
`172`		`- _fileLock.Wait();`
`173`		`- try`
	`156`	`+ lock (_fileMutex)`
`174`	`157`	`{`
`175`	`158`	`return QueryInternal(maxEntries, logTypeFilter, includeStackTrace, lastMinutes);`
`176`	`159`	`}`
`177`		`- finally`
`178`		`- {`
`179`		`- _fileLock.Release();`
`180`		`- }`
`181`	`160`	`}`
`182`	`161`
`183`	`162`	`protected override LogEntry[] QueryInternal(`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,6 @@`
`15`	`15`	`using System.Linq;`
`16`	`16`	`using System.Text.Json;`
`17`	`17`	`using System.Text.Json.Serialization;`
`18`		`-using System.Threading;`
`19`	`18`	`using System.Threading.Tasks;`
`20`	`19`	`using com.IvanMurzak.McpPlugin.Common;`
`21`	`20`	`using com.IvanMurzak.ReflectorNet;`
`@@ -36,7 +35,7 @@ public class FileLogStorage : ILogStorage, IDisposable`
`36`	`35`	`protected readonly string _directoryPath;`
`37`	`36`	`protected readonly string _requestedFileName;`
`38`	`37`	`protected readonly JsonSerializerOptions _jsonOptions;`
`39`		`- protected readonly SemaphoreSlim _fileLock = new(1, 1);`
	`38`	`+ protected readonly object _fileMutex = new();`
`40`	`39`	`protected readonly int _fileBufferSize;`
`41`	`40`	`protected readonly long _maxFileSizeBytes;`
`42`	`41`	`protected readonly ThreadSafeBool _isDisposed = new(false);`
`@@ -140,34 +139,32 @@ public virtual void Flush()`
`140`	`139`	`nameof(Flush));`
`141`	`140`	`return;`
`142`	`141`	`}`
`143`		`- _fileLock.Wait();`
`144`		`- try`
	`142`	`+ lock (_fileMutex)`
`145`	`143`	`{`
`146`	`144`	`fileWriteStream?.Flush();`
`147`	`145`	`}`
`148`		`- finally`
`149`		`- {`
`150`		`- _fileLock.Release();`
`151`		`- }`
`152`	`146`	`}`
`153`		`- public virtual async Task FlushAsync()`
	`147`	`+ public virtual Task FlushAsync()`
`154`	`148`	`{`
`155`	`149`	`if (_isDisposed.Value)`
`156`	`150`	`{`
`157`	`151`	`_logger.LogWarning("{method} called but already disposed, ignored.",`
`158`	`152`	`nameof(FlushAsync));`
`159`		`- return;`
`160`		`- }`
`161`		`- await _fileLock.WaitAsync();`
`162`		`- try`
`163`		`- {`
`164`		`- if (fileWriteStream != null)`
`165`		`- await fileWriteStream.FlushAsync();`
	`153`	`+ return Task.CompletedTask;`
`166`	`154`	`}`
`167`		`- finally`
	`155`	`+ return Task.Run(() =>`
`168`	`156`	`{`
`169`		`- _fileLock.Release();`
`170`		`- }`
	`157`	`+ if (_isDisposed.Value)`
	`158`	`+ {`
	`159`	`+ _logger.LogWarning("{method} called but already disposed, ignored.",`
	`160`	`+ nameof(FlushAsync));`
	`161`	`+ return;`
	`162`	`+ }`
	`163`	`+ lock (_fileMutex)`
	`164`	`+ {`
	`165`	`+ fileWriteStream?.Flush();`
	`166`	`+ }`
	`167`	`+ });`
`171`	`168`	`}`
`172`	`169`
`173`	`170`	`public virtual Task AppendAsync(params LogEntry[] entries)`
`@@ -178,16 +175,17 @@ public virtual Task AppendAsync(params LogEntry[] entries)`
`178`	`175`	`nameof(AppendAsync));`
`179`	`176`	`return Task.CompletedTask;`
`180`	`177`	`}`
`181`		`- return Task.Run(async () =>`
	`178`	`+ return Task.Run(() =>`
`182`	`179`	`{`
`183`		`- await _fileLock.WaitAsync();`
`184`		`- try`
	`180`	`+ if (_isDisposed.Value)`
`185`	`181`	`{`
`186`		`- AppendInternal(entries);`
	`182`	`+ _logger.LogWarning("{method} called but already disposed, ignored.",`
	`183`	`+ nameof(AppendAsync));`
	`184`	`+ return;`
`187`	`185`	`}`
`188`		`- finally`
	`186`	`+ lock (_fileMutex)`
`189`	`187`	`{`
`190`		`- _fileLock.Release();`
	`188`	`+ AppendInternal(entries);`
`191`	`189`	`}`
`192`	`190`	`});`
`193`	`191`	`}`
`@@ -200,15 +198,10 @@ public virtual void Append(params LogEntry[] entries)`
`200`	`198`	`nameof(Append));`
`201`	`199`	`return;`
`202`	`200`	`}`
`203`		`- _fileLock.Wait();`
`204`		`- try`
	`201`	`+ lock (_fileMutex)`
`205`	`202`	`{`
`206`	`203`	`AppendInternal(entries);`
`207`	`204`	`}`
`208`		`- finally`
`209`		`- {`
`210`		`- _fileLock.Release();`
`211`		`- }`
`212`	`205`	`}`
`213`	`206`
`214`	`207`	`protected virtual void AppendInternal(params LogEntry[] entries)`
`@@ -272,8 +265,7 @@ public virtual void Clear()`
`272`	`265`	`nameof(Clear));`
`273`	`266`	`return;`
`274`	`267`	`}`
`275`		`- _fileLock.Wait();`
`276`		`- try`
	`268`	`+ lock (_fileMutex)`
`277`	`269`	`{`
`278`	`270`	`fileWriteStream?.Dispose();`
`279`	`271`	`fileWriteStream = null;`
`@@ -284,10 +276,6 @@ public virtual void Clear()`
`284`	`276`	`if (File.Exists(filePath))`
`285`	`277`	`_logger.LogError("Failed to delete cache file: {file}", filePath);`
`286`	`278`	`}`
`287`		`- finally`
`288`		`- {`
`289`		`- _fileLock.Release();`
`290`		`- }`
`291`	`279`	`}`
`292`	`280`
`293`	`281`	`public virtual Task<LogEntry[]> QueryAsync(`
`@@ -317,15 +305,10 @@ public virtual LogEntry[] Query(`
`317`	`305`	`nameof(Query));`
`318`	`306`	`return Array.Empty<LogEntry>();`
`319`	`307`	`}`
`320`		`- _fileLock.Wait();`
`321`		`- try`
	`308`	`+ lock (_fileMutex)`
`322`	`309`	`{`
`323`	`310`	`return QueryInternal(maxEntries, logTypeFilter, includeStackTrace, lastMinutes);`
`324`	`311`	`}`
`325`		`- finally`
`326`		`- {`
`327`		`- _fileLock.Release();`
`328`		`- }`
`329`	`312`	`}`
`330`	`313`
`331`	`314`	`protected virtual LogEntry[] QueryInternal(`
`@@ -460,8 +443,6 @@ public virtual void Dispose()`
`460`	`443`	`fileWriteStream = null;`
`461`	`444`	`}`
`462`	`445`
`463`		`- _fileLock.Dispose();`
`464`		`-`
`465`	`446`	`GC.SuppressFinalize(this);`
`466`	`447`	`}`
`467`	`448`