( )⚙ D11750 commit: prevent possible race that results in bad dirstate

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11750

commit: prevent possible race that results in bad dirstate
AbandonedPublic

Authored by valentin.gatienbaron on Nov 10 2021, 8:24 PM.

Details

Reviewers
marmoute
Group Reviewers
hg-reviewers
Summary

I'm getting reports of wrongly clean hg status, that get fixed by
running hg debugrebuilddirstate, which I suspect is the issue
below. And if it's not, it still seems good to fix.

hg commit works by adding new version of files from the working copy
into the store, then later lstat'ing the files in the working copy to
mark them as clean in the dirstate. This is racy, since the files can
be modified in the meantime.

Reduce the race by doing the lstat immediately after adding new file
versions into the store, and guarantee that the file size recorded in
the dirstate is correct (i.e. is the file size from the store).

Diff Detail

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

Event Timeline

marmoute requested changes to this revision.Dec 3 2021, 12:09 PM
marmoute added a subscriber: marmoute.

I can confirm that his changeset is no longer necessary now that no longer try to record dirstate cache during hg commit.

This revision now requires changes to proceed.Dec 3 2021, 12:09 PM

Revision Contents
Changeset List

Diff 31058

hgext/eol.py

# as modified. But if we cannot lock the # as modified. But if we cannot lock the
# repository, then we can also not make a commit, # repository, then we can also not make a commit,
# so ignore the error. # so ignore the error.
pass pass
finally: finally:
if wlock is not None: if wlock is not None:
wlock.release() wlock.release()
def commitctx(self, ctx, error=False, origctx=None): def commitctx(self, ctx, error=False, origctx=None, filedata=None):
for f in sorted(ctx.added() + ctx.modified()): for f in sorted(ctx.added() + ctx.modified()):
if not self._eolmatch(f): if not self._eolmatch(f):
continue continue
fctx = ctx[f] fctx = ctx[f]
if fctx is None: if fctx is None:
continue continue
data = fctx.data() data = fctx.data()
if stringutil.binary(data): if stringutil.binary(data):
# We should not abort here, since the user should # We should not abort here, since the user should
# be able to say "** = native" to automatically # be able to say "** = native" to automatically
# have all non-binary files taken care of. # have all non-binary files taken care of.
continue continue
if inconsistenteol(data): if inconsistenteol(data):
raise errormod.Abort( raise errormod.Abort(
_(b"inconsistent newline style in %s\n") % f _(b"inconsistent newline style in %s\n") % f
) )
return super(eolrepo, self).commitctx(ctx, error, origctx) return super(eolrepo, self).commitctx(ctx, error, origctx, filedata)
repo.__class__ = eolrepo repo.__class__ = eolrepo
repo._hgcleardirstate() repo._hgcleardirstate()

hgext/keyword.py

# use custom commitctx for user commands # use custom commitctx for user commands
# other extensions can still wrap repo.commitctx directly # other extensions can still wrap repo.commitctx directly
self.commitctx = self.kwcommitctx self.commitctx = self.kwcommitctx
try: try:
return super(kwrepo, self).commit(*args, **opts) return super(kwrepo, self).commit(*args, **opts)
finally: finally:
del self.commitctx del self.commitctx
def kwcommitctx(self, ctx, error=False, origctx=None): def kwcommitctx(self, ctx, error=False, origctx=None, filedata=None):
n = super(kwrepo, self).commitctx(ctx, error, origctx) n = super(kwrepo, self).commitctx(
ctx, error, origctx, filedata=None
)
# no lock needed, only called from repo.commit() which already locks # no lock needed, only called from repo.commit() which already locks
if not kwt.postcommit: if not kwt.postcommit:
restrict = kwt.restrict restrict = kwt.restrict
kwt.restrict = True kwt.restrict = True
kwt.overwrite( kwt.overwrite(
self[n], sorted(ctx.added() + ctx.modified()), False, True self[n], sorted(ctx.added() + ctx.modified()), False, True
) )
kwt.restrict = restrict kwt.restrict = restrict

hgext/largefiles/reposetup.py

