This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10828

dirstate-v2: Add --dirs to debugdirstate command
ClosedPublic

Authored by SimonSapin on Jun 1 2021, 12:51 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG3b9914b28133: dirstate-v2: Add --dirs to debugdirstate command
Summary

hg debugdirstate --dirs also shows information stored in the dirstate
(for read_dir caching) about directories.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

SimonSapin created this revision.Jun 1 2021, 12:51 PM
SimonSapin added a commit: rHG3b9914b28133: dirstate-v2: Add --dirs to debugdirstate command.Jun 1 2021, 3:36 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG3b9914b28133: dirstate-v2: Add --dirs to debugdirstate command (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.
baymax updated this revision to Diff 28386.Jun 1 2021, 5:05 PM

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

Revision Contents
Changeset List

Diff 28386

mercurial/debugcommands.py

( (
b'', b'',
b'nodates', b'nodates',
None, None,
_(b'do not display the saved mtime (DEPRECATED)'), _(b'do not display the saved mtime (DEPRECATED)'),
), ),
(b'', b'dates', True, _(b'display the saved mtime')), (b'', b'dates', True, _(b'display the saved mtime')),
(b'', b'datesort', None, _(b'sort by saved mtime')), (b'', b'datesort', None, _(b'sort by saved mtime')),
(b'', b'dirs', False, _(b'display directories')),
], ],
_(b'[OPTION]...'), _(b'[OPTION]...'),
) )
def debugstate(ui, repo, **opts): def debugstate(ui, repo, **opts):
"""show the contents of the current dirstate""" """show the contents of the current dirstate"""
nodates = not opts['dates'] nodates = not opts['dates']
if opts.get('nodates') is not None: if opts.get('nodates') is not None:
nodates = True nodates = True
datesort = opts.get('datesort') datesort = opts.get('datesort')
if datesort: if datesort:
keyfunc = lambda x: (x[1][3], x[0]) # sort by mtime, then by filename keyfunc = lambda x: (x[1][3], x[0]) # sort by mtime, then by filename
else: else:
keyfunc = None # sort by filename keyfunc = None # sort by filename
for file_, ent in sorted(pycompat.iteritems(repo.dirstate), key=keyfunc): entries = list(pycompat.iteritems(repo.dirstate))
if opts['dirs']:
entries.extend(repo.dirstate.directories())
entries.sort(key=keyfunc)
for file_, ent in entries:
if ent[3] == -1: if ent[3] == -1:
timestr = b'unset ' timestr = b'unset '
elif nodates: elif nodates:
timestr = b'set ' timestr = b'set '
else: else:
timestr = time.strftime( timestr = time.strftime(
"%Y-%m-%d %H:%M:%S ", time.localtime(ent[3]) "%Y-%m-%d %H:%M:%S ", time.localtime(ent[3])
) )

mercurial/dirstate.py

def __iter__(self): def __iter__(self):
return iter(sorted(self._map)) return iter(sorted(self._map))
def items(self): def items(self):
return pycompat.iteritems(self._map) return pycompat.iteritems(self._map)
iteritems = items iteritems = items
def directories(self):
return self._map.directories()
def parents(self): def parents(self):
return [self._validate(p) for p in self._pl] return [self._validate(p) for p in self._pl]
def p1(self): def p1(self):
return self._validate(self._pl[0]) return self._validate(self._pl[0])
def p2(self): def p2(self):
return self._validate(self._pl[1]) return self._validate(self._pl[1])
return self._map return self._map
@propertycache @propertycache
def copymap(self): def copymap(self):
self.copymap = {} self.copymap = {}
self._map self._map
return self.copymap return self.copymap
def directories(self):
# Rust / dirstate-v2 only
return []
def clear(self): def clear(self):
self._map.clear() self._map.clear()
self.copymap.clear() self.copymap.clear()
self.setparents(self._nodeconstants.nullid, self._nodeconstants.nullid) self.setparents(self._nodeconstants.nullid, self._nodeconstants.nullid)
util.clearcachedproperty(self, b"_dirs") util.clearcachedproperty(self, b"_dirs")
util.clearcachedproperty(self, b"_alldirs") util.clearcachedproperty(self, b"_alldirs")
util.clearcachedproperty(self, b"filefoldmap") util.clearcachedproperty(self, b"filefoldmap")
util.clearcachedproperty(self, b"dirfoldmap") util.clearcachedproperty(self, b"dirfoldmap")
def get(self, *args, **kwargs): def get(self, *args, **kwargs):
return self._rustmap.get(*args, **kwargs) return self._rustmap.get(*args, **kwargs)
@property @property
def copymap(self): def copymap(self):
return self._rustmap.copymap() return self._rustmap.copymap()
def directories(self):
return self._rustmap.directories()
def preload(self): def preload(self):
self._rustmap self._rustmap
def clear(self): def clear(self):
self._rustmap.clear() self._rustmap.clear()
self.setparents( self.setparents(
self._nodeconstants.nullid, self._nodeconstants.nullid self._nodeconstants.nullid, self._nodeconstants.nullid
) )

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

