( )⚙ D11774 rhg: Fix status desambiguation of symlinks and executable files

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11774

rhg: Fix status desambiguation of symlinks and executable files
ClosedPublic

Authored by SimonSapin on Nov 23 2021, 2:11 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGd5a91701f7dc: rhg: Fix status desambiguation of symlinks and executable files

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.Nov 23 2021, 2:11 PM
Alphare accepted this revision.Nov 24 2021, 6:36 AM
Alphare added a subscriber: Alphare.

This is maybe missing a // TODO fallback bits in dirstate-v2

This revision is now accepted and ready to land.Nov 24 2021, 6:36 AM
Alphare accepted this revision.Nov 26 2021, 9:45 AM
baymax updated this revision to Diff 31165.Nov 26 2021, 10:33 AM

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

Revision Contents
Changeset List

Diff 31152

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

} }
// TODO: other platforms // TODO: other platforms
#[cfg(unix)] #[cfg(unix)]
pub fn mode_changed( pub fn mode_changed(
&self, &self,
filesystem_metadata: &std::fs::Metadata, filesystem_metadata: &std::fs::Metadata,
) -> bool { ) -> bool {
use std::os::unix::fs::MetadataExt; let dirstate_exec_bit = (self.mode() as u32 & EXEC_BIT_MASK) != 0;
const EXEC_BIT_MASK: u32 = 0o100; let fs_exec_bit = has_exec_bit(filesystem_metadata);
let dirstate_exec_bit = (self.mode() as u32) & EXEC_BIT_MASK;
let fs_exec_bit = filesystem_metadata.mode() & EXEC_BIT_MASK;
dirstate_exec_bit != fs_exec_bit dirstate_exec_bit != fs_exec_bit
} }
/// Returns a `(state, mode, size, mtime)` tuple as for /// Returns a `(state, mode, size, mtime)` tuple as for
/// `DirstateMapMethods::debug_iter`. /// `DirstateMapMethods::debug_iter`.
pub fn debug_tuple(&self) -> (u8, i32, i32, i32) { pub fn debug_tuple(&self) -> (u8, i32, i32, i32) {
(self.state().into(), self.mode(), self.size(), self.mtime()) (self.state().into(), self.mode(), self.size(), self.mtime())
} }
match self { match self {
EntryState::Normal => b'n', EntryState::Normal => b'n',
EntryState::Added => b'a', EntryState::Added => b'a',
EntryState::Removed => b'r', EntryState::Removed => b'r',
EntryState::Merged => b'm', EntryState::Merged => b'm',
} }
} }
} }
const EXEC_BIT_MASK: u32 = 0o100;
pub fn has_exec_bit(metadata: &std::fs::Metadata) -> bool {
// TODO: How to handle executable permissions on Windows?
use std::os::unix::fs::MetadataExt;
(metadata.mode() & EXEC_BIT_MASK) != 0
}

rust/hg-core/src/vfs.rs

