Add a dry_run mode to LockedWorkingCopy snapshot method.

At Google, we are implementing a tool that needs to know the state of the jj repo constantly. Always snapshotting and updating .jj/working_copy/checkout increases the likelihood of write races. To fix this, I'd like to add a --dry-run flag to SnapshotOptions to make it not update the working copy. This is similar to the request in jj-vcs#2562

Implement

Author: kevincliao

cli/src/cli_util.rs

@@ -1409,6 +1409,7 @@ to the current parents may contain changes from multiple commits.
             start_tracking_matcher,
             max_new_file_size,
             conflict_marker_style,
+            dry_run: false,
         })
     }
 

cli/src/merge_tools/diff_working_copies.rs

@@ -299,6 +299,7 @@ diff editing in mind and be a little inaccurate.
             start_tracking_matcher: &EverythingMatcher,
             max_new_file_size: u64::MAX,
             conflict_marker_style,
+            dry_run: false,
         })?;
         Ok(output_tree_state.current_tree_id().clone())
     }

lib/src/local_working_copy.rs

@@ -966,8 +966,8 @@ impl TreeState {
             start_tracking_matcher,
             max_new_file_size,
             conflict_marker_style,
+            dry_run,
         } = options;
-
         let sparse_matcher = self.sparse_matcher();
 
         let fsmonitor_clock_needs_save = *fsmonitor_settings != FsmonitorSettings::None;
@@ -985,6 +985,15 @@ impl TreeState {
         if matcher.visit(RepoPath::root()).is_nothing() {
             // No need to load the current tree, set up channels, etc.
             self.watchman_clock = watchman_clock;
+            if dry_run {
+                return Ok((
+                    false,
+                    SnapshotStats {
+                        dry_run_tree_id: Some(self.tree_id.clone()),
+                        ..SnapshotStats::default()
+                    },
+                ));
+            }
             return Ok((is_dirty, SnapshotStats::default()));
         }
 
@@ -1024,8 +1033,9 @@ impl TreeState {
             snapshotter.into_result()
         })?;
 
-        let stats = SnapshotStats {
+        let mut stats = SnapshotStats {
             untracked_paths: untracked_paths_rx.into_iter().collect(),
+            dry_run_tree_id: None,
         };
         let mut tree_builder = MergedTreeBuilder::new(self.tree_id.clone());
         trace_span!("process tree entries").in_scope(|| {
@@ -1041,6 +1051,18 @@ impl TreeState {
             }
             deleted_files
         });
+        trace_span!("write tree").in_scope(|| {
+            let new_tree_id = tree_builder.write_tree(&self.store).unwrap();
+            if dry_run {
+                stats.dry_run_tree_id = Some(new_tree_id);
+            } else {
+                is_dirty |= new_tree_id != self.tree_id;
+                self.tree_id = new_tree_id;
+            }
+        });
+        if dry_run {
+            return Ok((false, stats));
+        }
         trace_span!("process file states").in_scope(|| {
             let changed_file_states = file_states_rx
                 .iter()
@@ -1050,11 +1072,6 @@ impl TreeState {
             self.file_states
                 .merge_in(changed_file_states, &deleted_files);
         });
-        trace_span!("write tree").in_scope(|| {
-            let new_tree_id = tree_builder.write_tree(&self.store).unwrap();
-            is_dirty |= new_tree_id != self.tree_id;
-            self.tree_id = new_tree_id;
-        });
         if cfg!(debug_assertions) {
             let tree = self.current_tree().unwrap();
             let tree_paths: HashSet<_> = tree

lib/src/working_copy.rs

@@ -222,6 +222,9 @@ pub struct SnapshotOptions<'a> {
     pub max_new_file_size: u64,
     /// Expected conflict marker style for checking for changed files.
     pub conflict_marker_style: ConflictMarkerStyle,
+    /// If true, skip any updates to the working copy metadata files when
+    /// snapshotting.
+    pub dry_run: bool,
 }
 
 impl SnapshotOptions<'_> {
@@ -234,6 +237,7 @@ impl SnapshotOptions<'_> {
             start_tracking_matcher: &EverythingMatcher,
             max_new_file_size: u64::MAX,
             conflict_marker_style: ConflictMarkerStyle::default(),
+            dry_run: false,
         }
     }
 }
@@ -246,6 +250,8 @@ pub type SnapshotProgress<'a> = dyn Fn(&RepoPath) + 'a + Sync;
 pub struct SnapshotStats {
     /// List of new (previously untracked) files which are still untracked.
     pub untracked_paths: BTreeMap<RepoPathBuf, UntrackedReason>,
+    /// The tree id generated in dry_run mode. Set iff dry_run is enabled.
+    pub dry_run_tree_id: Option<MergedTreeId>,
 }
 
 /// Reason why the new path isn't tracked.

lib/tests/test_local_working_copy.rs

@@ -838,6 +838,33 @@ fn test_snapshot_file_directory_transition() {
     assert_eq!(new_tree.id(), tree1.id());
 }
 
+#[test]
+fn test_snapshot_dry_run() {
+    let mut test_workspace = TestWorkspace::init();
+    let workspace_root = test_workspace.workspace.workspace_root().to_owned();
+    let file_path = workspace_root.join("file");
+    std::fs::write(&file_path, "contents".as_bytes()).unwrap();
+    let repo = &test_workspace.repo;
+    let mut locked_ws = test_workspace
+        .workspace
+        .start_working_copy_mutation()
+        .unwrap();
+    let (new_tree_id, stats) = locked_ws
+        .locked_wc()
+        .snapshot(&SnapshotOptions {
+            dry_run: true,
+            ..SnapshotOptions::empty_for_test()
+        })
+        .unwrap();
+    assert_eq!(new_tree_id, repo.store().empty_merged_tree_id());
+    assert_ne!(
+        stats
+            .dry_run_tree_id
+            .expect("dry_run_tree_id must be set in dry_run mode"),
+        repo.store().empty_merged_tree_id()
+    );
+}
+
 #[test]
 fn test_materialize_snapshot_conflicted_files() {
     let mut test_workspace = TestWorkspace::init();