( )⚙ D12124 dirstate: introduce a "tracked-key" feature

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12124

dirstate: introduce a "tracked-key" feature
ClosedPublic

Authored by marmoute on Jan 31 2022, 10:30 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG568f63b5a30f: dirstate: introduce a "tracked-key" feature
Summary

A new format variant is introduced. When used, a tracked-key file will be
generated. That file will be update when the set of tracked file might have
changed. This will be useful for external automation (e.g. build tool) to be
notified when the set of relevant files changes.

One of the motivation for this changes is to mitigate effect dirstate-v2 has on
such automation. Since the dirstate file is updated much more frequently on
dirstate-v2, monitoring update to that file is no longer a viable strategy.

See the associated documentation for details about the feature

To prevent older client to update the repository without updating that file, a
new requirements is introduced.

The postfinalizegenerators business is a bit weird, so I'll likely clean that
up soon.

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

marmoute created this revision.Jan 31 2022, 10:30 AM
Alphare added a subscriber: Alphare.Feb 3 2022, 5:29 AM
Alphare added inline comments.
mercurial/helptext/config.txt
947

This will need a typo pass, we can figure it out outside of phab

mercurial/requirements.py
21

nit: should we drop the v1? We haven't done it for other requirements that I know of

marmoute added inline comments.Feb 3 2022, 11:01 AM
mercurial/requirements.py
21

The 1 format is very basic, but fits our needs.

I expect others might wants some more meaningful format so I and putting the versioning scheme forward early. The whole things is experimental still so we can probably iron this out by the freeze.

Alphare accepted this revision.Feb 3 2022, 11:02 AM
Alphare added inline comments.
mercurial/requirements.py
21

Sure

