Merge pull request #9637 from Byron/fix

fix `git fetch` to ignore lock failures just like Git

Author: Byron

Cargo.lock

@@ -28,7 +28,9 @@ test-askpass-path = []
 benches = []
 
 [dependencies]
+tracing.workspace = true
 thiserror.workspace = true
+anyhow.workspace = true
 serde = { workspace = true, optional = true }
 tokio = { workspace = true, optional = true, features = [
     "process",

crates/gitbutler-git/Cargo.toml

@@ -77,8 +77,6 @@ pub unsafe trait GitExecutor {
         let mut args = args.as_ref().to_vec();
 
         args.insert(0, "--no-pager");
-        // TODO(qix-): Test the performance impact of this.
-        args.insert(0, "--no-optional-locks");
         // '-c' arguments must be inserted in reverse order; Git does not support
         // shortflags for '-c' arguments, so they must be separated.
         args.insert(0, "protocol.version=2");

crates/gitbutler-git/src/executor/mod.rs

@@ -5,8 +5,8 @@ mod unix;
 #[cfg(windows)]
 mod windows;
 
+use gix::bstr::ByteSlice;
 use std::{collections::HashMap, path::Path};
-
 use tokio::process::Command;
 
 #[cfg(unix)]
@@ -32,24 +32,6 @@ unsafe impl super::GitExecutor for TokioExecutor {
         let git_exe = gix::path::env::exe_invocation();
         let mut cmd = Command::new(git_exe);
 
-        // Output the command being executed to stderr, for debugging purposes
-        // (only on test configs).
-        #[cfg(any(test, debug_assertions))]
-        {
-            let mut envs_str = String::new();
-            if let Some(envs) = &envs {
-                for (key, value) in envs.iter() {
-                    envs_str.push_str(&format!("{key}={value:?} "));
-                }
-            }
-            let args_str = args
-                .iter()
-                .map(|s| format!("{s:?}"))
-                .collect::<Vec<_>>()
-                .join(" ");
-            eprintln!("env {envs_str} {git_exe:?} {args_str}");
-        }
-
         cmd.kill_on_drop(true);
         cmd.current_dir(cwd);
 
@@ -90,7 +72,9 @@ unsafe impl super::GitExecutor for TokioExecutor {
 
         let output = cmd.output().await?;
 
-        #[cfg(any(test, debug_assertions))]
+        debug_log_sanitised_git_cmd(&mut cmd);
+
+        #[cfg(test)]
         {
             eprintln!(
                 "\n\n GIT STDOUT:\n\n{}\n\nGIT STDERR:\n\n{}\n\nGIT EXIT CODE: {}\n",
@@ -100,6 +84,15 @@ unsafe impl super::GitExecutor for TokioExecutor {
             );
         }
 
+        if !output.status.success() {
+            tracing::error!(
+                ?cmd,
+                stdout = output.stdout.as_bstr().to_string(),
+                stderr = output.stderr.as_bstr().to_string(),
+                "Git invocation failed"
+            );
+        }
+
         Ok((
             output.status.code().unwrap_or(127) as usize,
             String::from_utf8_lossy(&output.stdout).trim().into(),
@@ -129,6 +122,14 @@ unsafe impl super::GitExecutor for TokioExecutor {
         }
     }
 }
+
+fn debug_log_sanitised_git_cmd(cmd: &mut Command) {
+    cmd.env_remove("GITBUTLER_ASKPASS_SECRET")
+        .env_remove("GITBUTLER_ASKPASS_PIPE")
+        .env_remove("SSH_ASKPASS");
+    tracing::debug!(?cmd, "sanitised Git invocation");
+}
+
 #[cfg(test)]
 mod tests {
     use std::time::Duration;

crates/gitbutler-git/src/executor/tokio/mod.rs

@@ -158,8 +158,9 @@ where
         .or_else(|| std::env::var("GIT_SSH").ok())
     {
         Some(v) => v,
-        None => get_core_sshcommand(executor, &repo_path)
-            .await
+        None => get_core_sshcommand(&repo_path)
+            .ok()
+            .flatten()
             .unwrap_or_else(|| "ssh".into()),
     };
 
@@ -507,19 +508,9 @@ where
     Ok(commit_hash)
 }
 
-async fn get_core_sshcommand<E: GitExecutor, P: AsRef<Path>>(
-    executor: &E,
-    cwd: P,
-) -> Option<String> {
-    executor
-        .execute(&["config", "--get", "core.sshCommand"], cwd, None)
-        .await
-        .map(|(status, stdout, _)| {
-            if status != 0 {
-                None
-            } else {
-                Some(stdout.trim().to_string())
-            }
-        })
-        .unwrap_or(None)
+fn get_core_sshcommand(cwd: impl AsRef<Path>) -> anyhow::Result<Option<String>> {
+    Ok(gix::open(cwd.as_ref())?
+        .config_snapshot()
+        .trusted_program(&gix::config::tree::Core::SSH_COMMAND)
+        .map(|program| program.to_string_lossy().into_owned()))
 }