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

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 31165

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