This revision is now accepted and ready to land.Feb 3 2022, 11:02 AM
marmoute added a commit: rHG568f63b5a30f: dirstate: introduce a "tracked-key" feature.Feb 3 2022, 11:51 AM
Closed by commit rHG568f63b5a30f: dirstate: introduce a "tracked-key" feature (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 32042

mercurial/configitems.py

b'format', b'format',
b'use-dirstate-v2', b'use-dirstate-v2',
default=False, default=False,
experimental=True, experimental=True,
alias=[(b'format', b'exp-rc-dirstate-v2')], alias=[(b'format', b'exp-rc-dirstate-v2')],
) )
coreconfigitem( coreconfigitem(
b'format', b'format',
b'exp-dirstate-tracked-key-version',
default=0,
experimental=True,
)
coreconfigitem(
b'format',
b'dotencode', b'dotencode',
default=True, default=True,
) )
coreconfigitem( coreconfigitem(
b'format', b'format',
b'generaldelta', b'generaldelta',
default=False, default=False,
experimental=True, experimental=True,

mercurial/dirstate.py

# dirstate.py - working directory tracking for mercurial # dirstate.py - working directory tracking for mercurial
# #
# Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>
# #
# 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.
from __future__ import absolute_import from __future__ import absolute_import
import collections import collections
import contextlib import contextlib
import errno import errno
import os import os
import stat import stat
import uuid
from .i18n import _ from .i18n import _
from .pycompat import delattr from .pycompat import delattr
from hgdemandimport import tracing from hgdemandimport import tracing
from . import ( from . import (
dirstatemap, dirstatemap,
encoding, encoding,
error, error,
match as matchmod, match as matchmod,
node,
pathutil, pathutil,
policy, policy,
pycompat, pycompat,
scmutil, scmutil,
sparse, sparse,
util, util,
) )
self, self,
opener, opener,
ui, ui,
root, root,
validate, validate,
sparsematchfn, sparsematchfn,
nodeconstants, nodeconstants,
use_dirstate_v2, use_dirstate_v2,
use_tracked_key=False,
): ):
"""Create a new dirstate object. """Create a new dirstate object.
opener is an open()-like callable that can be used to open the opener is an open()-like callable that can be used to open the
dirstate file; root is the root of the directory tracked by dirstate file; root is the root of the directory tracked by
the dirstate. the dirstate.
""" """
self._use_dirstate_v2 = use_dirstate_v2 self._use_dirstate_v2 = use_dirstate_v2
self._use_tracked_key = use_tracked_key
self._nodeconstants = nodeconstants self._nodeconstants = nodeconstants
self._opener = opener self._opener = opener
self._validate = validate self._validate = validate
self._root = root self._root = root
self._sparsematchfn = sparsematchfn self._sparsematchfn = sparsematchfn
# ntpath.join(root, '') of Python 2.7.9 does not add sep if root is # ntpath.join(root, '') of Python 2.7.9 does not add sep if root is
# UNC path pointing to root share (issue4557) # UNC path pointing to root share (issue4557)
self._rootdir = pathutil.normasprefix(root) self._rootdir = pathutil.normasprefix(root)
# True is any internal state may be different
self._dirty = False self._dirty = False
# True if the set of tracked file may be different
self._dirty_tracked_set = False
self._ui = ui self._ui = ui
self._filecache = {} self._filecache = {}
self._parentwriters = 0 self._parentwriters = 0
self._filename = b'dirstate' self._filename = b'dirstate'
self._filename_tk = b'dirstate-tracked-key'
self._pendingfilename = b'%s.pending' % self._filename self._pendingfilename = b'%s.pending' % self._filename
self._plchangecallbacks = {} self._plchangecallbacks = {}
self._origpl = None self._origpl = None
self._mapcls = dirstatemap.dirstatemap self._mapcls = dirstatemap.dirstatemap
# Access and cache cwd early, so we don't access it for the first time # Access and cache cwd early, so we don't access it for the first time
# after a working-copy update caused it to not exist (accessing it then # after a working-copy update caused it to not exist (accessing it then
# raises an exception). # raises an exception).
self._cwd self._cwd
This is different from localrepo.invalidatedirstate() because it always This is different from localrepo.invalidatedirstate() because it always
rereads the dirstate. Use localrepo.invalidatedirstate() if you want to rereads the dirstate. Use localrepo.invalidatedirstate() if you want to
check whether the dirstate has changed before rereading it.""" check whether the dirstate has changed before rereading it."""
for a in ("_map", "_branch", "_ignore"): for a in ("_map", "_branch", "_ignore"):
if a in self.__dict__: if a in self.__dict__:
delattr(self, a) delattr(self, a)
self._dirty = False self._dirty = False
self._dirty_tracked_set = False
self._parentwriters = 0 self._parentwriters = 0
self._origpl = None self._origpl = None
def copy(self, source, dest): def copy(self, source, dest):
"""Mark dest as a copy of source. Unmark dest if source is None.""" """Mark dest as a copy of source. Unmark dest if source is None."""
if source == dest: if source == dest:
return return
self._dirty = True self._dirty = True
""" """
self._dirty = True self._dirty = True
entry = self._map.get(filename) entry = self._map.get(filename)
if entry is None or not entry.tracked: if entry is None or not entry.tracked:
self._check_new_tracked_filename(filename) self._check_new_tracked_filename(filename)
pre_tracked = self._map.set_tracked(filename) pre_tracked = self._map.set_tracked(filename)
if reset_copy: if reset_copy:
self._map.copymap.pop(filename, None) self._map.copymap.pop(filename, None)
if pre_tracked:
self._dirty_tracked_set = True
return pre_tracked return pre_tracked
@requires_no_parents_change @requires_no_parents_change
def set_untracked(self, filename): def set_untracked(self, filename):
"""a "public" method for generic code to mark a file as untracked """a "public" method for generic code to mark a file as untracked
This function is to be called outside of "update/merge" case. For This function is to be called outside of "update/merge" case. For
example by a command like `hg remove X`. example by a command like `hg remove X`.
return True the file was previously tracked, False otherwise. return True the file was previously tracked, False otherwise.
""" """
ret = self._map.set_untracked(filename) ret = self._map.set_untracked(filename)
if ret: if ret:
self._dirty = True self._dirty = True
self._dirty_tracked_set = True
return ret return ret
@requires_no_parents_change @requires_no_parents_change
def set_clean(self, filename, parentfiledata): def set_clean(self, filename, parentfiledata):
"""record that the current state of the file on disk is known to be clean""" """record that the current state of the file on disk is known to be clean"""
self._dirty = True self._dirty = True
if not self._map[filename].tracked: if not self._map[filename].tracked:
self._check_new_tracked_filename(filename) self._check_new_tracked_filename(filename)
other processing. other processing.
""" """
# note: I do not think we need to double check name clash here since we # note: I do not think we need to double check name clash here since we
# are in a update/merge case that should already have taken care of # are in a update/merge case that should already have taken care of
# this. The test agrees # this. The test agrees
self._dirty = True self._dirty = True
old_entry = self._map.get(filename)
if old_entry is None:
prev_tracked = False
else:
prev_tracked = old_entry.tracked
if prev_tracked != wc_tracked:
self._dirty_tracked_set = True
self._map.reset_state( self._map.reset_state(
filename, filename,
wc_tracked, wc_tracked,
p1_tracked, p1_tracked,
p2_info=p2_info, p2_info=p2_info,
has_meaningful_mtime=not possibly_dirty, has_meaningful_mtime=not possibly_dirty,
parentfiledata=parentfiledata, parentfiledata=parentfiledata,
changes based on the former dirstate out can keep consistency. changes based on the former dirstate out can keep consistency.
""" """
return self._map.identity return self._map.identity
def write(self, tr): def write(self, tr):
if not self._dirty: if not self._dirty:
return return
filename = self._filename write_key = self._use_tracked_key and self._dirty_tracked_set
if tr: if tr:
# delay writing in-memory changes out # delay writing in-memory changes out
if write_key:
tr.addfilegenerator(
b'dirstate-0-key-pre',
(self._filename_tk,),
lambda f: self._write_tracked_key(tr, f),
location=b'plain',
)
tr.addfilegenerator( tr.addfilegenerator(
b'dirstate-1-main', b'dirstate-1-main',
(self._filename,), (self._filename,),
lambda f: self._writedirstate(tr, f), lambda f: self._writedirstate(tr, f),
location=b'plain', location=b'plain',
) )
if write_key:
tr.addfilegenerator(
b'dirstate-2-key-post',
(self._filename_tk,),
lambda f: self._write_tracked_key(tr, f),
location=b'plain',
)
return return
file = lambda f: self._opener(f, b"w", atomictemp=True, checkambig=True) file = lambda f: self._opener(f, b"w", atomictemp=True, checkambig=True)
if write_key:
# we change the key-file before changing the dirstate to make sure
# reading invalidate there cache before we start writing
with file(self._filename_tk) as f:
self._write_tracked_key(tr, f)
with file(self._filename) as f: with file(self._filename) as f:
self._writedirstate(tr, f) self._writedirstate(tr, f)
if write_key:
# we update the key-file after writing to make sure reader have a
# key that match the newly written content
with file(self._filename_tk) as f:
self._write_tracked_key(tr, f)
def addparentchangecallback(self, category, callback): def addparentchangecallback(self, category, callback):
"""add a callback to be called when the wd parents are changed """add a callback to be called when the wd parents are changed
Callback will be called with the following arguments: Callback will be called with the following arguments:
dirstate, (oldp1, oldp2), (newp1, newp2) dirstate, (oldp1, oldp2), (newp1, newp2)
Category is a unique identifier to allow overwriting an old callback Category is a unique identifier to allow overwriting an old callback
with a newer callback. with a newer callback.
""" """
self._plchangecallbacks[category] = callback self._plchangecallbacks[category] = callback
def _writedirstate(self, tr, st): def _writedirstate(self, tr, st):
# notify callbacks about parents change # notify callbacks about parents change
if self._origpl is not None and self._origpl != self._pl: if self._origpl is not None and self._origpl != self._pl:
for c, callback in sorted( for c, callback in sorted(
pycompat.iteritems(self._plchangecallbacks) pycompat.iteritems(self._plchangecallbacks)
): ):
callback(self, self._origpl, self._pl) callback(self, self._origpl, self._pl)
self._origpl = None self._origpl = None
self._map.write(tr, st) self._map.write(tr, st)
self._dirty = False self._dirty = False
self._dirty_tracked_set = False
def _write_tracked_key(self, tr, f):
key = node.hex(uuid.uuid4().bytes)
f.write(b"1\n%s\n" % key) # 1 is the format version
def _dirignore(self, f): def _dirignore(self, f):
if self._ignore(f): if self._ignore(f):
return True return True
for p in pathutil.finddirs(f): for p in pathutil.finddirs(f):
if self._ignore(p): if self._ignore(p):
return True return True
return False return False

mercurial/helptext/config.txt

$ hg debugupgraderepo \ $ hg debugupgraderepo \
--run \ --run \
--config format.use-dirstate-v2=False \ --config format.use-dirstate-v2=False \
--config storage.dirstate-v2.slow-path=allow --config storage.dirstate-v2.slow-path=allow
For a more comprehensive guide, see :hg:`help internals.dirstate-v2`. For a more comprehensive guide, see :hg:`help internals.dirstate-v2`.
``exp-dirstate-tracked-key-version``
AlphareUnsubmitted
Not Done

This will need a typo pass, we can figure it out outside of phab

Alphare: This will need a typo pass, we can figure it out outside of phab
Enable or disable the writing of "tracked key" file alongside the dirstate.
That "tracked-key" can help external automations to detect changes to the
set of tracked files.
Two values are currently supported:
- 0: no file is written (the default),
- 1: a file in version "1" is written.
The tracked-key is written in a new `.hg/dirstate-tracked-key`. That file
contains two lines:
- the first line is the file version (currently: 1),
- the second line contains the "tracked-key".
The tracked-key changes whenever the set of file tracked in the dirstate
changes. The general guarantees are:
- if the tracked key is identical, the set of tracked file MUST not have changed,
- if the tracked key is different, the set of tracked file MIGHT differ.
They are two "ways" to use this feature:
1) monitoring changes to the `.hg/dirstate-tracked-key`, if the file changes
the tracked set might have changed.
2) storing the value and comparing it to a later value. Beware that it is
impossible to achieve atomic writing or reading of the two files involved
files (`.hg/dirstate` and `.hg/dirstate-tracked-key`). So it is needed to
read the `tracked-key` files twice: before and after reading the tracked
set. The `tracked-key` is only usable as a cache key if it had the same
value in both cases and must be discarded otherwise.
To enforce that the `tracked-key` value can be used race-free (with double
reading as explained in (2)), the `.hg/dirstate-tracked-key` is written
twice: before and after we change the associated `.hg/dirstate` file.
``use-persistent-nodemap`` ``use-persistent-nodemap``
Enable or disable the "persistent-nodemap" feature which improves Enable or disable the "persistent-nodemap" feature which improves
performance if the Rust extensions are available. performance if the Rust extensions are available.
The "persistent-nodemap" persist the "node -> rev" on disk removing the The "persistent-nodemap" persist the "node -> rev" on disk removing the
need to dynamically build that mapping for each Mercurial invocation. This need to dynamically build that mapping for each Mercurial invocation. This
significantly reduces the startup cost of various local and server-side significantly reduces the startup cost of various local and server-side
operation for larger repositories. operation for larger repositories.

