This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9320

rust-status: don't bubble up os errors, translate them to bad matches
ClosedPublic

Authored by Alphare on Nov 16 2020, 11:02 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG5c736ba5dc27: rust-status: don't bubble up os errors, translate them to bad matches
Summary

In the rare cases when either the OS/filesystem throws an error on an otherwise
valid action, or because a path is not representable on the filesystem, or
because of concurrent actions in the filesystem, we want to warn the user about
said path instead of bubbling up the error, causing an exception to be raised
in the Python layer.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

Alphare created this revision.Nov 16 2020, 11:02 AM
Alphare added a commit: rHG5c736ba5dc27: rust-status: don't bubble up os errors, translate them to bad matches.Nov 18 2020, 6:06 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG5c736ba5dc27: rust-status: don't bubble up os errors, translate them to bad matches (authored by Alphare). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 23546

rust/hg-core/src/dirstate/status.rs

/// We have a good mix of owned (from directory traversal) and borrowed (from /// We have a good mix of owned (from directory traversal) and borrowed (from
/// the dirstate/explicit) paths, this comes up a lot. /// the dirstate/explicit) paths, this comes up a lot.
pub type HgPathCow<'a> = Cow<'a, HgPath>; pub type HgPathCow<'a> = Cow<'a, HgPath>;
/// A path with its computed ``Dispatch`` information /// A path with its computed ``Dispatch`` information
type DispatchedPath<'a> = (HgPathCow<'a>, Dispatch); type DispatchedPath<'a> = (HgPathCow<'a>, Dispatch);
/// The conversion from `HgPath` to a real fs path failed.
/// `22` is the error code for "Invalid argument"
const INVALID_PATH_DISPATCH: Dispatch = Dispatch::Bad(BadMatch::OsError(22));
/// Dates and times that are outside the 31-bit signed range are compared /// Dates and times that are outside the 31-bit signed range are compared
/// modulo 2^31. This should prevent hg from behaving badly with very large /// modulo 2^31. This should prevent hg from behaving badly with very large
/// files or corrupt dates while still having a high probability of detecting /// files or corrupt dates while still having a high probability of detecting
/// changes. (issue2608) /// changes. (issue2608)
/// TODO I haven't found a way of having `b` be `Into<i32>`, since `From<u64>` /// TODO I haven't found a way of having `b` be `Into<i32>`, since `From<u64>`
/// is not defined for `i32`, and there is no `As` trait. This forces the /// is not defined for `i32`, and there is no `As` trait. This forces the
/// caller to cast `b` as `i32`. /// caller to cast `b` as `i32`.
fn mod_compare(a: i32, b: i32) -> bool { fn mod_compare(a: i32, b: i32) -> bool {
} }
// File was removed, everything is normal // File was removed, everything is normal
EntryState::Removed => Dispatch::Removed, EntryState::Removed => Dispatch::Removed,
// File is unknown to Mercurial, everything is normal // File is unknown to Mercurial, everything is normal
EntryState::Unknown => Dispatch::Unknown, EntryState::Unknown => Dispatch::Unknown,
} }
} }
fn dispatch_os_error(e: &std::io::Error) -> Dispatch {
Dispatch::Bad(BadMatch::OsError(
e.raw_os_error().expect("expected real OS error"),
))
}
lazy_static! { lazy_static! {
static ref DEFAULT_WORK: HashSet<&'static HgPath> = { static ref DEFAULT_WORK: HashSet<&'static HgPath> = {
let mut h = HashSet::new(); let mut h = HashSet::new();
h.insert(HgPath::new(b"")); h.insert(HgPath::new(b""));
h h
}; };
} }
pub fn walk_explicit( pub fn walk_explicit(
&self, &self,
traversed_sender: crossbeam::Sender<HgPathBuf>, traversed_sender: crossbeam::Sender<HgPathBuf>,
) -> (Vec<DispatchedPath<'a>>, Vec<DispatchedPath<'a>>) { ) -> (Vec<DispatchedPath<'a>>, Vec<DispatchedPath<'a>>) {
self.matcher self.matcher
.file_set() .file_set()
.unwrap_or(&DEFAULT_WORK) .unwrap_or(&DEFAULT_WORK)
.par_iter() .par_iter()
.map(|&filename| -> Option<IoResult<_>> { .flat_map(|&filename| -> Option<_> {
// TODO normalization // TODO normalization
let normalized = filename; let normalized = filename;
let buf = match hg_path_to_path_buf(normalized) { let buf = match hg_path_to_path_buf(normalized) {
Ok(x) => x, Ok(x) => x,
Err(e) => return Some(Err(e.into())), Err(_) => {
return Some((
Cow::Borrowed(normalized),
INVALID_PATH_DISPATCH,
))
}
}; };
let target = self.root_dir.join(buf); let target = self.root_dir.join(buf);
let st = target.symlink_metadata(); let st = target.symlink_metadata();
let in_dmap = self.dmap.get(normalized); let in_dmap = self.dmap.get(normalized);
match st { match st {
Ok(meta) => { Ok(meta) => {
let file_type = meta.file_type(); let file_type = meta.file_type();
return if file_type.is_file() || file_type.is_symlink() return if file_type.is_file() || file_type.is_symlink()
{ {
if let Some(entry) = in_dmap { if let Some(entry) = in_dmap {
return Some(Ok(( return Some((
Cow::Borrowed(normalized), Cow::Borrowed(normalized),
dispatch_found( dispatch_found(
&normalized, &normalized,
*entry, *entry,
HgMetadata::from_metadata(meta), HgMetadata::from_metadata(meta),
&self.dmap.copy_map, &self.dmap.copy_map,
self.options, self.options,
), ),
))); ));
} }
Some(Ok(( Some((
Cow::Borrowed(normalized), Cow::Borrowed(normalized),
Dispatch::Unknown, Dispatch::Unknown,
))) ))
} else if file_type.is_dir() { } else if file_type.is_dir() {
if self.options.collect_traversed_dirs { if self.options.collect_traversed_dirs {
traversed_sender traversed_sender
.send(normalized.to_owned()) .send(normalized.to_owned())
.expect("receiver should outlive sender"); .expect("receiver should outlive sender");
} }
Some(Ok(( Some((
Cow::Borrowed(normalized), Cow::Borrowed(normalized),
Dispatch::Directory { Dispatch::Directory {
was_file: in_dmap.is_some(), was_file: in_dmap.is_some(),
}, },
))) ))
} else { } else {
Some(Ok(( Some((
Cow::Borrowed(normalized), Cow::Borrowed(normalized),
Dispatch::Bad(BadMatch::BadType( Dispatch::Bad(BadMatch::BadType(
// TODO do more than unknown // TODO do more than unknown
// Support for all `BadType` variant // Support for all `BadType` variant
// varies greatly between platforms. // varies greatly between platforms.
// So far, no tests check the type and // So far, no tests check the type and
// this should be good enough for most // this should be good enough for most
// users. // users.
BadType::Unknown, BadType::Unknown,
)), )),
))) ))
}; };
} }
Err(_) => { Err(_) => {
if let Some(entry) = in_dmap { if let Some(entry) = in_dmap {
return Some(Ok(( return Some((
Cow::Borrowed(normalized), Cow::Borrowed(normalized),
dispatch_missing(entry.state), dispatch_missing(entry.state),
))); ));
} }
} }
}; };
None None
}) })
.flatten()
.filter_map(Result::ok)
.partition(|(_, dispatch)| match dispatch { .partition(|(_, dispatch)| match dispatch {
Dispatch::Directory { .. } => true, Dispatch::Directory { .. } => true,
_ => false, _ => false,
}) })
} }
/// Walk the working directory recursively to look for changes compared to /// Walk the working directory recursively to look for changes compared to
/// the current `DirstateMap`. /// the current `DirstateMap`.
/// ///
/// This takes a mutable reference to the results to account for the /// This takes a mutable reference to the results to account for the
/// `extend` in timings /// `extend` in timings
#[timed] #[timed]
pub fn traverse( pub fn traverse(
&self, &self,
path: impl AsRef<HgPath>, path: impl AsRef<HgPath>,
old_results: &FastHashMap<HgPathCow<'a>, Dispatch>, old_results: &FastHashMap<HgPathCow<'a>, Dispatch>,
results: &mut Vec<DispatchedPath<'a>>, results: &mut Vec<DispatchedPath<'a>>,
traversed_sender: crossbeam::Sender<HgPathBuf>, traversed_sender: crossbeam::Sender<HgPathBuf>,
) -> IoResult<()> { ) {
// The traversal is done in parallel, so use a channel to gather // The traversal is done in parallel, so use a channel to gather
// entries. `crossbeam::Sender` is `Sync`, while `mpsc::Sender` // entries. `crossbeam::Sender` is `Sync`, while `mpsc::Sender`
// is not. // is not.
let (files_transmitter, files_receiver) = let (files_transmitter, files_receiver) =
crossbeam::channel::unbounded(); crossbeam::channel::unbounded();
self.traverse_dir( self.traverse_dir(
&files_transmitter, &files_transmitter,
path, path,
&old_results, &old_results,
traversed_sender, traversed_sender,
)?; );
// Disconnect the channel so the receiver stops waiting // Disconnect the channel so the receiver stops waiting
drop(files_transmitter); drop(files_transmitter);
// TODO don't collect. Find a way of replicating the behavior of let new_results = files_receiver
// `itertools::process_results`, but for `rayon::ParallelIterator`
let new_results: IoResult<Vec<(Cow<HgPath>, Dispatch)>> =
files_receiver
.into_iter() .into_iter()
.map(|item| { .par_bridge()
let (f, d) = item?; .map(|(f, d)| (Cow::Owned(f), d));
Ok((Cow::Owned(f), d))
})
.collect();
results.par_extend(new_results?);
Ok(()) results.par_extend(new_results);
} }
/// Dispatch a single entry (file, folder, symlink...) found during /// Dispatch a single entry (file, folder, symlink...) found during
/// `traverse`. If the entry is a folder that needs to be traversed, it /// `traverse`. If the entry is a folder that needs to be traversed, it
/// will be handled in a separate thread. /// will be handled in a separate thread.
fn handle_traversed_entry<'b>( fn handle_traversed_entry<'b>(
&'a self, &'a self,
scope: &rayon::Scope<'b>, scope: &rayon::Scope<'b>,
files_sender: &'b crossbeam::Sender<IoResult<(HgPathBuf, Dispatch)>>, files_sender: &'b crossbeam::Sender<(HgPathBuf, Dispatch)>,
old_results: &'a FastHashMap<Cow<HgPath>, Dispatch>, old_results: &'a FastHashMap<Cow<HgPath>, Dispatch>,
filename: HgPathBuf, filename: HgPathBuf,
dir_entry: DirEntry, dir_entry: DirEntry,
traversed_sender: crossbeam::Sender<HgPathBuf>, traversed_sender: crossbeam::Sender<HgPathBuf>,
) -> IoResult<()> ) -> IoResult<()>
where where
'a: 'b, 'a: 'b,
{ {
); );
} else if file_type.is_file() || file_type.is_symlink() { } else if file_type.is_file() || file_type.is_symlink() {
if let Some(entry) = entry_option { if let Some(entry) = entry_option {
if self.matcher.matches_everything() if self.matcher.matches_everything()
|| self.matcher.matches(&filename) || self.matcher.matches(&filename)
{ {
let metadata = dir_entry.metadata()?; let metadata = dir_entry.metadata()?;
files_sender files_sender
.send(Ok(( .send((
filename.to_owned(), filename.to_owned(),
dispatch_found( dispatch_found(
&filename, &filename,
*entry, *entry,
HgMetadata::from_metadata(metadata), HgMetadata::from_metadata(metadata),
&self.dmap.copy_map, &self.dmap.copy_map,
self.options, self.options,
), ),
))) ))
.unwrap(); .unwrap();
} }
} else if (self.matcher.matches_everything() } else if (self.matcher.matches_everything()
|| self.matcher.matches(&filename)) || self.matcher.matches(&filename))
&& !self.is_ignored(&filename) && !self.is_ignored(&filename)
{ {
if (self.options.list_ignored if (self.options.list_ignored
|| self.matcher.exact_match(&filename)) || self.matcher.exact_match(&filename))
&& self.dir_ignore(&filename) && self.dir_ignore(&filename)
{ {
if self.options.list_ignored { if self.options.list_ignored {
files_sender files_sender
.send(Ok((filename.to_owned(), Dispatch::Ignored))) .send((filename.to_owned(), Dispatch::Ignored))
.unwrap(); .unwrap();
} }
} else if self.options.list_unknown { } else if self.options.list_unknown {
files_sender files_sender
.send(Ok((filename.to_owned(), Dispatch::Unknown))) .send((filename.to_owned(), Dispatch::Unknown))
.unwrap(); .unwrap();
} }
} else if self.is_ignored(&filename) && self.options.list_ignored { } else if self.is_ignored(&filename) && self.options.list_ignored {
files_sender files_sender
.send(Ok((filename.to_owned(), Dispatch::Ignored))) .send((filename.to_owned(), Dispatch::Ignored))
.unwrap(); .unwrap();
} }
} else if let Some(entry) = entry_option { } else if let Some(entry) = entry_option {
// Used to be a file or a folder, now something else. // Used to be a file or a folder, now something else.
if self.matcher.matches_everything() if self.matcher.matches_everything()
|| self.matcher.matches(&filename) || self.matcher.matches(&filename)
{ {
files_sender files_sender
.send(Ok(( .send((filename.to_owned(), dispatch_missing(entry.state)))
filename.to_owned(),
dispatch_missing(entry.state),
)))
.unwrap(); .unwrap();
} }
} }
Ok(()) Ok(())
} }
/// A directory was found in the filesystem and needs to be traversed /// A directory was found in the filesystem and needs to be traversed
fn handle_traversed_dir<'b>( fn handle_traversed_dir<'b>(
&'a self, &'a self,
scope: &rayon::Scope<'b>, scope: &rayon::Scope<'b>,
files_sender: &'b crossbeam::Sender<IoResult<(HgPathBuf, Dispatch)>>, files_sender: &'b crossbeam::Sender<(HgPathBuf, Dispatch)>,
old_results: &'a FastHashMap<Cow<HgPath>, Dispatch>, old_results: &'a FastHashMap<Cow<HgPath>, Dispatch>,
entry_option: Option<&'a DirstateEntry>, entry_option: Option<&'a DirstateEntry>,
directory: HgPathBuf, directory: HgPathBuf,
traversed_sender: crossbeam::Sender<HgPathBuf>, traversed_sender: crossbeam::Sender<HgPathBuf>,
) where ) where
'a: 'b, 'a: 'b,
{ {
scope.spawn(move |_| { scope.spawn(move |_| {
// Nested `if` until `rust-lang/rust#53668` is stable // Nested `if` until `rust-lang/rust#53668` is stable
if let Some(entry) = entry_option { if let Some(entry) = entry_option {
// Used to be a file, is now a folder // Used to be a file, is now a folder
if self.matcher.matches_everything() if self.matcher.matches_everything()
|| self.matcher.matches(&directory) || self.matcher.matches(&directory)
{ {
files_sender files_sender
.send(Ok(( .send((
directory.to_owned(), directory.to_owned(),
dispatch_missing(entry.state), dispatch_missing(entry.state),
))) ))
.unwrap(); .unwrap();
} }
} }
// Do we need to traverse it? // Do we need to traverse it?
if !self.is_ignored(&directory) || self.options.list_ignored { if !self.is_ignored(&directory) || self.options.list_ignored {
self.traverse_dir( self.traverse_dir(
files_sender, files_sender,
directory, directory,
&old_results, &old_results,
traversed_sender, traversed_sender,
) )
.unwrap_or_else(|e| files_sender.send(Err(e)).unwrap())
} }
}); });
} }
/// Decides whether the directory needs to be listed, and if so handles the /// Decides whether the directory needs to be listed, and if so handles the
/// entries in a separate thread. /// entries in a separate thread.
fn traverse_dir( fn traverse_dir(
&self, &self,
files_sender: &crossbeam::Sender<IoResult<(HgPathBuf, Dispatch)>>, files_sender: &crossbeam::Sender<(HgPathBuf, Dispatch)>,
directory: impl AsRef<HgPath>, directory: impl AsRef<HgPath>,
old_results: &FastHashMap<Cow<HgPath>, Dispatch>, old_results: &FastHashMap<Cow<HgPath>, Dispatch>,
traversed_sender: crossbeam::Sender<HgPathBuf>, traversed_sender: crossbeam::Sender<HgPathBuf>,
) -> IoResult<()> { ) {
let directory = directory.as_ref(); let directory = directory.as_ref();
if self.options.collect_traversed_dirs { if self.options.collect_traversed_dirs {
traversed_sender traversed_sender
.send(directory.to_owned()) .send(directory.to_owned())
.expect("receiver should outlive sender"); .expect("receiver should outlive sender");
} }
let visit_entries = match self.matcher.visit_children_set(directory) { let visit_entries = match self.matcher.visit_children_set(directory) {
VisitChildrenSet::Empty => return Ok(()), VisitChildrenSet::Empty => return,
VisitChildrenSet::This | VisitChildrenSet::Recursive => None, VisitChildrenSet::This | VisitChildrenSet::Recursive => None,
VisitChildrenSet::Set(set) => Some(set), VisitChildrenSet::Set(set) => Some(set),
}; };
let buf = hg_path_to_path_buf(directory)?; let buf = match hg_path_to_path_buf(directory) {
Ok(b) => b,
Err(_) => {
files_sender
.send((directory.to_owned(), INVALID_PATH_DISPATCH))
.expect("receiver should outlive sender");
return;
}
};
let dir_path = self.root_dir.join(buf); let dir_path = self.root_dir.join(buf);
let skip_dot_hg = !directory.as_bytes().is_empty(); let skip_dot_hg = !directory.as_bytes().is_empty();
let entries = match list_directory(dir_path, skip_dot_hg) { let entries = match list_directory(dir_path, skip_dot_hg) {
Err(e) => { Err(e) => {
return match e.kind() {
ErrorKind::NotFound | ErrorKind::PermissionDenied => {
files_sender files_sender
.send(Ok(( .send((directory.to_owned(), dispatch_os_error(&e)))
directory.to_owned(),
Dispatch::Bad(BadMatch::OsError(
// Unwrapping here is OK because the error
// always is a
// real os error
e.raw_os_error().unwrap(),
)),
)))
.expect("receiver should outlive sender"); .expect("receiver should outlive sender");
Ok(()) return;
}
_ => Err(e),
};
} }
Ok(entries) => entries, Ok(entries) => entries,
}; };
rayon::scope(|scope| -> IoResult<()> { rayon::scope(|scope| {
for (filename, dir_entry) in entries { for (filename, dir_entry) in entries {
if let Some(ref set) = visit_entries { if let Some(ref set) = visit_entries {
if !set.contains(filename.deref()) { if !set.contains(filename.deref()) {
continue; continue;
} }
} }
// TODO normalize // TODO normalize
let filename = if directory.is_empty() { let filename = if directory.is_empty() {
filename.to_owned() filename.to_owned()
} else { } else {
directory.join(&filename) directory.join(&filename)
}; };
if !old_results.contains_key(filename.deref()) { if !old_results.contains_key(filename.deref()) {
self.handle_traversed_entry( match self.handle_traversed_entry(
scope, scope,
files_sender, files_sender,
old_results, old_results,
filename, filename,
dir_entry, dir_entry,
traversed_sender.clone(), traversed_sender.clone(),
)?; ) {
Err(e) => {
files_sender
.send((
directory.to_owned(),
dispatch_os_error(&e),
))
.expect("receiver should outlive sender");
}
Ok(_) => {}
}
} }
} }
Ok(())
}) })
} }
/// Add the files in the dirstate to the results. /// Add the files in the dirstate to the results.
/// ///
/// This takes a mutable reference to the results to account for the /// This takes a mutable reference to the results to account for the
/// `extend` in timings /// `extend` in timings
#[cfg(feature = "dirstate-tree")] #[cfg(feature = "dirstate-tree")]
#[timed] #[timed]
pub fn extend_from_dmap(&self, results: &mut Vec<DispatchedPath<'a>>) { pub fn extend_from_dmap(&self, results: &mut Vec<DispatchedPath<'a>>) {
results.par_extend( results.par_extend(
self.dmap self.dmap
.fs_iter(self.root_dir.clone()) .fs_iter(self.root_dir.clone())
.par_bridge() .par_bridge()
.filter(|(path, _)| self.matcher.matches(path)) .filter(|(path, _)| self.matcher.matches(path))
.flat_map(move |(filename, shortcut)| { .map(move |(filename, shortcut)| {
let entry = match shortcut { let entry = match shortcut {
StatusShortcut::Entry(e) => e, StatusShortcut::Entry(e) => e,
StatusShortcut::Dispatch(d) => { StatusShortcut::Dispatch(d) => {
return Ok((Cow::Owned(filename), d)) return (Cow::Owned(filename), d)
}
};
let filename_as_path = match hg_path_to_path_buf(&filename)
{
Ok(f) => f,
Err(_) => {
return (
Cow::Owned(filename),
INVALID_PATH_DISPATCH,
)
} }
}; };
let filename_as_path = hg_path_to_path_buf(&filename)?;
let meta = self let meta = self
.root_dir .root_dir
.join(filename_as_path) .join(filename_as_path)
.symlink_metadata(); .symlink_metadata();
match meta { match meta {
Ok(m) Ok(m)
if !(m.file_type().is_file() if !(m.file_type().is_file()
|| m.file_type().is_symlink()) => || m.file_type().is_symlink()) =>
{ {
Ok(( (
Cow::Owned(filename), Cow::Owned(filename),
dispatch_missing(entry.state), dispatch_missing(entry.state),
)) )
} }
Ok(m) => { Ok(m) => {
let dispatch = dispatch_found( let dispatch = dispatch_found(
&filename, &filename,
entry, entry,
HgMetadata::from_metadata(m), HgMetadata::from_metadata(m),
&self.dmap.copy_map, &self.dmap.copy_map,
self.options, self.options,
); );
Ok((Cow::Owned(filename), dispatch)) (Cow::Owned(filename), dispatch)
} }
Err(e) Err(e)
if e.kind() == ErrorKind::NotFound if e.kind() == ErrorKind::NotFound
|| e.raw_os_error() == Some(20) => || e.raw_os_error() == Some(20) =>
{ {
// Rust does not yet have an `ErrorKind` for // Rust does not yet have an `ErrorKind` for
// `NotADirectory` (errno 20) // `NotADirectory` (errno 20)
// It happens if the dirstate contains `foo/bar` // It happens if the dirstate contains `foo/bar`
// and foo is not a // and foo is not a
// directory // directory
Ok(( (
Cow::Owned(filename), Cow::Owned(filename),
dispatch_missing(entry.state), dispatch_missing(entry.state),
)) )
}
Err(e) => {
(Cow::Owned(filename), dispatch_os_error(&e))
} }
Err(e) => Err(e),
} }
}), }),
); );
} }
/// Add the files in the dirstate to the results. /// Add the files in the dirstate to the results.
/// ///
/// This takes a mutable reference to the results to account for the /// This takes a mutable reference to the results to account for the
/// `extend` in timings /// `extend` in timings
#[cfg(not(feature = "dirstate-tree"))] #[cfg(not(feature = "dirstate-tree"))]
#[timed] #[timed]
pub fn extend_from_dmap(&self, results: &mut Vec<DispatchedPath<'a>>) { pub fn extend_from_dmap(&self, results: &mut Vec<DispatchedPath<'a>>) {
results.par_extend(self.dmap.par_iter().flat_map( results.par_extend(self.dmap.par_iter().map(
move |(filename, entry)| { move |(filename, entry)| {
let filename: &HgPath = filename; let filename: &HgPath = filename;
let filename_as_path = hg_path_to_path_buf(filename)?; let filename_as_path = match hg_path_to_path_buf(filename) {
Ok(f) => f,
Err(_) => {
return (
Cow::Borrowed(filename),
INVALID_PATH_DISPATCH,
)
}
};
let meta = let meta =
self.root_dir.join(filename_as_path).symlink_metadata(); self.root_dir.join(filename_as_path).symlink_metadata();
match meta { match meta {
Ok(m) Ok(m)
if !(m.file_type().is_file() if !(m.file_type().is_file()
|| m.file_type().is_symlink()) => || m.file_type().is_symlink()) =>
{ {
Ok(( (
Cow::Borrowed(filename), Cow::Borrowed(filename),
dispatch_missing(entry.state), dispatch_missing(entry.state),
)) )
} }
Ok(m) => Ok(( Ok(m) => (
Cow::Borrowed(filename), Cow::Borrowed(filename),
dispatch_found( dispatch_found(
filename, filename,
*entry, *entry,
HgMetadata::from_metadata(m), HgMetadata::from_metadata(m),
&self.dmap.copy_map, &self.dmap.copy_map,
self.options, self.options,
), ),
)), ),
Err(e) Err(e)
if e.kind() == ErrorKind::NotFound if e.kind() == ErrorKind::NotFound
|| e.raw_os_error() == Some(20) => || e.raw_os_error() == Some(20) =>
{ {
// Rust does not yet have an `ErrorKind` for // Rust does not yet have an `ErrorKind` for
// `NotADirectory` (errno 20) // `NotADirectory` (errno 20)
// It happens if the dirstate contains `foo/bar` // It happens if the dirstate contains `foo/bar`
// and foo is not a // and foo is not a
// directory // directory
Ok(( (
Cow::Borrowed(filename), Cow::Borrowed(filename),
dispatch_missing(entry.state), dispatch_missing(entry.state),
)) )
} }
Err(e) => Err(e), Err(e) => (Cow::Borrowed(filename), dispatch_os_error(&e)),
} }
}, },
)); ));
} }
/// Checks all files that are in the dirstate but were not found during the /// Checks all files that are in the dirstate but were not found during the
/// working directory traversal. This means that the rest must /// working directory traversal. This means that the rest must
/// be either ignored, under a symlink or under a new nested repo. /// be either ignored, under a symlink or under a new nested repo.
/// ///
/// This takes a mutable reference to the results to account for the /// This takes a mutable reference to the results to account for the
/// `extend` in timings /// `extend` in timings
#[cfg(not(feature = "dirstate-tree"))] #[cfg(not(feature = "dirstate-tree"))]
#[timed] #[timed]
pub fn handle_unknowns( pub fn handle_unknowns(&self, results: &mut Vec<DispatchedPath<'a>>) {
&self,
results: &mut Vec<DispatchedPath<'a>>,
) -> IoResult<()> {
let to_visit: Vec<(&HgPath, &DirstateEntry)> = let to_visit: Vec<(&HgPath, &DirstateEntry)> =
if results.is_empty() && self.matcher.matches_everything() { if results.is_empty() && self.matcher.matches_everything() {
self.dmap.iter().map(|(f, e)| (f.deref(), e)).collect() self.dmap.iter().map(|(f, e)| (f.deref(), e)).collect()
} else { } else {
// Only convert to a hashmap if needed. // Only convert to a hashmap if needed.
let old_results: FastHashMap<_, _> = let old_results: FastHashMap<_, _> =
results.iter().cloned().collect(); results.iter().cloned().collect();
self.dmap self.dmap
.iter() .iter()
.filter_map(move |(f, e)| { .filter_map(move |(f, e)| {
if !old_results.contains_key(f.deref()) if !old_results.contains_key(f.deref())
&& self.matcher.matches(f) && self.matcher.matches(f)
{ {
Some((f.deref(), e)) Some((f.deref(), e))
} else { } else {
None None
} }
}) })
.collect() .collect()
}; };
let path_auditor = PathAuditor::new(&self.root_dir); let path_auditor = PathAuditor::new(&self.root_dir);
// TODO don't collect. Find a way of replicating the behavior of let new_results = to_visit.into_par_iter().filter_map(
// `itertools::process_results`, but for `rayon::ParallelIterator` |(filename, entry)| -> Option<_> {
let new_results: IoResult<Vec<_>> = to_visit
.into_par_iter()
.filter_map(|(filename, entry)| -> Option<IoResult<_>> {
// Report ignored items in the dmap as long as they are not // Report ignored items in the dmap as long as they are not
// under a symlink directory. // under a symlink directory.
if path_auditor.check(filename) { if path_auditor.check(filename) {
// TODO normalize for case-insensitive filesystems // TODO normalize for case-insensitive filesystems
let buf = match hg_path_to_path_buf(filename) { let buf = match hg_path_to_path_buf(filename) {
Ok(x) => x, Ok(x) => x,
Err(e) => return Some(Err(e.into())), Err(_) => {
return Some((
Cow::Owned(filename.to_owned()),
INVALID_PATH_DISPATCH,
));
}
}; };
Some(Ok(( Some((
Cow::Borrowed(filename), Cow::Owned(filename.to_owned()),
match self.root_dir.join(&buf).symlink_metadata() { match self.root_dir.join(&buf).symlink_metadata() {
// File was just ignored, no links, and exists // File was just ignored, no links, and exists
Ok(meta) => { Ok(meta) => {
let metadata = HgMetadata::from_metadata(meta); let metadata = HgMetadata::from_metadata(meta);
dispatch_found( dispatch_found(
filename, filename,
*entry, *entry,
metadata, metadata,
&self.dmap.copy_map, &self.dmap.copy_map,
self.options, self.options,
) )
} }
// File doesn't exist // File doesn't exist
Err(_) => dispatch_missing(entry.state), Err(_) => dispatch_missing(entry.state),
}, },
))) ))
} else { } else {
// It's either missing or under a symlink directory which // It's either missing or under a symlink directory which
// we, in this case, report as missing. // we, in this case, report as missing.
Some(Ok(( Some((
Cow::Borrowed(filename), Cow::Owned(filename.to_owned()),
dispatch_missing(entry.state), dispatch_missing(entry.state),
))) ))
} }
}) },
.collect(); );
results.par_extend(new_results?);
Ok(()) results.par_extend(new_results);
} }
} }
#[timed] #[timed]
pub fn build_response<'a>( pub fn build_response<'a>(
results: impl IntoIterator<Item = DispatchedPath<'a>>, results: impl IntoIterator<Item = DispatchedPath<'a>>,
traversed: Vec<HgPathBuf>, traversed: Vec<HgPathBuf>,
) -> (Vec<HgPathCow<'a>>, DirstateStatus<'a>) { ) -> (Vec<HgPathCow<'a>>, DirstateStatus<'a>) {

rust/hg-core/src/operations/dirstate_status.rs

} }
self.traverse( self.traverse(
&dir, &dir,
old_results old_results
.as_ref() .as_ref()
.expect("old results should exist"), .expect("old results should exist"),
&mut results, &mut results,
traversed_sender.clone(), traversed_sender.clone(),
)?; );
} }
} }
_ => { _ => {
unreachable!("There can only be directories in `work`") unreachable!("There can only be directories in `work`")
} }
} }
} }
} }
|| self.options.list_unknown || self.options.list_unknown
&& !self.dir_ignore(&dir) && !self.dir_ignore(&dir)
{ {
self.traverse( self.traverse(
&dir, &dir,
&old_results, &old_results,
&mut results, &mut results,
traversed_sender.clone(), traversed_sender.clone(),
)?; );
} }
} }
_ => { _ => {
unreachable!("There can only be directories in `work`") unreachable!("There can only be directories in `work`")
} }
} }
} }
} }
if !self.matcher.is_exact() { if !self.matcher.is_exact() {
if self.options.list_unknown { if self.options.list_unknown {
self.handle_unknowns(&mut results)?; self.handle_unknowns(&mut results);
} else { } else {
// TODO this is incorrect, see issue6335 // TODO this is incorrect, see issue6335
// This requires a fix in both Python and Rust that can happen // This requires a fix in both Python and Rust that can happen
// with other pending changes to `status`. // with other pending changes to `status`.
self.extend_from_dmap(&mut results); self.extend_from_dmap(&mut results);
} }
} }
drop(traversed_sender); drop(traversed_sender);
let traversed = traversed_receiver.into_iter().collect(); let traversed = traversed_receiver.into_iter().collect();
Ok(build_response(results, traversed)) Ok(build_response(results, traversed))
} }
} }