Allow configuration of interrupts in status iter

Otherwise users might not have too much delay until an interrupt is possible,
wasting a lot of time.

Author: Byron

gix/src/status/index_worktree.rs

@@ -1,4 +1,5 @@
 use crate::bstr::{BStr, BString};
+use crate::status::OwnedOrStaticAtomic;
 use crate::{config, Repository};
 use gix_status::index_as_worktree::traits::{CompareBlobs, SubmoduleStatus};
 use std::sync::atomic::AtomicBool;
@@ -284,6 +285,10 @@ mod submodule_status {
 /// It's a crutch that is just there to make single-threaded applications possible at all, as it's not really an iterator
 /// anymore. If this matters, better run [Repository::index_worktree_status()] by hand as it provides all control one would need,
 /// just not as an iterator.
+///
+/// Also, even with `parallel` set, the first call to `next()` will block until there is an item available, without a chance
+/// to interrupt unless [`status::Platform::should_interrupt_*()`](crate::status::Platform::should_interrupt_shared()) was
+/// configured.
 pub struct Iter {
     #[cfg(feature = "parallel")]
     #[allow(clippy::type_complexity)]
@@ -292,7 +297,7 @@ pub struct Iter {
         std::thread::JoinHandle<Result<iter::Outcome, crate::status::index_worktree::Error>>,
     )>,
     #[cfg(feature = "parallel")]
-    should_interrupt: std::sync::Arc<AtomicBool>,
+    should_interrupt: OwnedOrStaticAtomic,
     /// Without parallelization, the iterator has to buffer all changes in advance.
     #[cfg(not(feature = "parallel"))]
     items: std::vec::IntoIter<iter::Item>,
@@ -307,10 +312,8 @@ pub mod iter {
     use crate::bstr::BString;
     use crate::config::cache::util::ApplyLeniencyDefault;
     use crate::status::index_worktree::{iter, BuiltinSubmoduleStatus};
-    use crate::status::{index_worktree, Platform};
+    use crate::status::{index_worktree, OwnedOrStaticAtomic, Platform};
     use crate::worktree::IndexPersistedOrInMemory;
-    use std::sync::atomic::AtomicBool;
-    use std::sync::Arc;
 
     pub(super) enum ApplyChange {
         SetSizeToZero,
@@ -564,7 +567,6 @@ pub mod iter {
                 Some(index) => index,
             };
 
-            let should_interrupt = Arc::new(AtomicBool::default());
             let skip_hash = self
                 .repo
                 .config
@@ -574,6 +576,7 @@ pub mod iter {
                 .transpose()
                 .with_lenient_default(self.repo.config.lenient_config)?
                 .unwrap_or_default();
+            let should_interrupt = self.should_interrupt.clone().unwrap_or_default();
             let submodule = BuiltinSubmoduleStatus::new(self.repo.clone().into_sync(), self.submodules)?;
             #[cfg(feature = "parallel")]
             {
@@ -726,10 +729,27 @@ pub mod iter {
     #[cfg(feature = "parallel")]
     impl Drop for super::Iter {
         fn drop(&mut self) {
-            self.should_interrupt.store(true, std::sync::atomic::Ordering::Relaxed);
-            // Allow to temporarily 'leak' the producer to not block on drop, nobody
-            // is interested in the result of the thread anymore.
-            drop(self.rx_and_join.take());
+            let Some((rx, handle)) = self.rx_and_join.take() else {
+                return;
+            };
+            let prev = self.should_interrupt.swap(true, std::sync::atomic::Ordering::Relaxed);
+            let undo = match &self.should_interrupt {
+                OwnedOrStaticAtomic::Shared(flag) => *flag,
+                OwnedOrStaticAtomic::Owned { flag, private: false } => flag.as_ref(),
+                OwnedOrStaticAtomic::Owned { private: true, .. } => {
+                    // Leak the handle to let it shut down in the background, so drop returns more quickly.
+                    drop((rx, handle));
+                    return;
+                }
+            };
+            // Wait until there is time to respond before we undo the change.
+            handle.join().ok();
+            undo.fetch_update(
+                std::sync::atomic::Ordering::SeqCst,
+                std::sync::atomic::Ordering::SeqCst,
+                |current| current.then_some(prev),
+            )
+            .ok();
         }
     }
 

gix/src/status/mod.rs

@@ -1,5 +1,8 @@
 use crate::{config, Repository};
 pub use gix_status as plumbing;
+use std::ops::Deref;
+use std::sync::atomic::AtomicBool;
+use std::sync::Arc;
 
 /// A structure to hold options configuring the status request, which can then be turned into an iterator.
 pub struct Platform<'repo, Progress>
@@ -11,6 +14,33 @@ where
     index: Option<crate::worktree::IndexPersistedOrInMemory>,
     submodules: Submodule,
     index_worktree_options: index_worktree::Options,
+    should_interrupt: Option<OwnedOrStaticAtomic>,
+}
+
+#[derive(Clone)]
+enum OwnedOrStaticAtomic {
+    Owned { flag: Arc<AtomicBool>, private: bool },
+    Shared(&'static AtomicBool),
+}
+
+impl Default for OwnedOrStaticAtomic {
+    fn default() -> Self {
+        OwnedOrStaticAtomic::Owned {
+            flag: Arc::new(AtomicBool::default()),
+            private: true,
+        }
+    }
+}
+
+impl Deref for OwnedOrStaticAtomic {
+    type Target = std::sync::atomic::AtomicBool;
+
+    fn deref(&self) -> &Self::Target {
+        match self {
+            OwnedOrStaticAtomic::Owned { flag, .. } => flag,
+            OwnedOrStaticAtomic::Shared(flag) => flag,
+        }
+    }
 }
 
 /// How to obtain a submodule's status.
@@ -71,6 +101,7 @@ impl Repository {
             progress,
             index: None,
             submodules: Submodule::default(),
+            should_interrupt: None,
             index_worktree_options: index_worktree::Options {
                 sorting: None,
                 dirwalk_options: Some(self.dirwalk_options()?),

gix/src/status/platform.rs

@@ -1,4 +1,5 @@
-use crate::status::{index_worktree, Platform, Submodule};
+use crate::status::{index_worktree, OwnedOrStaticAtomic, Platform, Submodule};
+use std::sync::atomic::AtomicBool;
 
 /// Builder
 impl<'repo, Progress> Platform<'repo, Progress>
@@ -16,6 +17,26 @@ where
         self
     }
 
+    /// Set the interrupt flag to `should_interrupt`, which typically is an application-wide flag
+    /// that is ultimately controlled by user interrupts.
+    ///
+    /// If it is `true`, the iteration will stop immediately.
+    pub fn should_interrupt_shared(mut self, should_interrupt: &'static AtomicBool) -> Self {
+        self.should_interrupt = Some(OwnedOrStaticAtomic::Shared(should_interrupt));
+        self
+    }
+
+    /// Set the interrupt flag to `should_interrupt`, as controlled by the caller.
+    ///
+    /// If it is `true`, the iteration will stop immediately.
+    pub fn should_interrupt_owned(mut self, should_interrupt: std::sync::Arc<AtomicBool>) -> Self {
+        self.should_interrupt = Some(OwnedOrStaticAtomic::Owned {
+            flag: should_interrupt,
+            private: false,
+        });
+        self
+    }
+
     /// Configure how the `submodule_status` is obtained when looking at submodules that are still mentioned in the index.
     // If `None` is given, no submodule status check is performed.
     pub fn index_worktree_submodules(mut self, submodules: impl Into<Option<Submodule>>) -> Self {