mercurial/localrepo.py

``reposetup()``. Generally speaking, ``hg.repository()`` should be ``reposetup()``. Generally speaking, ``hg.repository()`` should be
used. used.
""" """
_basesupported = { _basesupported = {
requirementsmod.BOOKMARKS_IN_STORE_REQUIREMENT, requirementsmod.BOOKMARKS_IN_STORE_REQUIREMENT,
requirementsmod.CHANGELOGV2_REQUIREMENT, requirementsmod.CHANGELOGV2_REQUIREMENT,
requirementsmod.COPIESSDC_REQUIREMENT, requirementsmod.COPIESSDC_REQUIREMENT,
requirementsmod.DIRSTATE_TRACKED_KEY_V1,
requirementsmod.DIRSTATE_V2_REQUIREMENT, requirementsmod.DIRSTATE_V2_REQUIREMENT,
requirementsmod.DOTENCODE_REQUIREMENT, requirementsmod.DOTENCODE_REQUIREMENT,
requirementsmod.FNCACHE_REQUIREMENT, requirementsmod.FNCACHE_REQUIREMENT,
requirementsmod.GENERALDELTA_REQUIREMENT, requirementsmod.GENERALDELTA_REQUIREMENT,
requirementsmod.INTERNAL_PHASE_REQUIREMENT, requirementsmod.INTERNAL_PHASE_REQUIREMENT,
requirementsmod.NODEMAP_REQUIREMENT, requirementsmod.NODEMAP_REQUIREMENT,
requirementsmod.RELATIVE_SHARED_REQUIREMENT, requirementsmod.RELATIVE_SHARED_REQUIREMENT,
requirementsmod.REVLOGV1_REQUIREMENT, requirementsmod.REVLOGV1_REQUIREMENT,
@repofilecache(b'dirstate') @repofilecache(b'dirstate')
def dirstate(self): def dirstate(self):
return self._makedirstate() return self._makedirstate()
def _makedirstate(self): def _makedirstate(self):
"""Extension point for wrapping the dirstate per-repo.""" """Extension point for wrapping the dirstate per-repo."""
sparsematchfn = lambda: sparse.matcher(self) sparsematchfn = lambda: sparse.matcher(self)
v2_req = requirementsmod.DIRSTATE_V2_REQUIREMENT v2_req = requirementsmod.DIRSTATE_V2_REQUIREMENT
tk = requirementsmod.DIRSTATE_TRACKED_KEY_V1
use_dirstate_v2 = v2_req in self.requirements use_dirstate_v2 = v2_req in self.requirements
use_tracked_key = tk in self.requirements
return dirstate.dirstate( return dirstate.dirstate(
self.vfs, self.vfs,
self.ui, self.ui,
self.root, self.root,
self._dirstatevalidate, self._dirstatevalidate,
sparsematchfn, sparsematchfn,
self.nodeconstants, self.nodeconstants,
use_dirstate_v2, use_dirstate_v2,
use_tracked_key=use_tracked_key,
) )
def _dirstatevalidate(self, node): def _dirstatevalidate(self, node):
try: try:
self.changelog.rev(node) self.changelog.rev(node)
return node return node
except error.LookupError: except error.LookupError:
if not self._dirstatevalidatewarned: if not self._dirstatevalidatewarned:
requirements -= to_drop requirements -= to_drop
requirements |= source_requirements requirements |= source_requirements
if createopts.get(b'sharedrelative'): if createopts.get(b'sharedrelative'):
requirements.add(requirementsmod.RELATIVE_SHARED_REQUIREMENT) requirements.add(requirementsmod.RELATIVE_SHARED_REQUIREMENT)
else: else:
requirements.add(requirementsmod.SHARED_REQUIREMENT) requirements.add(requirementsmod.SHARED_REQUIREMENT)
tracked_key = ui.configint(b'format', b'exp-dirstate-tracked-key-version')
if tracked_key:
if tracked_key != 1:
msg = _("ignoring unknown tracked key version: %d\n")
hint = _(
"see `hg help config.format.exp-dirstate-tracked-key-version"
)
ui.warn(msg % tracked_key, hint=hint)
else:
requirements.add(requirementsmod.DIRSTATE_TRACKED_KEY_V1)
return requirements return requirements
def checkrequirementscompat(ui, requirements): def checkrequirementscompat(ui, requirements):
"""Checks compatibility of repository requirements enabled and disabled. """Checks compatibility of repository requirements enabled and disabled.
Returns a set of requirements which needs to be dropped because dependend Returns a set of requirements which needs to be dropped because dependend
requirements are not enabled. Also warns users about it""" requirements are not enabled. Also warns users about it"""

mercurial/requirements.py

# being successful (repository sizes went up due to worse delta # being successful (repository sizes went up due to worse delta
# chains), and the code was deleted in 4.6. # chains), and the code was deleted in 4.6.
GENERALDELTA_REQUIREMENT = b'generaldelta' GENERALDELTA_REQUIREMENT = b'generaldelta'
DOTENCODE_REQUIREMENT = b'dotencode' DOTENCODE_REQUIREMENT = b'dotencode'
STORE_REQUIREMENT = b'store' STORE_REQUIREMENT = b'store'
FNCACHE_REQUIREMENT = b'fncache' FNCACHE_REQUIREMENT = b'fncache'
DIRSTATE_TRACKED_KEY_V1 = b'exp-dirstate-tracked-key-v1'
AlphareUnsubmitted
Not Done

nit: should we drop the v1? We haven't done it for other requirements that I know of

Alphare: nit: should we drop the v1? We haven't done it for other requirements that I know of
marmouteAuthorUnsubmitted
Done

The 1 format is very basic, but fits our needs.

I expect others might wants some more meaningful format so I and putting the versioning scheme forward early. The whole things is experimental still so we can probably iron this out by the freeze.

marmoute: The 1 format is very basic, but fits our needs. I expect others might wants some more…
AlphareUnsubmitted
Not Done

Sure

Alphare: Sure
DIRSTATE_V2_REQUIREMENT = b'dirstate-v2' DIRSTATE_V2_REQUIREMENT = b'dirstate-v2'
# When narrowing is finalized and no longer subject to format changes, # When narrowing is finalized and no longer subject to format changes,
# we should move this to just "narrow" or similar. # we should move this to just "narrow" or similar.
NARROW_REQUIREMENT = b'narrowhg-experimental' NARROW_REQUIREMENT = b'narrowhg-experimental'
# Enables sparse working directory usage # Enables sparse working directory usage
SPARSE_REQUIREMENT = b'exp-sparse' SPARSE_REQUIREMENT = b'exp-sparse'
# the requirements are stored in store's requires # the requirements are stored in store's requires
# * DIRSTATE_V2_REQUIREMENT affects .hg/dirstate, of which there is one per # * DIRSTATE_V2_REQUIREMENT affects .hg/dirstate, of which there is one per
# working directory. # working directory.
WORKING_DIR_REQUIREMENTS = { WORKING_DIR_REQUIREMENTS = {
SPARSE_REQUIREMENT, SPARSE_REQUIREMENT,
SHARED_REQUIREMENT, SHARED_REQUIREMENT,
RELATIVE_SHARED_REQUIREMENT, RELATIVE_SHARED_REQUIREMENT,
SHARESAFE_REQUIREMENT, SHARESAFE_REQUIREMENT,
DIRSTATE_TRACKED_KEY_V1,
DIRSTATE_V2_REQUIREMENT, DIRSTATE_V2_REQUIREMENT,
} }
# List of requirement that impact "stream-clone" (and hardlink clone) and # List of requirement that impact "stream-clone" (and hardlink clone) and
# cannot be changed in such cases. # cannot be changed in such cases.
# #
# requirements not in this list are safe to be altered during stream-clone. # requirements not in this list are safe to be altered during stream-clone.
# #

mercurial/transaction.py

version = 2 version = 2
# These are the file generators that should only be executed after the # These are the file generators that should only be executed after the
# finalizers are done, since they rely on the output of the finalizers (like # finalizers are done, since they rely on the output of the finalizers (like
# the changelog having been written). # the changelog having been written).
postfinalizegenerators = { postfinalizegenerators = {
b'bookmarks', b'bookmarks',
b'dirstate-0-key-pre',
b'dirstate-1-main', b'dirstate-1-main',
b'dirstate-2-key-post',
} }
GEN_GROUP_ALL = b'all' GEN_GROUP_ALL = b'all'
GEN_GROUP_PRE_FINALIZE = b'prefinalize' GEN_GROUP_PRE_FINALIZE = b'prefinalize'
GEN_GROUP_POST_FINALIZE = b'postfinalize' GEN_GROUP_POST_FINALIZE = b'postfinalize'
def active(func): def active(func):

tests/test-help.t

"usegeneraldelta" "usegeneraldelta"
"dotencode" "dotencode"
"usefncache" "usefncache"
"use-dirstate-v2" "use-dirstate-v2"
"exp-dirstate-tracked-key-version"
"use-persistent-nodemap" "use-persistent-nodemap"
"use-share-safe" "use-share-safe"
"usestore" "usestore"
"sparse-revlog" "sparse-revlog"

tests/test-status-tracked-key.t

  • This file was added.
==============================
Test the "tracked key" feature
==============================
The tracked key feature provide a file that get updated when the set of tracked
files get updated.
basic setup
$ cat << EOF >> $HGRCPATH
> [format]
> exp-dirstate-tracked-key-version=1
> EOF
$ hg init tracked-key-test
$ cd tracked-key-test
$ hg debugbuilddag '.+10' -n
$ hg log -G -T '{rev} {desc} {files}\n'
o 10 r10 nf10
|
o 9 r9 nf9
|
o 8 r8 nf8
|
o 7 r7 nf7
|
o 6 r6 nf6
|
o 5 r5 nf5
|
o 4 r4 nf4
|
o 3 r3 nf3
|
o 2 r2 nf2
|
o 1 r1 nf1
|
o 0 r0 nf0
$ hg up tip
11 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ hg files
nf0
nf1
nf10
nf2
nf3
nf4
nf5
nf6
nf7
nf8
nf9
key-file exists
-----------
The tracked key file should exist
$ ls -1 .hg/dirstate*
.hg/dirstate
.hg/dirstate-tracked-key
key-file stay the same if the tracked set is unchanged
------------------------------------------------------
(copy its content for later comparison)
$ cp .hg/dirstate-tracked-key ../key-bck
$ echo foo >> nf0
$ sleep 1
$ hg status
M nf0
$ diff --brief .hg/dirstate-tracked-key ../key-bck
$ hg revert -C nf0
$ sleep 1
$ hg status
$ diff --brief .hg/dirstate-tracked-key ../key-bck
key-file change if the tracked set is changed manually
------------------------------------------------------
adding a file to tracking
$ cp .hg/dirstate-tracked-key ../key-bck
$ echo x > x
$ hg add x
$ diff --brief .hg/dirstate-tracked-key ../key-bck
Files .hg/dirstate-tracked-key and ../key-bck differ
[1]
remove a file from tracking
(forget)
$ cp .hg/dirstate-tracked-key ../key-bck
$ hg forget x
$ diff --brief .hg/dirstate-tracked-key ../key-bck
Files .hg/dirstate-tracked-key and ../key-bck differ
[1]
(remove)
$ cp .hg/dirstate-tracked-key ../key-bck
$ hg remove nf1
$ diff --brief .hg/dirstate-tracked-key ../key-bck
Files .hg/dirstate-tracked-key and ../key-bck differ
[1]
key-file changes on revert (when applicable)
--------------------------------------------
$ cp .hg/dirstate-tracked-key ../key-bck
$ hg status
R nf1
? x
$ hg revert --all
undeleting nf1
$ hg status
? x
$ diff --brief .hg/dirstate-tracked-key ../key-bck
Files .hg/dirstate-tracked-key and ../key-bck differ
[1]
`hg update` does affect the key-file (when needed)
--------------------------------------------------
update changing the tracked set
(removing)
$ cp .hg/dirstate-tracked-key ../key-bck
$ hg status --rev . --rev '.#generations[-1]'
R nf10
$ hg up '.#generations[-1]'
0 files updated, 0 files merged, 1 files removed, 0 files unresolved
$ diff --brief .hg/dirstate-tracked-key ../key-bck
Files .hg/dirstate-tracked-key and ../key-bck differ
[1]
(adding)
$ cp .hg/dirstate-tracked-key ../key-bck
$ hg status --rev . --rev '.#generations[1]'
A nf10
$ hg up '.#generations[1]'
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ diff --brief .hg/dirstate-tracked-key ../key-bck
Files .hg/dirstate-tracked-key and ../key-bck differ
[1]
update not affecting the tracked set
$ echo foo >> nf0
$ hg commit -m foo
$ cp .hg/dirstate-tracked-key ../key-bck
$ hg status --rev . --rev '.#generations[-1]'
M nf0
$ hg up '.#generations[-1]'
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ diff --brief .hg/dirstate-tracked-key ../key-bck