self.lfstatus = True self.lfstatus = True
return scmutil.status(*result) return scmutil.status(*result)
def commitctx(self, ctx, *args, **kwargs): def commitctx(self, ctx, *args, **kwargs):
node = super(lfilesrepo, self).commitctx(ctx, *args, **kwargs) node = super(lfilesrepo, self).commitctx(ctx, *args, **kwargs)
class lfilesctx(ctx.__class__): class lfilesctx(ctx.__class__):
def markcommitted(self, node): def markcommitted(self, node, filedata=None):
orig = super(lfilesctx, self).markcommitted orig = super(lfilesctx, self).markcommitted
return lfutil.markcommitted(orig, self, node) return lfutil.markcommitted(orig, self, node)
ctx.__class__ = lfilesctx ctx.__class__ = lfilesctx
return node return node
# Before commit, largefile standins have not had their # Before commit, largefile standins have not had their
# contents updated to reflect the hash of their largefile. # contents updated to reflect the hash of their largefile.

hgext/lfs/__init__.py

if not repo.local(): if not repo.local():
return return
repo.svfs.lfslocalblobstore = blobstore.local(repo) repo.svfs.lfslocalblobstore = blobstore.local(repo)
repo.svfs.lfsremoteblobstore = blobstore.remote(repo) repo.svfs.lfsremoteblobstore = blobstore.remote(repo)
class lfsrepo(repo.__class__): class lfsrepo(repo.__class__):
@localrepo.unfilteredmethod @localrepo.unfilteredmethod
def commitctx(self, ctx, error=False, origctx=None): def commitctx(self, ctx, error=False, origctx=None, filedata=None):
repo.svfs.options[b'lfstrack'] = _trackedmatcher(self) repo.svfs.options[b'lfstrack'] = _trackedmatcher(self)
return super(lfsrepo, self).commitctx(ctx, error, origctx=origctx) return super(lfsrepo, self).commitctx(
ctx, error, origctx=origctx, filedata=filedata
)
repo.__class__ = lfsrepo repo.__class__ = lfsrepo
if b'lfs' not in repo.requirements: if b'lfs' not in repo.requirements:
def checkrequireslfs(ui, repo, **kwargs): def checkrequireslfs(ui, repo, **kwargs):
if b'lfs' in repo.requirements: if b'lfs' in repo.requirements:
return 0 return 0

hgext/remotefilelog/shallowrepo.py

if self.shallowmatch(path): if self.shallowmatch(path):
return remotefilectx.remotefilectx(self, path, *args, **kwargs) return remotefilectx.remotefilectx(self, path, *args, **kwargs)
else: else:
return super(shallowrepository, self).filectx( return super(shallowrepository, self).filectx(
path, *args, **kwargs path, *args, **kwargs
) )
@localrepo.unfilteredmethod @localrepo.unfilteredmethod
def commitctx(self, ctx, error=False, origctx=None): def commitctx(self, ctx, error=False, origctx=None, filedata=None):
"""Add a new revision to current repository. """Add a new revision to current repository.
Revision information is passed via the context argument. Revision information is passed via the context argument.
""" """
# some contexts already have manifest nodes, they don't need any # some contexts already have manifest nodes, they don't need any
# prefetching (for example if we're just editing a commit message # prefetching (for example if we're just editing a commit message
# we can reuse manifest # we can reuse manifest
if not ctx.manifestnode(): if not ctx.manifestnode():
# prefetch files that will likely be compared # prefetch files that will likely be compared
m1 = ctx.p1().manifest() m1 = ctx.p1().manifest()
files = [] files = []
for f in ctx.modified() + ctx.added(): for f in ctx.modified() + ctx.added():
fparent1 = m1.get(f, self.nullid) fparent1 = m1.get(f, self.nullid)
if fparent1 != self.nullid: if fparent1 != self.nullid:
files.append((f, hex(fparent1))) files.append((f, hex(fparent1)))
self.fileservice.prefetch(files) self.fileservice.prefetch(files)
return super(shallowrepository, self).commitctx( return super(shallowrepository, self).commitctx(
ctx, error=error, origctx=origctx ctx, error=error, origctx=origctx, filedata=filedata
) )
def backgroundprefetch( def backgroundprefetch(
self, revs, base=None, repack=False, pats=None, opts=None self, revs, base=None, repack=False, pats=None, opts=None
): ):
"""Runs prefetch in background with optional repack""" """Runs prefetch in background with optional repack"""
cmd = [procutil.hgexecutable(), b'-R', repo.origroot, b'prefetch'] cmd = [procutil.hgexecutable(), b'-R', repo.origroot, b'prefetch']
if repack: if repack:

