Test for interrupts during git process

crates/uv-git/src/git.rs

@@ -134,6 +134,8 @@ pub(crate) struct GitRemote {
 /// A local clone of a remote repository's database. Multiple [`GitCheckout`]s
 /// can be cloned from a single [`GitDatabase`].
 pub(crate) struct GitDatabase {
+    /// The remote repository where this database is fetched from.
+    remote: GitRemote,
     /// Underlying Git repository instance for this database.
     repo: GitRepository,
 }
@@ -223,7 +225,7 @@ impl GitRemote {
     /// populated the database with the latest version of `reference`, so
     /// return that database and the rev we resolve to.
     pub(crate) fn checkout(
-        &self,
+        self,
         into: &Path,
         db: Option<GitDatabase>,
         reference: &GitReference,
@@ -276,14 +278,17 @@ impl GitRemote {
                 .with_context(|| format!("failed to fetch LFS objects at {rev}"))?;
         }
 
-        Ok((GitDatabase { repo }, rev))
+        Ok((GitDatabase { remote: self, repo }, rev))
     }
 
     /// Creates a [`GitDatabase`] of this remote at `db_path`.
     #[allow(clippy::unused_self)]
     pub(crate) fn db_at(&self, db_path: &Path) -> Result<GitDatabase> {
         let repo = GitRepository::open(db_path)?;
-        Ok(GitDatabase { repo })
+        Ok(GitDatabase {
+            remote: self.clone(),
+            repo,
+        })
     }
 }
 
@@ -300,7 +305,7 @@ impl GitDatabase {
             .filter(GitCheckout::is_fresh)
         {
             Some(co) => co,
-            None => GitCheckout::clone_into(destination, self, rev)?,
+            None => GitCheckout::clone_into(destination, self, rev, self.remote.url())?,
         };
         Ok(checkout)
     }
@@ -336,7 +341,12 @@ impl GitCheckout {
 
     /// Clone a repo for a `revision` into a local path from a `database`.
     /// This is a filesystem-to-filesystem clone.
-    fn clone_into(into: &Path, database: &GitDatabase, revision: GitOid) -> Result<Self> {
+    fn clone_into(
+        into: &Path,
+        database: &GitDatabase,
+        revision: GitOid,
+        original_remote_url: &Url,
+    ) -> Result<Self> {
         let dirname = into.parent().unwrap();
         fs_err::create_dir_all(dirname)?;
         match fs_err::remove_dir_all(into) {
@@ -371,7 +381,7 @@ impl GitCheckout {
 
         let repo = GitRepository::open(into)?;
         let checkout = GitCheckout::new(revision, repo);
-        checkout.reset()?;
+        checkout.update_submodules(original_remote_url)?;
         Ok(checkout)
     }
 
@@ -386,33 +396,56 @@ impl GitCheckout {
         }
     }
 
-    /// This performs `git reset --hard` to the revision of this checkout, with
+    /// This performs `git reset --hard` to the revision of this checkout and updates submodules, with
     /// additional interrupt protection by a dummy file [`CHECKOUT_READY_LOCK`].
     ///
-    /// If we're interrupted while performing a `git reset` (e.g., we die
-    /// because of a signal) Cargo needs to be sure to try to check out this
+    /// If we're interrupted while performing any of the processes in this method (e.g., we die
+    /// because of a signal) uv needs to be sure to try to check out this
     /// repo again on the next go-round.
     ///
-    /// To enable this we have a dummy file in our checkout, [`.cargo-ok`],
-    /// which if present means that the repo has been successfully reset and is
-    /// ready to go. Hence if we start to do a reset, we make sure this file
+    /// To enable this we have a dummy file in our checkout, [`.ok`],
+    /// which if present means that the repo has been successfully checked out and is
+    /// ready to go. Hence if we start to update submodules, we make sure this file
     /// *doesn't* exist, and then once we're done we create the file.
     ///
-    /// [`.cargo-ok`]: CHECKOUT_READY_LOCK
-    fn reset(&self) -> Result<()> {
+    /// [`.ok`]: CHECKOUT_READY_LOCK
+    fn update_submodules(&self, original_remote_url: &Url) -> Result<()> {
         let ok_file = self.repo.path.join(CHECKOUT_READY_LOCK);
         let _ = paths::remove_file(&ok_file);
+
+        // Store the current origin URL
+        let current_origin = ProcessBuilder::new(GIT.as_ref()?)
+            .arg("config")
+            .arg("--get")
+            .arg("remote.origin.url")
+            .cwd(&self.repo.path)
+            .exec_with_output()?;
+
+        let current_origin = String::from_utf8_lossy(&current_origin.stdout)
+            .trim()
+            .to_string();
+
         debug!("Reset {} to {}", self.repo.path.display(), self.revision);
 
-        // Perform the hard reset.
+        // Perform the hard reset (`git reset --hard <rev>`).
         ProcessBuilder::new(GIT.as_ref()?)
             .arg("reset")
             .arg("--hard")
             .arg(self.revision.as_str())
             .cwd(&self.repo.path)
             .exec_with_output()?;
 
-        // Update submodules (`git submodule update --recursive`).
+        // Temporarily set the origin to the original remote URL for submodule update
+        ProcessBuilder::new(GIT.as_ref()?)
+            .arg("remote")
+            .arg("set-url")
+            .arg("origin")
+            .arg(original_remote_url.as_str())
+            .cwd(&self.repo.path)
+            .exec_with_output()
+            .map(drop)?;
+
+        // Update submodules (`git submodule update --recursive --init`).
         ProcessBuilder::new(GIT.as_ref()?)
             .arg("submodule")
             .arg("update")
@@ -422,6 +455,16 @@ impl GitCheckout {
             .exec_with_output()
             .map(drop)?;
 
+        // Set the origin URL back
+        ProcessBuilder::new(GIT.as_ref()?)
+            .arg("remote")
+            .arg("set-url")
+            .arg("origin")
+            .arg(current_origin)
+            .cwd(&self.repo.path)
+            .exec_with_output()
+            .map(drop)?;
+
         paths::create(ok_file)?;
         Ok(())
     }

crates/uv-git/src/source.rs

@@ -103,7 +103,7 @@ impl GitSource {
                     reporter.on_checkout_start(remote.url(), self.git.reference().as_rev())
                 });
 
-                let (db, actual_rev) = remote.checkout(
+                let (db, actual_rev) = remote.clone().checkout(
                     &db_path,
                     db,
                     self.git.reference(),

crates/uv/tests/it/pip_install.rs

@@ -9183,3 +9183,222 @@ fn unsupported_git_scheme() {
     "###
     );
 }
+
+#[test]
+#[cfg(unix)]
+#[cfg(feature = "git")]
+fn test_git_submodule_relative_url() -> Result<()> {
+    let context = TestContext::new("3.12");
+    let temp_dir = &context.temp_dir;
+    let utilities_dir = temp_dir.child("utilities");
+    utilities_dir.create_dir_all()?;
+
+    // Create and initialize the helper repository
+    let helpers_dir = utilities_dir.child("helpers");
+    helpers_dir.create_dir_all()?;
+
+    // Initialize helpers as a git repo
+    Command::new("git")
+        .args(["init"])
+        .current_dir(helpers_dir.path())
+        .output()?;
+
+    // Create a simple file in helpers
+    helpers_dir
+        .child("helper.py")
+        .write_str("def help():\n    return 'I am a helper'")?;
+
+    // Add and commit in helpers
+    Command::new("git")
+        .args(["add", "."])
+        .current_dir(helpers_dir.path())
+        .output()?;
+
+    Command::new("git")
+        .args(["commit", "-m", "Initial helpers commit"])
+        .current_dir(helpers_dir.path())
+        .env("GIT_AUTHOR_NAME", "Test")
+        .env("GIT_AUTHOR_EMAIL", "[email protected]")
+        .env("GIT_COMMITTER_NAME", "Test")
+        .env("GIT_COMMITTER_EMAIL", "[email protected]")
+        .output()?;
+
+    // Create and initialize the main repository
+    let mylib_dir = temp_dir.child("mylib");
+    mylib_dir.create_dir_all()?;
+
+    // Initialize mylib as a git repo
+    Command::new("git")
+        .args(["init"])
+        .current_dir(mylib_dir.path())
+        .output()?;
+
+    // Create a simple setup.py
+    mylib_dir.child("setup.py").write_str(
+        r#"
+from setuptools import setup, find_packages
+
+setup(
+    name="mylib",
+    version="0.1.0",
+    packages=find_packages(),
+)
+"#,
+    )?;
+
+    // Create a simple module file
+    let mylib_package = mylib_dir.child("mylib");
+    mylib_package.create_dir_all()?;
+    mylib_package.child("__init__.py").write_str(
+        r#"
+from .helpers import helper
+
+def main():
+    return f"Hello from mylib, {helper.help()}"
+"#,
+    )?;
+
+    // Set helper as a submodule
+    Command::new("git")
+        .args(["submodule", "add", "../utilities/helpers", "mylib/helpers"])
+        .current_dir(mylib_dir.path())
+        .output()?;
+
+    // Add and commit in mylib
+    Command::new("git")
+        .args(["add", "."])
+        .current_dir(mylib_dir.path())
+        .output()?;
+
+    Command::new("git")
+        .args(["commit", "-m", "Initial mylib commit with submodule"])
+        .current_dir(mylib_dir.path())
+        .env("GIT_AUTHOR_NAME", "Test")
+        .env("GIT_AUTHOR_EMAIL", "[email protected]")
+        .env("GIT_COMMITTER_NAME", "Test")
+        .env("GIT_COMMITTER_EMAIL", "[email protected]")
+        .output()?;
+
+    let mut filters = context.filters();
+    filters.push((r"@[0-9a-f]{40}", "@COMMIT_HASH"));
+
+    uv_snapshot!(filters, context.pip_install()
+        .arg(format!("git+file://{}", mylib_dir.path().display()))
+        // Pass through environment variable to allow file:// URLs in Git subprocesses
+        .env("GIT_ALLOW_PROTOCOL", "file:ext:http:https:ssh"), @r"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+
+    ----- stderr -----
+    Resolved 1 package in [TIME]
+    Prepared 1 package in [TIME]
+    Installed 1 package in [TIME]
+     + mylib==0.1.0 (from git+file://[TEMP_DIR]/mylib@COMMIT_HASH)
+    ");
+
+    Ok(())
+}
+
+#[test]
+#[cfg(unix)] // Unix-only due to signal handling
+#[cfg(feature = "git")]
+fn recovery_after_interruption() {
+    use std::sync::{Arc, Mutex};
+    use std::thread;
+    use std::time::Duration;
+
+    // Create a custom environment marker
+    // This allows the test to run concurrently with other tests
+    const MARKER_ENV: &str = "UV_TEST_INTERRUPT_MARKER";
+    const TEST_REPO: &str = "Choudhry18/uv-test.git"; // Specific test repository
+
+    let context = TestContext::new("3.13");
+
+    // Set up a flag to track when we should simulate an interruption
+    let interrupt_sent = Arc::new(Mutex::new(false));
+
+    // Set up the interruption hook in a separate thread
+    thread::spawn(move || {
+        let max_attempts = 500;
+        let mut attempt = 0;
+
+        // Keep checking until we find our specific git process or exhaust attempts
+        while attempt < max_attempts {
+            attempt += 1;
+
+            thread::sleep(Duration::from_millis(150));
+            // Find git submodule processes
+            if let Ok(output) = Command::new("pgrep").args(["-f", "git submodule"]).output() {
+                let output_str = String::from_utf8_lossy(&output.stdout).into_owned();
+                let pids: Vec<_> = output_str
+                    .trim()
+                    .lines()
+                    .filter(|s| !s.is_empty())
+                    .collect();
+
+                // For each PID, check if it has our environment marker
+                for pid in pids {
+                    if let Ok(output) = Command::new("ps").args(["e", "-p", pid]).output() {
+                        let ps_output = String::from_utf8_lossy(&output.stdout);
+
+                        if ps_output.contains(MARKER_ENV) {
+                            // Send SIGINT only to our specific process
+                            let mut lock = interrupt_sent.lock().unwrap();
+                            *lock = true;
+                            let _ = Command::new("kill").args(["-SIGINT", pid]).output();
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+    });
+    // First attempt should fail due to interruption
+    let output = context
+        .pip_install()
+        .arg("git+https://github.com/Choudhry18/uv-test.git")
+        .env(MARKER_ENV, "1")
+        .output();
+
+    // Check that we got a SIGINT error
+    if let Ok(output) = output {
+        assert!(
+            String::from_utf8_lossy(&output.stderr).contains("SIGINT: terminal interrupt signal")
+        );
+    }
+
+    // Second attempt should succeed
+    uv_snapshot!(context.filters(), context.pip_install()
+        .arg(format!("git+https://github.com/{TEST_REPO}")), @r"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+
+    ----- stderr -----
+    Resolved 1 package in [TIME]
+    Prepared 1 package in [TIME]
+    Installed 1 package in [TIME]
+     + uv-test==0.1.0 (from git+https://github.com/Choudhry18/uv-test.git@043395dfdb441ebea950ea809a0c004c1abbf385)
+    ");
+}
+
+#[test]
+#[cfg(feature = "git")]
+fn remote_git_submodule_relative_url() {
+    const TEST_REPO: &str = "Choudhry18/uv-test.git"; // Specific test repository;
+    let context = TestContext::new("3.13");
+
+    uv_snapshot!(context.filters(), context.pip_install()
+        .arg(format!("git+https://github.com/{TEST_REPO}")), @r"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+
+    ----- stderr -----
+    Resolved 1 package in [TIME]
+    Prepared 1 package in [TIME]
+    Installed 1 package in [TIME]
+     + uv-test==0.1.0 (from git+https://github.com/Choudhry18/uv-test.git@043395dfdb441ebea950ea809a0c004c1abbf385)
+    ");
+}