struct FileNotFound(std::io::Error, PathBuf); struct FileNotFound(std::io::Error, PathBuf);
impl Vfs<'_> { impl Vfs<'_> {
pub fn join(&self, relative_path: impl AsRef<Path>) -> PathBuf { pub fn join(&self, relative_path: impl AsRef<Path>) -> PathBuf {
self.base.join(relative_path) self.base.join(relative_path)
} }
pub fn symlink_metadata(
&self,
relative_path: impl AsRef<Path>,
) -> Result<std::fs::Metadata, HgError> {
let path = self.join(relative_path);
std::fs::symlink_metadata(&path).when_reading_file(&path)
}
pub fn read_link(
&self,
relative_path: impl AsRef<Path>,
) -> Result<PathBuf, HgError> {
let path = self.join(relative_path);
std::fs::read_link(&path).when_reading_file(&path)
}
pub fn read( pub fn read(
&self, &self,
relative_path: impl AsRef<Path>, relative_path: impl AsRef<Path>,
) -> Result<Vec<u8>, HgError> { ) -> Result<Vec<u8>, HgError> {
let path = self.join(relative_path); let path = self.join(relative_path);
std::fs::read(&path).when_reading_file(&path) std::fs::read(&path).when_reading_file(&path)
} }

rust/rhg/src/commands/status.rs

// status.rs // status.rs
// //
// Copyright 2020, Georges Racinet <georges.racinets@octobus.net> // Copyright 2020, Georges Racinet <georges.racinets@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::{Ui, UiError}; use crate::ui::{Ui, UiError};
use crate::utils::path_utils::relativize_paths; use crate::utils::path_utils::relativize_paths;
use clap::{Arg, SubCommand}; use clap::{Arg, SubCommand};
use hg; use hg;
use hg::config::Config; use hg::config::Config;
use hg::dirstate::TruncatedTimestamp; use hg::dirstate::{has_exec_bit, TruncatedTimestamp};
use hg::errors::HgError; use hg::errors::HgError;
use hg::manifest::Manifest; use hg::manifest::Manifest;
use hg::matchers::AlwaysMatcher; use hg::matchers::AlwaysMatcher;
use hg::repo::Repo; use hg::repo::Repo;
use hg::utils::files::get_bytes_from_os_string;
use hg::utils::hg_path::{hg_path_to_os_string, HgPath}; use hg::utils::hg_path::{hg_path_to_os_string, HgPath};
use hg::{HgPathCow, StatusOptions}; use hg::{HgPathCow, StatusOptions};
use log::{info, warn}; use log::{info, warn};
use std::borrow::Cow; use std::borrow::Cow;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
Show changed files in the working directory Show changed files in the working directory
} }
Ok(()) Ok(())
} }
/// Check if a file is modified by comparing actual repo store and file system. /// 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 /// This meant to be used for those that the dirstate cannot resolve, due
/// to time resolution limits. /// to time resolution limits.
///
/// TODO: detect permission bits and similar metadata modifications
fn unsure_is_modified( fn unsure_is_modified(
repo: &Repo, repo: &Repo,
manifest: &Manifest, manifest: &Manifest,
hg_path: &HgPath, hg_path: &HgPath,
) -> Result<bool, HgError> { ) -> Result<bool, HgError> {
let vfs = repo.working_directory_vfs();
let fs_path = hg_path_to_os_string(hg_path).expect("HgPath conversion");
let fs_metadata = vfs.symlink_metadata(&fs_path)?;
let is_symlink = fs_metadata.file_type().is_symlink();
// TODO: Also account for `FALLBACK_SYMLINK` and `FALLBACK_EXEC` from the dirstate
let fs_flags = if is_symlink {
Some(b'l')
} else if has_exec_bit(&fs_metadata) {
Some(b'x')
} else {
None
};
let entry = manifest let entry = manifest
.find_file(hg_path)? .find_file(hg_path)?
.expect("ambgious file not in p1"); .expect("ambgious file not in p1");
if entry.flags != fs_flags {
return Ok(true);
}
let filelog = repo.filelog(hg_path)?; let filelog = repo.filelog(hg_path)?;
let filelog_entry = let filelog_entry =
filelog.data_for_node(entry.node_id()?).map_err(|_| { filelog.data_for_node(entry.node_id()?).map_err(|_| {
HgError::corrupted("filelog missing node from manifest") HgError::corrupted("filelog missing node from manifest")
})?; })?;
let contents_in_p1 = filelog_entry.data()?; let contents_in_p1 = filelog_entry.data()?;
let fs_path = hg_path_to_os_string(hg_path).expect("HgPath conversion"); let fs_contents = if is_symlink {
let fs_contents = repo.working_directory_vfs().read(fs_path)?; get_bytes_from_os_string(vfs.read_link(fs_path)?.into_os_string())
} else {
vfs.read(fs_path)?
};
return Ok(contents_in_p1 != &*fs_contents); return Ok(contents_in_p1 != &*fs_contents);
} }

tests/test-execute-bit.t

#require execbit #require execbit
TODO: fix rhg bugs that make this test fail when status is enabled
$ unset RHG_STATUS
$ hg init $ hg init
$ echo a > a $ echo a > a
$ hg ci -Am'not executable' $ hg ci -Am'not executable'
adding a adding a
$ chmod +x a $ chmod +x a
$ hg ci -m'executable' $ hg ci -m'executable'
$ hg id $ hg id

tests/test-merge-exec.t

=============================================== ===============================================
Testing merge involving change to the exec flag Testing merge involving change to the exec flag
=============================================== ===============================================
#require execbit #require execbit
TODO: fix rhg bugs that make this test fail when status is enabled
$ unset RHG_STATUS
Initial setup Initial setup
============== ==============
$ hg init base-repo $ hg init base-repo
$ cd base-repo $ cd base-repo
$ cat << EOF > a $ cat << EOF > a
> 1 > 1

tests/test-merge-types.t

#require symlink execbit #require symlink execbit
TODO: fix rhg bugs that make this test fail when status is enabled
$ unset RHG_STATUS
$ tellmeabout() { $ tellmeabout() {
> if [ -h $1 ]; then > if [ -h $1 ]; then
> echo $1 is a symlink: > echo $1 is a symlink:
> $TESTDIR/readlink.py $1 > $TESTDIR/readlink.py $1
> elif [ -x $1 ]; then > elif [ -x $1 ]; then
> echo $1 is an executable file with content: > echo $1 is an executable file with content:
> cat $1 > cat $1
> else > else

tests/test-symlinks.t

#require symlink #require symlink
#testcases dirstate-v1 dirstate-v2 #testcases dirstate-v1 dirstate-v2
#if dirstate-v2 #if dirstate-v2
$ cat >> $HGRCPATH << EOF $ cat >> $HGRCPATH << EOF
> [format] > [format]
> exp-rc-dirstate-v2=1 > exp-rc-dirstate-v2=1
> [storage] > [storage]
> dirstate-v2.slow-path=allow > dirstate-v2.slow-path=allow
> EOF > EOF
#endif #endif
TODO: fix rhg bugs that make this test fail when status is enabled
$ unset RHG_STATUS
== tests added in 0.7 == == tests added in 0.7 ==
$ hg init test-symlinks-0.7; cd test-symlinks-0.7; $ hg init test-symlinks-0.7; cd test-symlinks-0.7;
$ touch foo; ln -s foo bar; ln -s nonexistent baz $ touch foo; ln -s foo bar; ln -s nonexistent baz
import with add and addremove -- symlink walking should _not_ screwup. import with add and addremove -- symlink walking should _not_ screwup.
$ hg add $ hg add