add more tasks to gather a little more information

Byron · Byron · commit 891a06107883 · 2023-06-17T17:20:56.000+02:00
diff --git a/gitoxide-core/src/corpus/engine.rs b/gitoxide-core/src/corpus/engine.rs
@@ -71,38 +71,37 @@ impl Engine {
         dry_run: bool,
     ) -> anyhow::Result<()> {
         let start = Instant::now();
-        let task_progress = &mut self.state.progress;
-        task_progress.set_name("run");
-        task_progress.init(Some(tasks.len()), gix::progress::count("tasks"));
+        let repo_progress = &mut self.state.progress;
         let threads = gix::parallel::num_threads(threads);
         let db_path = self.con.path().expect("opened from path on disk").to_owned();
-        for (task_id, task) in tasks {
+        'tasks_loop: for (task_id, task) in tasks {
             let task_start = Instant::now();
-            let mut repo_progress = task_progress.add_child(format!("run '{}'", task.short_name));
+            let task_info = format!("run '{}'", task.short_name);
+            repo_progress.set_name(task_info.clone());
+            repo_progress.init(Some(repos.len()), gix::progress::count("repos"));
             if task.execute_exclusive || threads == 1 || dry_run {
                 if dry_run {
-                    task_progress.set_name("WOULD run");
+                    repo_progress.set_name("WOULD run");
                     for repo in &repos {
-                        task_progress.info(format!(
+                        repo_progress.info(format!(
                             "{}",
                             repo.path
                                 .strip_prefix(corpus_path)
                                 .expect("corpus contains repo")
                                 .display()
                         ));
-                        task_progress.inc();
+                        repo_progress.inc();
                     }
-                    task_progress.info(format!("with {} tasks", tasks.len()));
+                    repo_progress.info(format!("with {} tasks", tasks.len()));
                     for (_, task) in tasks {
-                        task_progress.info(format!("task '{}' ({})", task.description, task.short_name))
+                        repo_progress.info(format!("task '{}' ({})", task.description, task.short_name))
                     }
-                    continue;
+                    break 'tasks_loop;
                 }
-                repo_progress.init(Some(repos.len()), gix::progress::count("repos"));
                 let mut run_progress = repo_progress.add_child("set later");
                 let (_guard, current_id) = corpus::trace::override_thread_subscriber(
                     db_path.as_str(),
-                    self.state.trace_to_progress.then(|| task_progress.add_child("trace")),
+                    self.state.trace_to_progress.then(|| repo_progress.add_child("trace")),
                     self.state.reverse_trace_lines,
                 )?;
 
@@ -136,7 +135,9 @@ impl Engine {
                 repo_progress.show_throughput(task_start);
             } else {
                 let counter = repo_progress.counter();
-                let repo_progress = gix::threading::OwnShared::new(gix::threading::Mutable::new(repo_progress));
+                let repo_progress = gix::threading::OwnShared::new(gix::threading::Mutable::new(
+                    repo_progress.add_child("will be changed"),
+                ));
                 gix::parallel::in_parallel_with_slice(
                     &mut repos,
                     Some(threads),
@@ -194,9 +195,9 @@ impl Engine {
                 gix::threading::lock(&repo_progress).show_throughput(task_start);
             }
 
-            task_progress.inc();
+            repo_progress.inc();
         }
-        task_progress.show_throughput(start);
+        repo_progress.show_throughput(start);
         Ok(())
     }
 
diff --git a/gitoxide-core/src/corpus/run.rs b/gitoxide-core/src/corpus/run.rs
@@ -1,5 +1,6 @@
 use crate::corpus;
 use crate::corpus::{Run, Task};
+use crate::pack::verify::Algorithm;
 use std::path::Path;
 use std::sync::atomic::AtomicBool;
 
@@ -32,12 +33,26 @@ pub(crate) trait Execute {
     ) -> anyhow::Result<()>;
 }
 
-pub(crate) static ALL: &[Task] = &[Task {
-    short_name: "OPNR",
-    description: "open repository (isolated)",
-    execute_exclusive: false,
-    execute: &OpenRepo,
-}];
+pub(crate) static ALL: &[Task] = &[
+    Task {
+        short_name: "OPNR",
+        description: "open repository (isolated)",
+        execute_exclusive: false,
+        execute: &OpenRepo,
+    },
+    Task {
+        short_name: "POCN",
+        description: "packed object count",
+        execute_exclusive: false,
+        execute: &CountPackedObjects,
+    },
+    Task {
+        short_name: "VERI",
+        description: "verify object database",
+        execute_exclusive: true,
+        execute: &VerifyOdb,
+    },
+];
 
 struct OpenRepo;
 
@@ -53,3 +68,46 @@ impl Execute for OpenRepo {
         Ok(())
     }
 }
+
+struct CountPackedObjects;
+
+impl Execute for CountPackedObjects {
+    fn execute(
+        &self,
+        repo: &Path,
+        _progress: &mut corpus::engine::ProgressItem,
+        _threads: Option<usize>,
+        _should_interrupt: &AtomicBool,
+    ) -> anyhow::Result<()> {
+        let repo = gix::open_opts(repo, gix::open::Options::isolated())?;
+        repo.objects.packed_object_count()?;
+        Ok(())
+    }
+}
+
+struct VerifyOdb;
+
+impl Execute for VerifyOdb {
+    fn execute(
+        &self,
+        repo: &Path,
+        progress: &mut corpus::engine::ProgressItem,
+        threads: Option<usize>,
+        should_interrupt: &AtomicBool,
+    ) -> anyhow::Result<()> {
+        let repo = gix::open_opts(repo, gix::open::Options::isolated())?;
+        crate::repository::verify::integrity(
+            repo,
+            std::io::sink(),
+            progress,
+            should_interrupt,
+            crate::repository::verify::Context {
+                output_statistics: None,
+                thread_limit: threads,
+                verify_mode: Default::default(),
+                algorithm: Algorithm::LessTime,
+            },
+        )?;
+        Ok(())
+    }
+}
diff --git a/gix-index/src/extension/tree/verify.rs b/gix-index/src/extension/tree/verify.rs
@@ -111,6 +111,7 @@ impl Tree {
             }
             Ok(entries.into())
         }
+        let _span = gix_features::trace::coarse!("gix_index::extension::Tree::verify()");
 
         if !self.name.is_empty() {
             return Err(Error::RootWithName {
diff --git a/gix-index/src/file/verify.rs b/gix-index/src/file/verify.rs
@@ -23,6 +23,7 @@ pub use error::Error;
 impl File {
     /// Verify the integrity of the index to assure its consistency.
     pub fn verify_integrity(&self) -> Result<(), Error> {
+        let _span = gix_features::trace::coarse!("gix_index::File::verify_integrity()");
         let checksum = self.checksum.ok_or(Error::NoChecksum)?;
         let num_bytes_to_hash = self.path.metadata()?.len() - checksum.as_bytes().len() as u64;
         let should_interrupt = AtomicBool::new(false);
diff --git a/gix-index/src/verify.rs b/gix-index/src/verify.rs
@@ -42,6 +42,7 @@ pub mod extensions {
 impl State {
     /// Assure our entries are consistent.
     pub fn verify_entries(&self) -> Result<(), entries::Error> {
+        let _span = gix_features::trace::coarse!("gix_index::File::verify_entries()");
         let mut previous = None::<&crate::Entry>;
         for (idx, entry) in self.entries.iter().enumerate() {
             if let Some(prev) = previous {
diff --git a/gix-odb/src/store_impls/dynamic/verify.rs b/gix-odb/src/store_impls/dynamic/verify.rs

Original file line number	Diff line number	Diff line change
`@@ -111,6 +111,7 @@ impl Tree {`
`111`	`111`	`}`
`112`	`112`	`Ok(entries.into())`
`113`	`113`	`}`
	`114`	`+ let _span = gix_features::trace::coarse!("gix_index::extension::Tree::verify()");`
`114`	`115`
`115`	`116`	`if !self.name.is_empty() {`
`116`	`117`	`return Err(Error::RootWithName {`