packed.extend(filename.as_bytes()); packed.extend(filename.as_bytes());
if let Some(source) = copy_source { if let Some(source) = copy_source {
packed.push(b'\0'); packed.push(b'\0');
packed.extend(source.as_bytes()); packed.extend(source.as_bytes());
} }
} }
/// Seconds since the Unix epoch /// Seconds since the Unix epoch
pub struct Timestamp(pub u64); pub struct Timestamp(pub i64);
impl DirstateEntry { impl DirstateEntry {
pub fn mtime_is_ambiguous(&self, now: i32) -> bool { pub fn mtime_is_ambiguous(&self, now: i32) -> bool {
self.state == EntryState::Normal && self.mtime == now self.state == EntryState::Normal && self.mtime == now
} }
pub fn clear_ambiguous_mtime(&mut self, now: i32) -> bool { pub fn clear_ambiguous_mtime(&mut self, now: i32) -> bool {
let ambiguous = self.mtime_is_ambiguous(now); let ambiguous = self.mtime_is_ambiguous(now);

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

Ok(node.data.as_entry().map(|entry| entry.state)) Ok(node.data.as_entry().map(|entry| entry.state))
} }
NodeRef::OnDisk(node) => node.state(), NodeRef::OnDisk(node) => node.state(),
} }
} }
pub(super) fn cached_directory_mtime( pub(super) fn cached_directory_mtime(
&self, &self,
) -> Option<&on_disk::Timestamp> { ) -> Option<&'tree on_disk::Timestamp> {
match self { match self {
NodeRef::InMemory(_path, node) => match &node.data { NodeRef::InMemory(_path, node) => match &node.data {
NodeData::CachedDirectory { mtime } => Some(mtime), NodeData::CachedDirectory { mtime } => Some(mtime),
_ => None, _ => None,
}, },
NodeRef::OnDisk(node) => node.cached_directory_mtime(), NodeRef::OnDisk(node) => node.cached_directory_mtime(),
} }
} }
Box::new(filter_map_results(self.iter_nodes(), move |node| { Box::new(filter_map_results(self.iter_nodes(), move |node| {
Ok(if let Some(entry) = node.entry()? { Ok(if let Some(entry) = node.entry()? {
Some((node.full_path(self.on_disk)?, entry)) Some((node.full_path(self.on_disk)?, entry))
} else { } else {
None None
}) })
})) }))
} }
fn iter_directories(
&self,
) -> Box<
dyn Iterator<
Item = Result<
(&HgPath, Option<Timestamp>),
DirstateV2ParseError,
>,
> + Send
+ '_,
> {
Box::new(filter_map_results(self.iter_nodes(), move |node| {
Ok(if node.state()?.is_none() {
Some((
node.full_path(self.on_disk)?,
node.cached_directory_mtime()
.map(|mtime| Timestamp(mtime.seconds())),
))
} else {
None
})
}))
}
} }

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

