comparison rust/hg-core/src/dirstate_tree/status.rs @ 47409:0ef8231e413f

dirstate-v2: Store a hash of ignore patterns (.hgignore)

Later, this help extend `read_dir` caching to directories that contain ignored
files (but no unknown files). Such cache must be invalidated when ignore patterns
change since a formerly-ignored file might become unknown.

This helps the default configuration of `hg status` where unknown files must
be listed, but ignored files are not.

Differential Revision: https://phab.mercurial-scm.org/D10836

47408:7954ee2d7cf7

use crate::PatternFileWarning;
use crate::StatusError;
use crate::StatusOptions;
use micro_timer::timed;
use rayon::prelude::*;
use std::borrow::Cow;
use std::io;
use std::path::Path;
use std::path::PathBuf;
use std::sync::Mutex;

    matcher: &(dyn Matcher + Sync),
    root_dir: PathBuf,
    ignore_files: Vec<PathBuf>,
    options: StatusOptions,
) -> Result<(DirstateStatus<'on_disk>, Vec<PatternFileWarning>), StatusError> {
    let (ignore_fn, warnings): (IgnoreFnType, _) =
        if options.list_ignored || options.list_unknown {
            get_ignore_function(ignore_files, &root_dir)?
        } else {
            (Box::new(|&_| true), vec![])
        };

    let common = StatusCommon {
        dmap,
        options,
        matcher,
        ignore_fn,
        outcome: Default::default(),
        cached_directory_mtimes_to_add: Default::default(),
        filesystem_time_at_status_start: filesystem_now(&root_dir).ok(),
    };
    let is_at_repo_root = true;
    let hg_path = &BorrowedPath::OnDisk(HgPath::new(""));
    let has_ignored_ancestor = false;

        root_dir_metadata,
        root_cached_mtime,
        is_at_repo_root,
    )?;
    let mut outcome = common.outcome.into_inner().unwrap();
    let to_add = common.cached_directory_mtimes_to_add.into_inner().unwrap();
    outcome.dirty = !to_add.is_empty();
    for (path, mtime) in &to_add {
        let node = DirstateMap::get_or_insert_node(
            dmap.on_disk,
            &mut dmap.root,
            path,
            WithBasename::to_cow_owned,

            NodeData::CachedDirectory { .. } | NodeData::None => {
                node.data = NodeData::CachedDirectory { mtime: *mtime }
            }
        }
    }
    Ok((outcome, warnings))
}

/// Bag of random things needed by various parts of the algorithm. Reduces the
/// number of parameters passed to functions.

    dmap: &'tree DirstateMap<'on_disk>,
    options: StatusOptions,
    matcher: &'a (dyn Matcher + Sync),
    ignore_fn: IgnoreFnType<'a>,
    outcome: Mutex<DirstateStatus<'on_disk>>,
    cached_directory_mtimes_to_add:
        Mutex<Vec<(Cow<'on_disk, HgPath>, Timestamp)>>,

    /// The current time at the start of the `status()` algorithm, as measured
    /// and possibly truncated by the filesystem.
    filesystem_time_at_status_start: Option<SystemTime>,
}

                    let cached = dirstate_node.cached_directory_mtime();
                    if cached != Some(&timestamp) {
                        let hg_path = dirstate_node
                            .full_path_borrowed(self.dmap.on_disk)?
                            .detach_from_tree();
                        self.cached_directory_mtimes_to_add
                            .lock()
                            .unwrap()
                            .push((hg_path, timestamp))
                    }
                }

47409:0ef8231e413f

use crate::PatternFileWarning;
use crate::StatusError;
use crate::StatusOptions;
use micro_timer::timed;
use rayon::prelude::*;
use sha1::{Digest, Sha1};
use std::borrow::Cow;
use std::io;
use std::path::Path;
use std::path::PathBuf;
use std::sync::Mutex;

    matcher: &(dyn Matcher + Sync),
    root_dir: PathBuf,
    ignore_files: Vec<PathBuf>,
    options: StatusOptions,
) -> Result<(DirstateStatus<'on_disk>, Vec<PatternFileWarning>), StatusError> {
    let (ignore_fn, warnings, patterns_changed): (IgnoreFnType, _, _) =
        if options.list_ignored || options.list_unknown {
            let mut hasher = Sha1::new();
            let (ignore_fn, warnings) = get_ignore_function(
                ignore_files,
                &root_dir,
                &mut |pattern_bytes| hasher.update(pattern_bytes),
            )?;
            let new_hash = *hasher.finalize().as_ref();
            let changed = new_hash != dmap.ignore_patterns_hash;
            dmap.ignore_patterns_hash = new_hash;
            (ignore_fn, warnings, Some(changed))
        } else {
            (Box::new(|&_| true), vec![], None)
        };

    let common = StatusCommon {
        dmap,
        options,
        matcher,
        ignore_fn,
        outcome: Default::default(),
        ignore_patterns_have_changed: patterns_changed,
        new_cachable_directories: Default::default(),
        filesystem_time_at_status_start: filesystem_now(&root_dir).ok(),
    };
    let is_at_repo_root = true;
    let hg_path = &BorrowedPath::OnDisk(HgPath::new(""));
    let has_ignored_ancestor = false;

        root_dir_metadata,
        root_cached_mtime,
        is_at_repo_root,
    )?;
    let mut outcome = common.outcome.into_inner().unwrap();
    let new_cachable = common.new_cachable_directories.into_inner().unwrap();

    outcome.dirty = common.ignore_patterns_have_changed == Some(true)
        || !new_cachable.is_empty();

    for (path, mtime) in &new_cachable {
        let node = DirstateMap::get_or_insert_node(
            dmap.on_disk,
            &mut dmap.root,
            path,
            WithBasename::to_cow_owned,

            NodeData::CachedDirectory { .. } | NodeData::None => {
                node.data = NodeData::CachedDirectory { mtime: *mtime }
            }
        }
    }

    Ok((outcome, warnings))
}

/// Bag of random things needed by various parts of the algorithm. Reduces the
/// number of parameters passed to functions.

    dmap: &'tree DirstateMap<'on_disk>,
    options: StatusOptions,
    matcher: &'a (dyn Matcher + Sync),
    ignore_fn: IgnoreFnType<'a>,
    outcome: Mutex<DirstateStatus<'on_disk>>,
    new_cachable_directories: Mutex<Vec<(Cow<'on_disk, HgPath>, Timestamp)>>,

    /// Whether ignore files like `.hgignore` have changed since the previous
    /// time a `status()` call wrote their hash to the dirstate. `None` means
    /// we don’t know as this run doesn’t list either ignored or uknown files
    /// and therefore isn’t reading `.hgignore`.
    ignore_patterns_have_changed: Option<bool>,

    /// The current time at the start of the `status()` algorithm, as measured
    /// and possibly truncated by the filesystem.
    filesystem_time_at_status_start: Option<SystemTime>,
}

                    let cached = dirstate_node.cached_directory_mtime();
                    if cached != Some(&timestamp) {
                        let hg_path = dirstate_node
                            .full_path_borrowed(self.dmap.on_disk)?
                            .detach_from_tree();
                        self.new_cachable_directories
                            .lock()
                            .unwrap()
                            .push((hg_path, timestamp))
                    }
                }