fix: main thread deadlock cause by calling .Result directly (#1720)

Signed-off-by: leo <[email protected]>

Author: love-linger

src/App.axaml.cs

@@ -578,7 +578,7 @@ private void TryOpenRepository(string repo)
         {
             if (!string.IsNullOrEmpty(repo) && Directory.Exists(repo))
             {
-                var test = new Commands.QueryRepositoryRootPath(repo).GetResultAsync().Result;
+                var test = new Commands.QueryRepositoryRootPath(repo).GetResult();
                 if (test.IsSuccess && !string.IsNullOrEmpty(test.StdOut))
                 {
                     Dispatcher.UIThread.Invoke(() =>

src/Commands/Command.cs

@@ -50,6 +50,28 @@ public void Exec()
             }
         }
 
+        protected Result ReadToEnd()
+        {
+            using var proc = new Process() { StartInfo = CreateGitStartInfo(true) };
+
+            try
+            {
+                proc.Start();
+            }
+            catch (Exception e)
+            {
+                return Result.Failed(e.Message);
+            }
+
+            var rs = new Result() { IsSuccess = true };
+            rs.StdOut = proc.StandardOutput.ReadToEnd();
+            rs.StdErr = proc.StandardError.ReadToEnd();
+            proc.WaitForExit();
+
+            rs.IsSuccess = proc.ExitCode == 0;
+            return rs;
+        }
+
         public async Task<bool> ExecAsync()
         {
             Log?.AppendLine($"$ git {Args}\n");

src/Commands/Config.cs

@@ -20,6 +20,26 @@ public Config(string repository)
             }
         }
 
+        public Dictionary<string, string> ReadAll()
+        {
+            Args = "config -l";
+
+            var output = ReadToEnd();
+            var rs = new Dictionary<string, string>();
+            if (output.IsSuccess)
+            {
+                var lines = output.StdOut.Split(['\r', '\n'], StringSplitOptions.RemoveEmptyEntries);
+                foreach (var line in lines)
+                {
+                    var parts = line.Split('=', 2);
+                    if (parts.Length == 2)
+                        rs[parts[0]] = parts[1];
+                }
+            }
+
+            return rs;
+        }
+
         public async Task<Dictionary<string, string>> ReadAllAsync()
         {
             Args = "config -l";
@@ -40,6 +60,12 @@ public async Task<Dictionary<string, string>> ReadAllAsync()
             return rs;
         }
 
+        public string Get(string key)
+        {
+            Args = $"config {key}";
+            return ReadToEnd().StdOut.Trim();
+        }
+
         public async Task<string> GetAsync(string key)
         {
             Args = $"config {key}";

src/Commands/IsBareRepository.cs

@@ -11,6 +11,17 @@ public IsBareRepository(string path)
             Args = "rev-parse --is-bare-repository";
         }
 
+        public bool GetResult()
+        {
+            if (!Directory.Exists(Path.Combine(WorkingDirectory, "refs")) ||
+                !Directory.Exists(Path.Combine(WorkingDirectory, "objects")) ||
+                !File.Exists(Path.Combine(WorkingDirectory, "HEAD")))
+                return false;
+
+            var rs = ReadToEnd();
+            return rs.IsSuccess && rs.StdOut.Trim() == "true";
+        }
+
         public async Task<bool> GetResultAsync()
         {
             if (!Directory.Exists(Path.Combine(WorkingDirectory, "refs")) ||

src/Commands/IsConflictResolved.cs

@@ -13,6 +13,11 @@ public IsConflictResolved(string repo, Models.Change change)
             Args = $"diff -a --ignore-cr-at-eol --check {opt}";
         }
 
+        public bool GetResult()
+        {
+            return ReadToEnd().IsSuccess;
+        }
+
         public async Task<bool> GetResultAsync()
         {
             var rs = await ReadToEndAsync().ConfigureAwait(false);

src/Commands/IsLFSFiltered.cs

@@ -20,9 +20,19 @@ public IsLFSFiltered(string repo, string sha, string path)
             RaiseError = false;
         }
 
+        public bool GetResult()
+        {
+            return Parse(ReadToEnd());
+        }
+
         public async Task<bool> GetResultAsync()
         {
             var rs = await ReadToEndAsync().ConfigureAwait(false);
+            return Parse(rs);
+        }
+
+        private bool Parse(Result rs)
+        {
             return rs.IsSuccess && rs.StdOut.Contains("filter\0lfs");
         }
     }

src/Commands/QueryCommitFullMessage.cs

@@ -11,6 +11,12 @@ public QueryCommitFullMessage(string repo, string sha)
             Args = $"show --no-show-signature --format=%B -s {sha}";
         }
 
+        public string GetResult()
+        {
+            var rs = ReadToEnd();
+            return rs.IsSuccess ? rs.StdOut.TrimEnd() : string.Empty;
+        }
+
         public async Task<string> GetResultAsync()
         {
             var rs = await ReadToEndAsync().ConfigureAwait(false);

src/Commands/QueryCurrentBranch.cs

@@ -11,6 +11,11 @@ public QueryCurrentBranch(string repo)
             Args = "branch --show-current";
         }
 
+        public string GetResult()
+        {
+            return ReadToEnd().StdOut.Trim();
+        }
+
         public async Task<string> GetResultAsync()
         {
             var rs = await ReadToEndAsync().ConfigureAwait(false);

src/Commands/QueryGitCommonDir.cs

@@ -1,5 +1,4 @@
 using System.IO;
-using System.Threading.Tasks;
 
 namespace SourceGit.Commands
 {
@@ -11,9 +10,9 @@ public QueryGitCommonDir(string workDir)
             Args = "rev-parse --git-common-dir";
         }
 
-        public async Task<string> GetResultAsync()
+        public string GetResult()
         {
-            var rs = await ReadToEndAsync().ConfigureAwait(false);
+            var rs = ReadToEnd();
             if (!rs.IsSuccess)
                 return null;
 

src/Commands/QueryGitDir.cs

@@ -11,9 +11,19 @@ public QueryGitDir(string workDir)
             Args = "rev-parse --git-dir";
         }
 
+        public string GetResult()
+        {
+            return Parse(ReadToEnd());
+        }
+
         public async Task<string> GetResultAsync()
         {
             var rs = await ReadToEndAsync().ConfigureAwait(false);
+            return Parse(rs);
+        }
+
+        private string Parse(Result rs)
+        {
             if (!rs.IsSuccess)
                 return null;