-> Result<bool, DirstateV2ParseError>; -> Result<bool, DirstateV2ParseError>;
fn get( fn get(
&self, &self,
key: &HgPath, key: &HgPath,
) -> Result<Option<DirstateEntry>, DirstateV2ParseError>; ) -> Result<Option<DirstateEntry>, DirstateV2ParseError>;
fn iter(&self) -> StateMapIter<'_>; fn iter(&self) -> StateMapIter<'_>;
fn iter_directories(
&self,
) -> Box<
dyn Iterator<
Item = Result<
(&HgPath, Option<Timestamp>),
DirstateV2ParseError,
>,
> + Send
+ '_,
>;
} }
impl DirstateMapMethods for DirstateMap { impl DirstateMapMethods for DirstateMap {
fn clear(&mut self) { fn clear(&mut self) {
self.clear() self.clear()
} }
fn add_file( fn add_file(
key: &HgPath, key: &HgPath,
) -> Result<Option<DirstateEntry>, DirstateV2ParseError> { ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
Ok((&**self).get(key).cloned()) Ok((&**self).get(key).cloned())
} }
fn iter(&self) -> StateMapIter<'_> { fn iter(&self) -> StateMapIter<'_> {
Box::new((&**self).iter().map(|(key, value)| Ok((&**key, *value)))) Box::new((&**self).iter().map(|(key, value)| Ok((&**key, *value))))
} }
fn iter_directories(
&self,
) -> Box<
dyn Iterator<
Item = Result<
(&HgPath, Option<Timestamp>),
DirstateV2ParseError,
>,
> + Send
+ '_,
> {
Box::new(std::iter::empty())
}
} }

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

} }
fn as_timestamp(&self) -> &Timestamp { fn as_timestamp(&self) -> &Timestamp {
// Safety: same as above in `from_timestamp` // Safety: same as above in `from_timestamp`
unsafe { &*(self as *const Entry as *const Timestamp) } unsafe { &*(self as *const Entry as *const Timestamp) }
} }
} }
impl Timestamp {
pub fn seconds(&self) -> i64 {
self.seconds.get()
}
}
impl From<SystemTime> for Timestamp { impl From<SystemTime> for Timestamp {
fn from(system_time: SystemTime) -> Self { fn from(system_time: SystemTime) -> Self {
let (secs, nanos) = match system_time.duration_since(UNIX_EPOCH) { let (secs, nanos) = match system_time.duration_since(UNIX_EPOCH) {
Ok(duration) => { Ok(duration) => {
(duration.as_secs() as i64, duration.subsec_nanos()) (duration.as_secs() as i64, duration.subsec_nanos())
} }
Err(error) => { Err(error) => {
let negative = error.duration(); let negative = error.duration();

rust/hg-cpython/src/dirstate/dirstate_map.rs

def copymapitemsiter(&self) -> PyResult<CopyMapItemsIterator> { def copymapitemsiter(&self) -> PyResult<CopyMapItemsIterator> {
let leaked_ref = self.inner(py).leak_immutable(); let leaked_ref = self.inner(py).leak_immutable();
CopyMapItemsIterator::from_inner( CopyMapItemsIterator::from_inner(
py, py,
unsafe { leaked_ref.map(py, |o| o.copy_map_iter()) }, unsafe { leaked_ref.map(py, |o| o.copy_map_iter()) },
) )
} }
def directories(&self) -> PyResult<PyList> {
let dirs = PyList::new(py, &[]);
for item in self.inner(py).borrow().iter_directories() {
let (path, mtime) = item.map_err(|e| v2_error(py, e))?;
let path = PyBytes::new(py, path.as_bytes());
let mtime = mtime.map(|t| t.0).unwrap_or(-1);
let tuple = (path, (b'd', 0, 0, mtime));
dirs.append(py, tuple.to_py_object(py).into_object())
}
Ok(dirs)
}
}); });
impl DirstateMap { impl DirstateMap {
pub fn get_inner_mut<'a>( pub fn get_inner_mut<'a>(
&'a self, &'a self,
py: Python<'a>, py: Python<'a>,
) -> RefMut<'a, Box<dyn DirstateMapMethods + Send>> { ) -> RefMut<'a, Box<dyn DirstateMapMethods + Send>> {
self.inner(py).borrow_mut() self.inner(py).borrow_mut()

rust/hg-cpython/src/dirstate/dispatch.rs

key: &HgPath, key: &HgPath,
) -> Result<Option<DirstateEntry>, DirstateV2ParseError> { ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
self.get().get(key) self.get().get(key)
} }
fn iter(&self) -> StateMapIter<'_> { fn iter(&self) -> StateMapIter<'_> {
self.get().iter() self.get().iter()
} }
fn iter_directories(
&self,
) -> Box<
dyn Iterator<
Item = Result<
(&HgPath, Option<Timestamp>),
DirstateV2ParseError,
>,
> + Send
+ '_,
> {
self.get().iter_directories()
}
} }

rust/hg-cpython/src/parsers.rs

match pack_dirstate( match pack_dirstate(
&mut dirstate_map, &mut dirstate_map,
&copies?, &copies?,
DirstateParents { DirstateParents {
p1: p1.try_into().unwrap(), p1: p1.try_into().unwrap(),
p2: p2.try_into().unwrap(), p2: p2.try_into().unwrap(),
}, },
Timestamp(now.as_object().extract::<u64>(py)?), Timestamp(now.as_object().extract::<i64>(py)?),
) { ) {
Ok(packed) => { Ok(packed) => {
for (filename, entry) in dirstate_map.iter() { for (filename, entry) in dirstate_map.iter() {
dmap.set_item( dmap.set_item(
py, py,
PyBytes::new(py, filename.as_bytes()), PyBytes::new(py, filename.as_bytes()),
make_dirstate_tuple(py, &entry)?, make_dirstate_tuple(py, &entry)?,
)?; )?;

tests/test-completion.t

debugcolor: style debugcolor: style
debugcommands: debugcommands:
debugcomplete: options debugcomplete: options
debugcreatestreamclonebundle: debugcreatestreamclonebundle:
debugdag: tags, branches, dots, spaces debugdag: tags, branches, dots, spaces
debugdata: changelog, manifest, dir debugdata: changelog, manifest, dir
debugdate: extended debugdate: extended
debugdeltachain: changelog, manifest, dir, template debugdeltachain: changelog, manifest, dir, template
debugdirstate: nodates, dates, datesort debugdirstate: nodates, dates, datesort, dirs
debugdiscovery: old, nonheads, rev, seed, local-as-revs, remote-as-revs, ssh, remotecmd, insecure, template debugdiscovery: old, nonheads, rev, seed, local-as-revs, remote-as-revs, ssh, remotecmd, insecure, template
debugdownload: output debugdownload: output
debugextensions: template debugextensions: template
debugfileset: rev, all-files, show-matcher, show-stage debugfileset: rev, all-files, show-matcher, show-stage
debugformat: template debugformat: template
debugfsinfo: debugfsinfo:
debuggetbundle: head, common, type debuggetbundle: head, common, type
debugignore: debugignore:

tests/test-status.t

> A.hs > A.hs
> B.hs > B.hs
> ignored-folder/ > ignored-folder/
> EOF > EOF
$ hg st -i -I 're:.*\.hs$' $ hg st -i -I 're:.*\.hs$'
I A.hs I A.hs
I B.hs I B.hs
I ignored-folder/ctest.hs I ignored-folder/ctest.hs
#if dirstate-v2
Check read_dir caching
$ cd ..
$ hg init repo8
$ cd repo8
$ mkdir subdir
$ touch subdir/a subdir/b
$ hg ci -Aqm '#0'
The cached mtime is initially unset
$ hg debugdirstate --dirs --no-dates | grep '^d'
d 0 0 unset subdir
It is still not set when there are unknown files
$ touch subdir/unknown
$ hg status
? subdir/unknown
$ hg debugdirstate --dirs --no-dates | grep '^d'
d 0 0 unset subdir
Now the directory is eligible for caching, so its mtime is save in the dirstate
$ rm subdir/unknown
$ hg status
$ hg debugdirstate --dirs --no-dates | grep '^d'
d 0 0 set subdir
This time the command should be ever so slightly faster since it does not need `read_dir("subdir")`
$ hg status
Creating a new file changes the directory’s mtime, invalidating the cache
$ touch subdir/unknown
$ hg status
? subdir/unknown
#endif