mercurial/commit.py

# commit.py - fonction to perform commit # commit.py - fonction to perform commit
# #
# 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 errno import errno
from .i18n import _ from .i18n import _
from .node import ( from .node import (
hex, hex,
nullrev, nullrev,
) )
from .dirstateutils import timestamp
from . import ( from . import (
context, context,
mergestate, mergestate,
metadata, metadata,
phases, phases,
scmutil, scmutil,
subrepoutil, subrepoutil,
) )
writefilecopymeta = writecopiesto != b'changeset-only' writefilecopymeta = writecopiesto != b'changeset-only'
writechangesetcopy = writecopiesto in ( writechangesetcopy = writecopiesto in (
b'changeset-only', b'changeset-only',
b'compatibility', b'compatibility',
) )
return writechangesetcopy, writefilecopymeta return writechangesetcopy, writefilecopymeta
def commitctx(repo, ctx, error=False, origctx=None): def commitctx(repo, ctx, error=False, origctx=None, filedata=None):
"""Add a new revision to the target repository. """Add a new revision to the target repository.
Revision information is passed via the context argument. Revision information is passed via the context argument.
ctx.files() should list all files involved in this commit, i.e. ctx.files() should list all files involved in this commit, i.e.
modified/added/removed files. On merge, it may be wider than the modified/added/removed files. On merge, it may be wider than the
ctx.files() to be committed, since any file nodes derived directly ctx.files() to be committed, since any file nodes derived directly
from p1 or p2 are excluded from the committed ctx.files(). from p1 or p2 are excluded from the committed ctx.files().
origctx is for convert to work around the problem that bug origctx is for convert to work around the problem that bug
fixes to the files list in changesets change hashes. For fixes to the files list in changesets change hashes. For
convert to be the identity, it can pass an origctx and this convert to be the identity, it can pass an origctx and this
function will use the same files list when it makes sense to function will use the same files list when it makes sense to
do so. do so.
""" """
repo = repo.unfiltered() repo = repo.unfiltered()
p1, p2 = ctx.p1(), ctx.p2() p1, p2 = ctx.p1(), ctx.p2()
user = ctx.user() user = ctx.user()
with repo.lock(), repo.transaction(b"commit") as tr: with repo.lock(), repo.transaction(b"commit") as tr:
mn, files = _prepare_files(tr, ctx, error=error, origctx=origctx) mn, files = _prepare_files(
tr, ctx, filedata, error=error, origctx=origctx
)
extra = ctx.extra().copy() extra = ctx.extra().copy()
if extra is not None: if extra is not None:
for name in ( for name in (
b'p1copies', b'p1copies',
b'p2copies', b'p2copies',
b'filesadded', b'filesadded',
# if a parent have higher the resulting phase will # if a parent have higher the resulting phase will
# be compliant anyway # be compliant anyway
# #
# if minimal phase was 0 we don't need to retract anything # if minimal phase was 0 we don't need to retract anything
phases.registernew(repo, tr, targetphase, [rev]) phases.registernew(repo, tr, targetphase, [rev])
return n return n
def _prepare_files(tr, ctx, error=False, origctx=None): def _prepare_files(tr, ctx, filedata, error=False, origctx=None):
repo = ctx.repo() repo = ctx.repo()
p1 = ctx.p1() p1 = ctx.p1()
writechangesetcopy, writefilecopymeta = _write_copy_meta(repo) writechangesetcopy, writefilecopymeta = _write_copy_meta(repo)
files = metadata.ChangingFiles() files = metadata.ChangingFiles()
ms = mergestate.mergestate.read(repo) ms = mergestate.mergestate.read(repo)
salvaged = _get_salvaged(repo, ms, ctx) salvaged = _get_salvaged(repo, ms, ctx)
for s in salvaged: for s in salvaged:
files.mark_salvaged(s) files.mark_salvaged(s)
if ctx.manifestnode(): if ctx.manifestnode():
# reuse an existing manifest revision # reuse an existing manifest revision
repo.ui.debug(b'reusing known manifest\n') repo.ui.debug(b'reusing known manifest\n')
mn = ctx.manifestnode() mn = ctx.manifestnode()
files.update_touched(ctx.files()) files.update_touched(ctx.files())
if writechangesetcopy: if writechangesetcopy:
files.update_added(ctx.filesadded()) files.update_added(ctx.filesadded())
files.update_removed(ctx.filesremoved()) files.update_removed(ctx.filesremoved())
elif not ctx.files(): elif not ctx.files():
repo.ui.debug(b'reusing manifest from p1 (no file change)\n') repo.ui.debug(b'reusing manifest from p1 (no file change)\n')
mn = p1.manifestnode() mn = p1.manifestnode()
else: else:
mn = _process_files(tr, ctx, ms, files, error=error) mn = _process_files(tr, ctx, ms, files, filedata, error=error)
if origctx and origctx.manifestnode() == mn: if origctx and origctx.manifestnode() == mn:
origfiles = origctx.files() origfiles = origctx.files()
assert files.touched.issubset(origfiles) assert files.touched.issubset(origfiles)
files.update_touched(origfiles) files.update_touched(origfiles)
if writechangesetcopy: if writechangesetcopy:
files.update_copies_from_p1(ctx.p1copies()) files.update_copies_from_p1(ctx.p1copies())
for fname in sorted(ms.allextras().keys()): for fname in sorted(ms.allextras().keys()):
might_removed = ms.extras(fname).get(b'merge-removal-candidate') might_removed = ms.extras(fname).get(b'merge-removal-candidate')
if might_removed == b'yes': if might_removed == b'yes':
if fname in ctx: if fname in ctx:
salvaged.append(fname) salvaged.append(fname)
return salvaged return salvaged
def _process_files(tr, ctx, ms, files, error=False): def _process_files(tr, ctx, ms, files, filedata, error=False):
repo = ctx.repo() repo = ctx.repo()
p1 = ctx.p1() p1 = ctx.p1()
p2 = ctx.p2() p2 = ctx.p2()
writechangesetcopy, writefilecopymeta = _write_copy_meta(repo) writechangesetcopy, writefilecopymeta = _write_copy_meta(repo)
m1ctx = p1.manifestctx() m1ctx = p1.manifestctx()
m2ctx = p2.manifestctx() m2ctx = p2.manifestctx()
repo.ui.note(uipathfn(f) + b"\n") repo.ui.note(uipathfn(f) + b"\n")
try: try:
fctx = ctx[f] fctx = ctx[f]
if fctx is None: if fctx is None:
removed.append(f) removed.append(f)
else: else:
added.append(f) added.append(f)
m[f], is_touched = _filecommit( m[f], is_touched = _filecommit(
repo, fctx, m1, m2, linkrev, tr, writefilecopymeta, ms repo,
fctx,
m1,
m2,
linkrev,
tr,
writefilecopymeta,
ms,
filedata,
) )
if is_touched: if is_touched:
if is_touched == 'added': if is_touched == 'added':
files.mark_added(f) files.mark_added(f)
elif is_touched == 'merged': elif is_touched == 'merged':
files.mark_merged(f) files.mark_merged(f)
else: else:
files.mark_touched(f) files.mark_touched(f)
if not rf(f): if not rf(f):
files.mark_removed(f) files.mark_removed(f)
mn = _commit_manifest(tr, linkrev, ctx, mctx, m, files.touched, added, drop) mn = _commit_manifest(tr, linkrev, ctx, mctx, m, files.touched, added, drop)
return mn return mn
def storefiledata(repo, filedata, fctx, size):
if (
not repo._encodefilterpats
and not repo._decodefilterpats
and filedata is not None
):
# if there are encode or decode filters, size in store is not
# the same as size in dirstate, so this code wouldn't work the
# way it is currently written
s = fctx.lstat()
mode = s.st_mode
mtime = timestamp.mtime_of(s)
# for dirstate.update_file's parentfiledata argument:
filedata[fctx.path()] = (mode, size(), mtime)
def _filecommit( def _filecommit(
repo, repo,
fctx, fctx,
manifest1, manifest1,
manifest2, manifest2,
linkrev, linkrev,
tr, tr,
includecopymeta, includecopymeta,
ms, ms,
filedata,
): ):
""" """
commit an individual file as part of a larger transaction commit an individual file as part of a larger transaction
input: input:
fctx: a file context with the content we are trying to commit fctx: a file context with the content we are trying to commit
manifest1: manifest of changeset first parent manifest1: manifest of changeset first parent
if ( if (
fparent1 != repo.nullid fparent1 != repo.nullid
and manifest1.flags(fname) != fctx.flags() and manifest1.flags(fname) != fctx.flags()
) or ( ) or (
fparent2 != repo.nullid fparent2 != repo.nullid
and manifest2.flags(fname) != fctx.flags() and manifest2.flags(fname) != fctx.flags()
): ):
touched = 'modified' touched = 'modified'
storefiledata(repo, filedata, fctx, fctx.size)
return node, touched return node, touched
flog = repo.file(fname) flog = repo.file(fname)
meta = {} meta = {}
cfname = fctx.copysource() cfname = fctx.copysource()
fnode = None fnode = None
if cfname and cfname != fname: if cfname and cfname != fname:
touched = 'merged' touched = 'merged'
fnode = flog.add(text, meta, tr, linkrev, fparent1, fparent2) fnode = flog.add(text, meta, tr, linkrev, fparent1, fparent2)
# are just the flags changed during merge? # are just the flags changed during merge?
elif fname in manifest1 and manifest1.flags(fname) != fctx.flags(): elif fname in manifest1 and manifest1.flags(fname) != fctx.flags():
touched = 'modified' touched = 'modified'
fnode = fparent1 fnode = fparent1
else: else:
fnode = fparent1 fnode = fparent1
storefiledata(repo, filedata, fctx, lambda: len(text))
return fnode, touched return fnode, touched
def _commit_manifest(tr, linkrev, ctx, mctx, manifest, files, added, drop): def _commit_manifest(tr, linkrev, ctx, mctx, manifest, files, added, drop):
"""make a new manifest entry (or reuse a new one) """make a new manifest entry (or reuse a new one)
given an initialised manifest context and precomputed list of given an initialised manifest context and precomputed list of
- files: files affected by the commit - files: files affected by the commit

mercurial/context.py

def ancestors(self): def ancestors(self):
for p in self._parents: for p in self._parents:
yield p yield p
for a in self._repo.changelog.ancestors( for a in self._repo.changelog.ancestors(
[p.rev() for p in self._parents] [p.rev() for p in self._parents]
): ):
yield self._repo[a] yield self._repo[a]
def markcommitted(self, node): def markcommitted(self, node, filedata=None):
"""Perform post-commit cleanup necessary after committing this ctx """Perform post-commit cleanup necessary after committing this ctx
Specifically, this updates backing stores this working context Specifically, this updates backing stores this working context
wraps to reflect the fact that the changes reflected by this wraps to reflect the fact that the changes reflected by this
workingctx have been committed. For example, it marks workingctx have been committed. For example, it marks
modified and added files as normal in the dirstate. modified and added files as normal in the dirstate.
""" """
) )
) )
def matches(self, match): def matches(self, match):
match = self._repo.narrowmatch(match) match = self._repo.narrowmatch(match)
ds = self._repo.dirstate ds = self._repo.dirstate
return sorted(f for f in ds.matches(match) if ds.get_entry(f).tracked) return sorted(f for f in ds.matches(match) if ds.get_entry(f).tracked)
def markcommitted(self, node): def markcommitted(self, node, filedata=None):
if filedata is None:
filedata = {}
with self._repo.dirstate.parentchange(): with self._repo.dirstate.parentchange():
for f in self.modified() + self.added(): for f in self.modified() + self.added():
self._repo.dirstate.update_file( self._repo.dirstate.update_file(
f, p1_tracked=True, wc_tracked=True f,
p1_tracked=True,
wc_tracked=True,
parentfiledata=filedata.get(f),
) )
for f in self.removed(): for f in self.removed():
self._repo.dirstate.update_file( self._repo.dirstate.update_file(
f, p1_tracked=False, wc_tracked=False f,
p1_tracked=False,
wc_tracked=False,
parentfiledata=filedata.get(f),
) )
self._repo.dirstate.setparents(node) self._repo.dirstate.setparents(node)
self._repo._quick_access_changeid_invalidate() self._repo._quick_access_changeid_invalidate()
sparse.aftercommit(self._repo, node) sparse.aftercommit(self._repo, node)
# write changes out explicitly, because nesting wlock at # write changes out explicitly, because nesting wlock at
# runtime may prevent 'wlock.release()' in 'repo.commit()' # runtime may prevent 'wlock.release()' in 'repo.commit()'

