status.rs
539 lines
| 17.1 KiB
| application/rls-services+xml
|
RustLexer
|
r47578 | // status.rs | ||
// | ||||
// Copyright 2020, Georges Racinet <georges.racinets@octobus.net> | ||||
// | ||||
// This software may be used and distributed according to the terms of the | ||||
// GNU General Public License version 2 or any later version. | ||||
use crate::error::CommandError; | ||||
|
r49171 | use crate::ui::Ui; | ||
|
r49284 | use crate::utils::path_utils::RelativizePaths; | ||
|
r47578 | use clap::{Arg, SubCommand}; | ||
|
r49171 | use format_bytes::format_bytes; | ||
|
r47578 | use hg; | ||
|
r48989 | use hg::config::Config; | ||
r49220 | use hg::dirstate::has_exec_bit; | |||
|
r49285 | use hg::dirstate::status::StatusPath; | ||
|
r49250 | use hg::dirstate::TruncatedTimestamp; | ||
use hg::dirstate::RANGE_MASK_31BIT; | ||||
use hg::errors::{HgError, IoResultExt}; | ||||
use hg::lock::LockError; | ||||
|
r48778 | use hg::manifest::Manifest; | ||
|
r47578 | use hg::matchers::AlwaysMatcher; | ||
use hg::repo::Repo; | ||||
|
r49168 | use hg::utils::files::get_bytes_from_os_string; | ||
|
r49342 | use hg::utils::files::get_bytes_from_path; | ||
|
r49282 | use hg::utils::files::get_path_from_bytes; | ||
|
r49250 | use hg::utils::hg_path::{hg_path_to_path_buf, HgPath}; | ||
|
r49285 | use hg::StatusOptions; | ||
|
r49342 | use log::info; | ||
|
r49250 | use std::io; | ||
|
r49282 | use std::path::PathBuf; | ||
|
r47578 | |||
pub const HELP_TEXT: &str = " | ||||
Show changed files in the working directory | ||||
This is a pure Rust version of `hg status`. | ||||
Some options might be missing, check the list below. | ||||
"; | ||||
pub fn args() -> clap::App<'static, 'static> { | ||||
SubCommand::with_name("status") | ||||
.alias("st") | ||||
.about(HELP_TEXT) | ||||
.arg( | ||||
Arg::with_name("all") | ||||
.help("show status of all files") | ||||
.short("-A") | ||||
.long("--all"), | ||||
) | ||||
.arg( | ||||
Arg::with_name("modified") | ||||
.help("show only modified files") | ||||
.short("-m") | ||||
.long("--modified"), | ||||
) | ||||
.arg( | ||||
Arg::with_name("added") | ||||
.help("show only added files") | ||||
.short("-a") | ||||
.long("--added"), | ||||
) | ||||
.arg( | ||||
Arg::with_name("removed") | ||||
.help("show only removed files") | ||||
.short("-r") | ||||
.long("--removed"), | ||||
) | ||||
.arg( | ||||
Arg::with_name("clean") | ||||
.help("show only clean files") | ||||
.short("-c") | ||||
.long("--clean"), | ||||
) | ||||
.arg( | ||||
Arg::with_name("deleted") | ||||
.help("show only deleted files") | ||||
.short("-d") | ||||
.long("--deleted"), | ||||
) | ||||
.arg( | ||||
Arg::with_name("unknown") | ||||
.help("show only unknown (not tracked) files") | ||||
.short("-u") | ||||
.long("--unknown"), | ||||
) | ||||
.arg( | ||||
Arg::with_name("ignored") | ||||
.help("show only ignored files") | ||||
.short("-i") | ||||
.long("--ignored"), | ||||
) | ||||
|
r49171 | .arg( | ||
|
r49285 | Arg::with_name("copies") | ||
.help("show source of copied files (DEFAULT: ui.statuscopies)") | ||||
.short("-C") | ||||
.long("--copies"), | ||||
) | ||||
.arg( | ||||
|
r49171 | Arg::with_name("no-status") | ||
.help("hide status prefix") | ||||
.short("-n") | ||||
.long("--no-status"), | ||||
) | ||||
|
r47578 | } | ||
/// Pure data type allowing the caller to specify file states to display | ||||
#[derive(Copy, Clone, Debug)] | ||||
pub struct DisplayStates { | ||||
pub modified: bool, | ||||
pub added: bool, | ||||
pub removed: bool, | ||||
pub clean: bool, | ||||
pub deleted: bool, | ||||
pub unknown: bool, | ||||
pub ignored: bool, | ||||
} | ||||
pub const DEFAULT_DISPLAY_STATES: DisplayStates = DisplayStates { | ||||
modified: true, | ||||
added: true, | ||||
removed: true, | ||||
clean: false, | ||||
deleted: true, | ||||
unknown: true, | ||||
ignored: false, | ||||
}; | ||||
pub const ALL_DISPLAY_STATES: DisplayStates = DisplayStates { | ||||
modified: true, | ||||
added: true, | ||||
removed: true, | ||||
clean: true, | ||||
deleted: true, | ||||
unknown: true, | ||||
ignored: true, | ||||
}; | ||||
impl DisplayStates { | ||||
pub fn is_empty(&self) -> bool { | ||||
!(self.modified | ||||
|| self.added | ||||
|| self.removed | ||||
|| self.clean | ||||
|| self.deleted | ||||
|| self.unknown | ||||
|| self.ignored) | ||||
} | ||||
} | ||||
pub fn run(invocation: &crate::CliInvocation) -> Result<(), CommandError> { | ||||
let status_enabled_default = false; | ||||
let status_enabled = invocation.config.get_option(b"rhg", b"status")?; | ||||
if !status_enabled.unwrap_or(status_enabled_default) { | ||||
return Err(CommandError::unsupported( | ||||
"status is experimental in rhg (enable it with 'rhg.status = true' \ | ||||
or enable fallback with 'rhg.on-unsupported = fallback')" | ||||
)); | ||||
} | ||||
|
r48985 | // TODO: lift these limitations | ||
|
r49160 | if invocation.config.get_bool(b"ui", b"tweakdefaults")? { | ||
|
r48985 | return Err(CommandError::unsupported( | ||
"ui.tweakdefaults is not yet supported with rhg status", | ||||
)); | ||||
} | ||||
|
r49160 | if invocation.config.get_bool(b"ui", b"statuscopies")? { | ||
|
r48985 | return Err(CommandError::unsupported( | ||
"ui.statuscopies is not yet supported with rhg status", | ||||
)); | ||||
} | ||||
|
r49161 | if invocation | ||
.config | ||||
.get(b"commands", b"status.terse") | ||||
.is_some() | ||||
{ | ||||
return Err(CommandError::unsupported( | ||||
"status.terse is not yet supported with rhg status", | ||||
)); | ||||
} | ||||
|
r48985 | |||
|
r47578 | let ui = invocation.ui; | ||
|
r48989 | let config = invocation.config; | ||
|
r47578 | let args = invocation.subcommand_args; | ||
|
r49344 | |||
|
r49580 | let verbose = !ui.plain(None) | ||
|
r49344 | && !args.is_present("print0") | ||
&& (config.get_bool(b"ui", b"verbose")? | ||||
|| config.get_bool(b"commands", b"status.verbose")?); | ||||
if verbose { | ||||
return Err(CommandError::unsupported( | ||||
"verbose status is not supported yet", | ||||
)); | ||||
} | ||||
|
r49285 | let all = args.is_present("all"); | ||
let display_states = if all { | ||||
|
r47578 | // TODO when implementing `--quiet`: it excludes clean files | ||
// from `--all` | ||||
ALL_DISPLAY_STATES | ||||
} else { | ||||
let requested = DisplayStates { | ||||
modified: args.is_present("modified"), | ||||
added: args.is_present("added"), | ||||
removed: args.is_present("removed"), | ||||
clean: args.is_present("clean"), | ||||
deleted: args.is_present("deleted"), | ||||
unknown: args.is_present("unknown"), | ||||
ignored: args.is_present("ignored"), | ||||
}; | ||||
if requested.is_empty() { | ||||
DEFAULT_DISPLAY_STATES | ||||
} else { | ||||
requested | ||||
} | ||||
}; | ||||
|
r49171 | let no_status = args.is_present("no-status"); | ||
|
r49285 | let list_copies = all | ||
|| args.is_present("copies") | ||||
|| config.get_bool(b"ui", b"statuscopies")?; | ||||
|
r47578 | |||
let repo = invocation.repo?; | ||||
|
r49238 | |||
if repo.has_sparse() || repo.has_narrow() { | ||||
return Err(CommandError::unsupported( | ||||
"rhg status is not supported for sparse checkouts or narrow clones yet" | ||||
)); | ||||
} | ||||
|
r48768 | let mut dmap = repo.dirstate_map_mut()?; | ||
|
r48474 | |||
|
r47578 | let options = StatusOptions { | ||
// we're currently supporting file systems with exec flags only | ||||
// anyway | ||||
check_exec: true, | ||||
list_clean: display_states.clean, | ||||
list_unknown: display_states.unknown, | ||||
list_ignored: display_states.ignored, | ||||
|
r49285 | list_copies, | ||
|
r47578 | collect_traversed_dirs: false, | ||
}; | ||||
|
r48768 | let (mut ds_status, pattern_warnings) = dmap.status( | ||
|
r47578 | &AlwaysMatcher, | ||
repo.working_directory_path().to_owned(), | ||||
|
r49282 | ignore_files(repo, config), | ||
|
r47578 | options, | ||
)?; | ||||
|
r49342 | for warning in pattern_warnings { | ||
match warning { | ||||
hg::PatternFileWarning::InvalidSyntax(path, syntax) => ui | ||||
.write_stderr(&format_bytes!( | ||||
b"{}: ignoring invalid syntax '{}'\n", | ||||
get_bytes_from_path(path), | ||||
&*syntax | ||||
))?, | ||||
hg::PatternFileWarning::NoSuchFile(path) => { | ||||
let path = if let Ok(relative) = | ||||
path.strip_prefix(repo.working_directory_path()) | ||||
{ | ||||
relative | ||||
} else { | ||||
&*path | ||||
}; | ||||
ui.write_stderr(&format_bytes!( | ||||
b"skipping unreadable pattern file '{}': \ | ||||
No such file or directory\n", | ||||
get_bytes_from_path(path), | ||||
))? | ||||
} | ||||
} | ||||
|
r47578 | } | ||
|
r49298 | for (path, error) in ds_status.bad { | ||
let error = match error { | ||||
hg::BadMatch::OsError(code) => { | ||||
std::io::Error::from_raw_os_error(code).to_string() | ||||
} | ||||
hg::BadMatch::BadType(ty) => { | ||||
format!("unsupported file type (type is {})", ty) | ||||
} | ||||
}; | ||||
ui.write_stderr(&format_bytes!( | ||||
b"{}: {}\n", | ||||
path.as_bytes(), | ||||
error.as_bytes() | ||||
))? | ||||
|
r47578 | } | ||
|
r47880 | if !ds_status.unsure.is_empty() { | ||
|
r47578 | info!( | ||
"Files to be rechecked by retrieval from filelog: {:?}", | ||||
|
r49285 | ds_status.unsure.iter().map(|s| &s.path).collect::<Vec<_>>() | ||
|
r47578 | ); | ||
} | ||||
|
r49250 | let mut fixup = Vec::new(); | ||
|
r48112 | if !ds_status.unsure.is_empty() | ||
&& (display_states.modified || display_states.clean) | ||||
{ | ||||
|
r48778 | let p1 = repo.dirstate_parents()?.p1; | ||
let manifest = repo.manifest_for_node(p1).map_err(|e| { | ||||
CommandError::from((e, &*format!("{:x}", p1.short()))) | ||||
})?; | ||||
|
r47880 | for to_check in ds_status.unsure { | ||
|
r49285 | if unsure_is_modified(repo, &manifest, &to_check.path)? { | ||
|
r48112 | if display_states.modified { | ||
ds_status.modified.push(to_check); | ||||
} | ||||
|
r47578 | } else { | ||
|
r48112 | if display_states.clean { | ||
|
r49250 | ds_status.clean.push(to_check.clone()); | ||
|
r48112 | } | ||
|
r49285 | fixup.push(to_check.path.into_owned()) | ||
|
r47578 | } | ||
} | ||||
|
r48112 | } | ||
|
r49580 | let relative_paths = (!ui.plain(None)) | ||
|
r49283 | && config | ||
.get_option(b"commands", b"status.relative")? | ||||
.unwrap_or(config.get_bool(b"ui", b"relative-paths")?); | ||||
let output = DisplayStatusPaths { | ||||
ui, | ||||
no_status, | ||||
|
r49284 | relativize: if relative_paths { | ||
Some(RelativizePaths::new(repo)?) | ||||
} else { | ||||
None | ||||
}, | ||||
|
r49283 | }; | ||
|
r48112 | if display_states.modified { | ||
|
r49283 | output.display(b"M", ds_status.modified)?; | ||
|
r47578 | } | ||
if display_states.added { | ||||
|
r49283 | output.display(b"A", ds_status.added)?; | ||
|
r47578 | } | ||
if display_states.removed { | ||||
|
r49283 | output.display(b"R", ds_status.removed)?; | ||
|
r47578 | } | ||
if display_states.deleted { | ||||
|
r49283 | output.display(b"!", ds_status.deleted)?; | ||
|
r47578 | } | ||
if display_states.unknown { | ||||
|
r49283 | output.display(b"?", ds_status.unknown)?; | ||
|
r47578 | } | ||
if display_states.ignored { | ||||
|
r49283 | output.display(b"I", ds_status.ignored)?; | ||
|
r48112 | } | ||
if display_states.clean { | ||||
|
r49283 | output.display(b"C", ds_status.clean)?; | ||
|
r47578 | } | ||
|
r49250 | |||
let mut dirstate_write_needed = ds_status.dirty; | ||||
|
r49332 | let filesystem_time_at_status_start = | ||
ds_status.filesystem_time_at_status_start; | ||||
|
r49250 | |||
if (fixup.is_empty() || filesystem_time_at_status_start.is_none()) | ||||
&& !dirstate_write_needed | ||||
{ | ||||
// Nothing to update | ||||
return Ok(()); | ||||
} | ||||
// Update the dirstate on disk if we can | ||||
let with_lock_result = | ||||
repo.try_with_wlock_no_wait(|| -> Result<(), CommandError> { | ||||
if let Some(mtime_boundary) = filesystem_time_at_status_start { | ||||
for hg_path in fixup { | ||||
use std::os::unix::fs::MetadataExt; | ||||
let fs_path = hg_path_to_path_buf(&hg_path) | ||||
.expect("HgPath conversion"); | ||||
// Specifically do not reuse `fs_metadata` from | ||||
// `unsure_is_clean` which was needed before reading | ||||
// contents. Here we access metadata again after reading | ||||
// content, in case it changed in the meantime. | ||||
let fs_metadata = repo | ||||
.working_directory_vfs() | ||||
.symlink_metadata(&fs_path)?; | ||||
|
r49272 | if let Some(mtime) = | ||
TruncatedTimestamp::for_reliable_mtime_of( | ||||
&fs_metadata, | ||||
&mtime_boundary, | ||||
) | ||||
.when_reading_file(&fs_path)? | ||||
{ | ||||
|
r49250 | let mode = fs_metadata.mode(); | ||
let size = fs_metadata.len() as u32 & RANGE_MASK_31BIT; | ||||
let mut entry = dmap | ||||
.get(&hg_path)? | ||||
.expect("ambiguous file not in dirstate"); | ||||
entry.set_clean(mode, size, mtime); | ||||
dmap.add_file(&hg_path, entry)?; | ||||
dirstate_write_needed = true | ||||
} | ||||
} | ||||
} | ||||
drop(dmap); // Avoid "already mutably borrowed" RefCell panics | ||||
if dirstate_write_needed { | ||||
repo.write_dirstate()? | ||||
} | ||||
Ok(()) | ||||
}); | ||||
match with_lock_result { | ||||
Ok(closure_result) => closure_result?, | ||||
Err(LockError::AlreadyHeld) => { | ||||
// Not updating the dirstate is not ideal but not critical: | ||||
// don’t keep our caller waiting until some other Mercurial | ||||
// process releases the lock. | ||||
} | ||||
Err(LockError::Other(HgError::IoError { error, .. })) | ||||
if error.kind() == io::ErrorKind::PermissionDenied => | ||||
{ | ||||
// `hg status` on a read-only repository is fine | ||||
} | ||||
Err(LockError::Other(error)) => { | ||||
// Report other I/O errors | ||||
Err(error)? | ||||
} | ||||
} | ||||
|
r47578 | Ok(()) | ||
} | ||||
|
r49282 | fn ignore_files(repo: &Repo, config: &Config) -> Vec<PathBuf> { | ||
let mut ignore_files = Vec::new(); | ||||
let repo_ignore = repo.working_directory_vfs().join(".hgignore"); | ||||
if repo_ignore.exists() { | ||||
ignore_files.push(repo_ignore) | ||||
} | ||||
for (key, value) in config.iter_section(b"ui") { | ||||
if key == b"ignore" || key.starts_with(b"ignore.") { | ||||
let path = get_path_from_bytes(value); | ||||
// TODO:Â expand "~/" and environment variable here, like Python | ||||
// does with `os.path.expanduser` and `os.path.expandvars` | ||||
let joined = repo.working_directory_path().join(path); | ||||
ignore_files.push(joined); | ||||
} | ||||
} | ||||
ignore_files | ||||
} | ||||
|
r49283 | struct DisplayStatusPaths<'a> { | ||
ui: &'a Ui, | ||||
|
r49171 | no_status: bool, | ||
|
r49284 | relativize: Option<RelativizePaths>, | ||
|
r49283 | } | ||
impl DisplayStatusPaths<'_> { | ||||
// Probably more elegant to use a Deref or Borrow trait rather than | ||||
// harcode HgPathBuf, but probably not really useful at this point | ||||
fn display( | ||||
&self, | ||||
status_prefix: &[u8], | ||||
|
r49285 | mut paths: Vec<StatusPath<'_>>, | ||
|
r49283 | ) -> Result<(), CommandError> { | ||
paths.sort_unstable(); | ||||
|
r49285 | for StatusPath { path, copy_source } in paths { | ||
|
r49284 | let relative; | ||
let path = if let Some(relativize) = &self.relativize { | ||||
relative = relativize.relativize(&path); | ||||
&*relative | ||||
} else { | ||||
path.as_bytes() | ||||
}; | ||||
|
r49283 | // TODO optim, probably lots of unneeded copies here, especially | ||
// if out stream is buffered | ||||
if self.no_status { | ||||
|
r49284 | self.ui.write_stdout(&format_bytes!(b"{}\n", path))? | ||
|
r49283 | } else { | ||
self.ui.write_stdout(&format_bytes!( | ||||
b"{} {}\n", | ||||
status_prefix, | ||||
path | ||||
|
r49284 | ))? | ||
|
r49283 | } | ||
|
r49285 | if let Some(source) = copy_source { | ||
self.ui.write_stdout(&format_bytes!( | ||||
b" {}\n", | ||||
source.as_bytes() | ||||
))? | ||||
} | ||||
|
r49171 | } | ||
|
r49283 | Ok(()) | ||
|
r47578 | } | ||
} | ||||
/// Check if a file is modified by comparing actual repo store and file system. | ||||
/// | ||||
/// This meant to be used for those that the dirstate cannot resolve, due | ||||
/// to time resolution limits. | ||||
|
r49167 | fn unsure_is_modified( | ||
|
r47578 | repo: &Repo, | ||
|
r48778 | manifest: &Manifest, | ||
|
r47578 | hg_path: &HgPath, | ||
|
r48778 | ) -> Result<bool, HgError> { | ||
|
r49168 | let vfs = repo.working_directory_vfs(); | ||
|
r49250 | let fs_path = hg_path_to_path_buf(hg_path).expect("HgPath conversion"); | ||
|
r49168 | let fs_metadata = vfs.symlink_metadata(&fs_path)?; | ||
let is_symlink = fs_metadata.file_type().is_symlink(); | ||||
r49220 | // TODO: Also account for `FALLBACK_SYMLINK` and `FALLBACK_EXEC` from the | |||
// dirstate | ||||
|
r49168 | let fs_flags = if is_symlink { | ||
Some(b'l') | ||||
} else if has_exec_bit(&fs_metadata) { | ||||
Some(b'x') | ||||
} else { | ||||
None | ||||
}; | ||||
|
r49166 | let entry = manifest | ||
|
r49324 | .find_by_path(hg_path)? | ||
|
r48778 | .expect("ambgious file not in p1"); | ||
|
r49168 | if entry.flags != fs_flags { | ||
return Ok(true); | ||||
} | ||||
|
r48778 | let filelog = repo.filelog(hg_path)?; | ||
|
r49302 | let fs_len = fs_metadata.len(); | ||
|
r49374 | let filelog_entry = | ||
filelog.entry_for_node(entry.node_id()?).map_err(|_| { | ||||
HgError::corrupted("filelog missing node from manifest") | ||||
})?; | ||||
|
r49378 | if filelog_entry.file_data_len_not_equal_to(fs_len) { | ||
// No need to read file contents: | ||||
// it cannot be equal if it has a different length. | ||||
return Ok(true); | ||||
} | ||||
let p1_filelog_data = filelog_entry.data()?; | ||||
let p1_contents = p1_filelog_data.file_data()?; | ||||
if p1_contents.len() as u64 != fs_len { | ||||
// No need to read file contents: | ||||
|
r49302 | // it cannot be equal if it has a different length. | ||
return Ok(true); | ||||
} | ||||
|
r47578 | |||
|
r49168 | let fs_contents = if is_symlink { | ||
get_bytes_from_os_string(vfs.read_link(fs_path)?.into_os_string()) | ||||
} else { | ||||
vfs.read(fs_path)? | ||||
}; | ||||
|
r49378 | Ok(p1_contents != &*fs_contents) | ||
|
r47578 | } | ||