( )⚙ D10549 dirstate-tree: Handle I/O errors in status

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10549

dirstate-tree: Handle I/O errors in status
ClosedPublic

Authored by SimonSapin on May 3 2021, 6:25 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG1b4f0f819f92: dirstate-tree: Handle I/O errors in status
rHG2039f0815456: dirstate-tree: Handle I/O errors in status
Summary

Errors such as insufficient permissions when listing a directory are logged,
and the algorithm continues without considering that directory.

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

SimonSapin created this revision.May 3 2021, 6:25 AM
Alphare accepted this revision.May 3 2021, 10:40 AM
This revision is now accepted and ready to land.May 3 2021, 10:40 AM
baymax updated this revision to Diff 27625.May 6 2021, 12:03 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

SimonSapin added a commit: rHG2039f0815456: dirstate-tree: Handle I/O errors in status.May 6 2021, 12:55 PM
Closed by commit rHG2039f0815456: dirstate-tree: Handle I/O errors in status (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 27659

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

use crate::dirstate::status::IgnoreFnType; use crate::dirstate::status::IgnoreFnType;
use crate::dirstate_tree::dirstate_map::ChildNodes; use crate::dirstate_tree::dirstate_map::ChildNodes;
use crate::dirstate_tree::dirstate_map::DirstateMap; use crate::dirstate_tree::dirstate_map::DirstateMap;
use crate::dirstate_tree::dirstate_map::Node; use crate::dirstate_tree::dirstate_map::Node;
use crate::matchers::get_ignore_function; use crate::matchers::get_ignore_function;
use crate::matchers::Matcher; use crate::matchers::Matcher;
use crate::utils::files::get_bytes_from_os_string; use crate::utils::files::get_bytes_from_os_string;
use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
use crate::BadMatch;
use crate::DirstateStatus; use crate::DirstateStatus;
use crate::EntryState; use crate::EntryState;
use crate::HgPathBuf; use crate::HgPathBuf;
use crate::PatternFileWarning; use crate::PatternFileWarning;
use crate::StatusError; use crate::StatusError;
use crate::StatusOptions; use crate::StatusOptions;
use std::borrow::Cow; use std::borrow::Cow;
use std::io; use std::io;
struct StatusCommon<'tree, 'a> { struct StatusCommon<'tree, 'a> {
options: StatusOptions, options: StatusOptions,
matcher: &'a (dyn Matcher + Sync), matcher: &'a (dyn Matcher + Sync),
ignore_fn: IgnoreFnType<'a>, ignore_fn: IgnoreFnType<'a>,
outcome: DirstateStatus<'tree>, outcome: DirstateStatus<'tree>,
} }
impl<'tree, 'a> StatusCommon<'tree, 'a> { impl<'tree, 'a> StatusCommon<'tree, 'a> {
fn read_dir(
&mut self,
hg_path: &HgPath,
fs_path: &Path,
is_at_repo_root: bool,
) -> Result<Vec<DirEntry>, ()> {
DirEntry::read_dir(fs_path, is_at_repo_root).map_err(|error| {
let errno = error.raw_os_error().expect("expected real OS error");
self.outcome
.bad
.push((hg_path.to_owned().into(), BadMatch::OsError(errno)))
})
}
fn traverse_fs_directory_and_dirstate( fn traverse_fs_directory_and_dirstate(
&mut self, &mut self,
has_ignored_ancestor: bool, has_ignored_ancestor: bool,
dirstate_nodes: &'tree mut ChildNodes, dirstate_nodes: &'tree mut ChildNodes,
directory_hg_path: &HgPath, directory_hg_path: &'tree HgPath,
fs_path: &Path, directory_fs_path: &Path,
is_at_repo_root: bool, is_at_repo_root: bool,
) { ) {
// TODO: handle I/O errors let mut fs_entries = if let Ok(entries) = self.read_dir(
let mut fs_entries = directory_hg_path,
DirEntry::read_dir(fs_path, is_at_repo_root).unwrap(); directory_fs_path,
is_at_repo_root,
) {
entries
} else {
return;
};
// `merge_join_by` requires both its input iterators to be sorted: // `merge_join_by` requires both its input iterators to be sorted:
// * `BTreeMap` iterates according to keys’ ordering by definition // * `BTreeMap` iterates according to keys’ ordering by definition
// `sort_unstable_by_key` doesn’t allow keys borrowing from the value: // `sort_unstable_by_key` doesn’t allow keys borrowing from the value:
// https://github.com/rust-lang/rust/issues/34162 // https://github.com/rust-lang/rust/issues/34162
fs_entries.sort_unstable_by(|e1, e2| e1.base_name.cmp(&e2.base_name)); fs_entries.sort_unstable_by(|e1, e2| e1.base_name.cmp(&e2.base_name));
self.options.list_ignored self.options.list_ignored
} else { } else {
// Descendants of an unknown directory may be either unknown or // Descendants of an unknown directory may be either unknown or
// ignored // ignored
self.options.list_unknown || self.options.list_ignored self.options.list_unknown || self.options.list_ignored
}; };
if traverse_children { if traverse_children {
let is_at_repo_root = false; let is_at_repo_root = false;
// TODO: handle I/O errors if let Ok(children_fs_entries) = self.read_dir(
let children_fs_entries = &hg_path,
DirEntry::read_dir(&fs_entry.full_path, is_at_repo_root) &fs_entry.full_path,
.unwrap(); is_at_repo_root,
) {
for child_fs_entry in children_fs_entries { for child_fs_entry in children_fs_entries {
self.traverse_fs_only( self.traverse_fs_only(
is_ignored, is_ignored,
&hg_path, &hg_path,
&child_fs_entry, &child_fs_entry,
) )
} }
} }
}
if self.options.collect_traversed_dirs { if self.options.collect_traversed_dirs {
self.outcome.traversed.push(hg_path.into()) self.outcome.traversed.push(hg_path.into())
} }
} else if file_or_symlink && self.matcher.matches(&hg_path) { } else if file_or_symlink && self.matcher.matches(&hg_path) {
self.mark_unknown_or_ignored(has_ignored_ancestor, hg_path.into()) self.mark_unknown_or_ignored(has_ignored_ancestor, hg_path.into())
} }
} }