mercurial/interfaces/repository.py

date=None, date=None,
match=None, match=None,
force=False, force=False,
editor=False, editor=False,
extra=None, extra=None,
): ):
"""Add a new revision to the repository.""" """Add a new revision to the repository."""
def commitctx(ctx, error=False, origctx=None): def commitctx(ctx, error=False, origctx=None, filedata=None):
"""Commit a commitctx instance to the repository.""" """Commit a commitctx instance to the repository."""
def destroying(): def destroying():
"""Inform the repository that nodes are about to be destroyed.""" """Inform the repository that nodes are about to be destroyed."""
def destroyed(): def destroyed():
"""Inform the repository that nodes have been destroyed.""" """Inform the repository that nodes have been destroyed."""

mercurial/localrepo.py

p1, p2 = self.dirstate.parents() p1, p2 = self.dirstate.parents()
hookp1, hookp2 = hex(p1), (p2 != self.nullid and hex(p2) or b'') hookp1, hookp2 = hex(p1), (p2 != self.nullid and hex(p2) or b'')
try: try:
self.hook( self.hook(
b"precommit", throw=True, parent1=hookp1, parent2=hookp2 b"precommit", throw=True, parent1=hookp1, parent2=hookp2
) )
with self.transaction(b'commit'): with self.transaction(b'commit'):
ret = self.commitctx(cctx, True) filedata = {} if not cctx.isinmemory() else None
ret = self.commitctx(cctx, error=True, filedata=filedata)
# update bookmarks, dirstate and mergestate # update bookmarks, dirstate and mergestate
bookmarks.update(self, [p1, p2], ret) bookmarks.update(self, [p1, p2], ret)
cctx.markcommitted(ret) cctx.markcommitted(ret, filedata=filedata)
ms.reset() ms.reset()
except: # re-raises except: # re-raises
if edited: if edited:
self.ui.write( self.ui.write(
_(b'note: commit message saved in %s\n') % msgfn _(b'note: commit message saved in %s\n') % msgfn
) )
self.ui.write( self.ui.write(
_( _(
self.hook( self.hook(
b"commit", node=hex(ret), parent1=hookp1, parent2=hookp2 b"commit", node=hex(ret), parent1=hookp1, parent2=hookp2
) )
self._afterlock(commithook) self._afterlock(commithook)
return ret return ret
@unfilteredmethod @unfilteredmethod
def commitctx(self, ctx, error=False, origctx=None): def commitctx(self, ctx, error=False, origctx=None, filedata=None):
return commit.commitctx(self, ctx, error=error, origctx=origctx) return commit.commitctx(
self, ctx, error=error, origctx=origctx, filedata=filedata
)
@unfilteredmethod @unfilteredmethod
def destroying(self): def destroying(self):
"""Inform the repository that nodes are about to be destroyed. """Inform the repository that nodes are about to be destroyed.
Intended for use by strip and rollback, so there's a common Intended for use by strip and rollback, so there's a common
place for anything that has to be done before destroying history. place for anything that has to be done before destroying history.
This is mostly useful for saving state that is in memory and waiting This is mostly useful for saving state that is in memory and waiting

tests/fakedirstatewritetime.py

dirstatemapmod.dirstatemap.write = orig_dirstatemap_write dirstatemapmod.dirstatemap.write = orig_dirstatemap_write
def _poststatusfixup(orig, workingctx, status, fixup): def _poststatusfixup(orig, workingctx, status, fixup):
ui = workingctx.repo().ui ui = workingctx.repo().ui
return fakewrite(ui, lambda: orig(workingctx, status, fixup)) return fakewrite(ui, lambda: orig(workingctx, status, fixup))
def markcommitted(orig, committablectx, node): def markcommitted(orig, committablectx, node, filedata=None):
ui = committablectx.repo().ui ui = committablectx.repo().ui
return fakewrite(ui, lambda: orig(committablectx, node)) return fakewrite(ui, lambda: orig(committablectx, node, filedata=filedata))
def extsetup(ui): def extsetup(ui):
extensions.wrapfunction( extensions.wrapfunction(
context.workingctx, '_poststatusfixup', _poststatusfixup context.workingctx, '_poststatusfixup', _poststatusfixup
) )
extensions.wrapfunction(context.workingctx, 'markcommitted', markcommitted) extensions.wrapfunction(context.workingctx, 'markcommitted', markcommitted)

tests/test-annotate.t

"hg debugsetparents" to merge without ancestor check by "hg merge", "hg debugsetparents" to merge without ancestor check by "hg merge",
and (2) the extension to allow filelog merging between the revision and (2) the extension to allow filelog merging between the revision
and its ancestor by overriding "repo._filecommit". and its ancestor by overriding "repo._filecommit".
$ cat > ../legacyrepo.py <<EOF $ cat > ../legacyrepo.py <<EOF
> from __future__ import absolute_import > from __future__ import absolute_import
> from mercurial import commit, error, extensions > from mercurial import commit, error, extensions
> def _filecommit(orig, repo, fctx, manifest1, manifest2, > def _filecommit(orig, repo, fctx, manifest1, manifest2,
> linkrev, tr, includecopymeta, ms): > linkrev, tr, includecopymeta, ms, filedata):
> fname = fctx.path() > fname = fctx.path()
> text = fctx.data() > text = fctx.data()
> flog = repo.file(fname) > flog = repo.file(fname)
> fparent1 = manifest1.get(fname, repo.nullid) > fparent1 = manifest1.get(fname, repo.nullid)
> fparent2 = manifest2.get(fname, repo.nullid) > fparent2 = manifest2.get(fname, repo.nullid)
> meta = {} > meta = {}
> copy = fctx.copysource() > copy = fctx.copysource()
> if copy and copy != fname: > if copy and copy != fname:

tests/test-commandserver.t

> configitem = registrar.configitem(configtable) > configitem = registrar.configitem(configtable)
> configitem(b'failafterfinalize', b'fail', > configitem(b'failafterfinalize', b'fail',
> default=None, > default=None,
> ) > )
> def fail(tr): > def fail(tr):
> raise error.Abort(b'fail after finalization') > raise error.Abort(b'fail after finalization')
> def reposetup(ui, repo): > def reposetup(ui, repo):
> class failrepo(repo.__class__): > class failrepo(repo.__class__):
> def commitctx(self, ctx, error=False, origctx=None): > def commitctx(self, ctx, **kwargs):
> if self.ui.configbool(b'failafterfinalize', b'fail'): > if self.ui.configbool(b'failafterfinalize', b'fail'):
> # 'sorted()' by ASCII code on category names causes > # 'sorted()' by ASCII code on category names causes
> # invoking 'fail' after finalization of changelog > # invoking 'fail' after finalization of changelog
> # using "'cl-%i' % id(self)" as category name > # using "'cl-%i' % id(self)" as category name
> self.currenttransaction().addfinalize(b'zzzzzzzz', fail) > self.currenttransaction().addfinalize(b'zzzzzzzz', fail)
> return super(failrepo, self).commitctx(ctx, error, origctx) > return super(failrepo, self).commitctx(ctx, **kwargs)
> repo.__class__ = failrepo > repo.__class__ = failrepo
> EOF > EOF
$ hg init repo3 $ hg init repo3
$ cd repo3 $ cd repo3
$ cat <<EOF >> $HGRCPATH $ cat <<EOF >> $HGRCPATH
> [command-templates] > [command-templates]

tests/test-dirstate-race2.t

$ hg up -r 0 --config extensions.race=$TESTTMP/dirstaterace.py $ hg up -r 0 --config extensions.race=$TESTTMP/dirstaterace.py
1 files updated, 0 files merged, 0 files removed, 0 files unresolved 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ hg debugdirstate --no-dates $ hg debugdirstate --no-dates
n 644 2 (set |unset) a (re) n 644 2 (set |unset) a (re)
$ echo a > a; hg status; hg diff $ echo a > a; hg status; hg diff
Do a commit where file 'a' is changed between hg committing its new Do a commit where file 'a' is changed between hg committing its new
revision into the repository, and the writing of the dirstate. This revision into the repository, and the writing of the dirstate. The
results in a corrupted dirstate (size doesn't match committed size). size in the dirstate is correct nonetheless, and so a diff is shown.
$ echo aaa > a; hg commit -qm _ $ echo aaa > a; hg commit -qm _
$ hg merge -qr 1; hg resolve -m; rm a.orig $ hg merge -qr 1; hg resolve -m; rm a.orig
warning: conflicts while merging a! (edit, then use 'hg resolve --mark') warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
(no more unresolved files) (no more unresolved files)
$ cat a $ cat a
<<<<<<< working copy: be46f74ce38d - test: _ <<<<<<< working copy: be46f74ce38d - test: _
aaa aaa
======= =======
aa aa
>>>>>>> merge rev: eb3fc6c17aa3 - test: _ >>>>>>> merge rev: eb3fc6c17aa3 - test: _
$ hg debugdirstate --no-dates $ hg debugdirstate --no-dates
m 0 -2 (set |unset) a (re) m 0 -2 (set |unset) a (re)
$ hg commit -m _ --config extensions.race=$TESTTMP/dirstaterace.py $ hg commit -m _ --config extensions.race=$TESTTMP/dirstaterace.py
$ hg debugdirstate --no-dates $ hg debugdirstate --no-dates
n 644 0 (set |unset) a (re) n 644 105 (set |unset) a (re)
$ cat a | wc -c $ cat a | wc -c
*0 (re) *0 (re)
$ hg cat -r . a | wc -c $ hg cat -r . a | wc -c
*105 (re) *105 (re)
$ hg status; hg diff --stat $ hg status; hg diff --stat
M a
a | 5 -----
1 files changed, 0 insertions(+), 5 deletions(-)

tests/test-fastannotate-hg.t

"hg debugsetparents" to merge without ancestor check by "hg merge", "hg debugsetparents" to merge without ancestor check by "hg merge",
and (2) the extension to allow filelog merging between the revision and (2) the extension to allow filelog merging between the revision
and its ancestor by overriding "repo._filecommit". and its ancestor by overriding "repo._filecommit".
$ cat > ../legacyrepo.py <<EOF $ cat > ../legacyrepo.py <<EOF
> from __future__ import absolute_import > from __future__ import absolute_import
> from mercurial import commit, error, extensions > from mercurial import commit, error, extensions
> def _filecommit(orig, repo, fctx, manifest1, manifest2, > def _filecommit(orig, repo, fctx, manifest1, manifest2,
> linkrev, tr, includecopymeta, ms): > linkrev, tr, includecopymeta, ms, filedata):
> fname = fctx.path() > fname = fctx.path()
> text = fctx.data() > text = fctx.data()
> flog = repo.file(fname) > flog = repo.file(fname)
> fparent1 = manifest1.get(fname, repo.nullid) > fparent1 = manifest1.get(fname, repo.nullid)
> fparent2 = manifest2.get(fname, repo.nullid) > fparent2 = manifest2.get(fname, repo.nullid)
> meta = {} > meta = {}
> copy = fctx.copysource() > copy = fctx.copysource()
> if copy and copy != fname: > if copy and copy != fname: