( )⚙ 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
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

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 27625

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())
} }
} }