This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10164

split: close transaction in the unlikely event of a conflict while rebasing
ClosedPublic

Authored by martinvonz on Mar 12 2021, 12:57 PM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHG7f6c002d7c0a: split: close transaction in the unlikely event of a conflict while rebasing
Summary

hg split *should* never result in conflicts, but in case there are
bugs, we should at least commit the transaction so they can continue
the rebase. One of our users ran into the regression fixed by
D10120. They fixed the conflict and the tried to continue the rebase,
but it failed with "abort: cannot continue inconsistent rebase"
because the rebase state referred to commits written in a transaction
that was never committed.

Side note: hg split should probably turn off copy tracing to reduce
the impact of such bugs, and to speed it up as well. Copies made in
the rebased commits should still be respected because hg rebase
calls copies.graftcopies().

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

martinvonz created this revision.Mar 12 2021, 12:57 PM
pulkit accepted this revision.Mar 12 2021, 1:24 PM
This revision is now accepted and ready to land.Mar 12 2021, 1:24 PM

Revision Contents
Changeset List

PathPackages
Mhgext/split.py (94 lines)

Diff 26439

hgext/split.py

commands, commands,
error, error,
hg, hg,
pycompat, pycompat,
registrar, registrar,
revsetlang, revsetlang,
rewriteutil, rewriteutil,
scmutil, scmutil,
util,
) )
# allow people to use split without explicitly enabling rebase extension # allow people to use split without explicitly enabling rebase extension
from . import rebase from . import rebase
cmdtable = {} cmdtable = {}
command = registrar.command(cmdtable) command = registrar.command(cmdtable)
By default, rebase connected non-obsoleted descendants onto the new By default, rebase connected non-obsoleted descendants onto the new
changeset. Use --no-rebase to avoid the rebase. changeset. Use --no-rebase to avoid the rebase.
""" """
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
revlist = [] revlist = []
if opts.get(b'rev'): if opts.get(b'rev'):
revlist.append(opts.get(b'rev')) revlist.append(opts.get(b'rev'))
revlist.extend(revs) revlist.extend(revs)
with repo.wlock(), repo.lock(), repo.transaction(b'split') as tr: with repo.wlock(), repo.lock():
tr = repo.transaction(b'split')
# If the rebase somehow runs into conflicts, make sure
# we close the transaction so the user can continue it.
with util.acceptintervention(tr):
revs = scmutil.revrange(repo, revlist or [b'.']) revs = scmutil.revrange(repo, revlist or [b'.'])
if len(revs) > 1: if len(revs) > 1:
raise error.InputError(_(b'cannot split multiple revisions')) raise error.InputError(_(b'cannot split multiple revisions'))
rev = revs.first() rev = revs.first()
ctx = repo[rev] ctx = repo[rev]
# Handle nullid specially here (instead of leaving for precheck() # Handle nullid specially here (instead of leaving for precheck()
# below) so we get a nicer message and error code. # below) so we get a nicer message and error code.
if rev is None or ctx.node() == nullid: if rev is None or ctx.node() == nullid:
ui.status(_(b'nothing to split\n')) ui.status(_(b'nothing to split\n'))
return 1 return 1
if ctx.node() is None: if ctx.node() is None:
raise error.InputError(_(b'cannot split working directory')) raise error.InputError(_(b'cannot split working directory'))
if opts.get(b'rebase'): if opts.get(b'rebase'):
# Skip obsoleted descendants and their descendants so the rebase # Skip obsoleted descendants and their descendants so the rebase
# won't cause conflicts for sure. # won't cause conflicts for sure.
descendants = list(repo.revs(b'(%d::) - (%d)', rev, rev)) descendants = list(repo.revs(b'(%d::) - (%d)', rev, rev))
torebase = list( torebase = list(
repo.revs( repo.revs(
b'%ld - (%ld & obsolete())::', descendants, descendants b'%ld - (%ld & obsolete())::', descendants, descendants
) )
) )
else: else:
torebase = [] torebase = []
rewriteutil.precheck(repo, [rev] + torebase, b'split') rewriteutil.precheck(repo, [rev] + torebase, b'split')
if len(ctx.parents()) > 1: if len(ctx.parents()) > 1:
raise error.InputError(_(b'cannot split a merge changeset')) raise error.InputError(_(b'cannot split a merge changeset'))
cmdutil.bailifchanged(repo) cmdutil.bailifchanged(repo)
# Deactivate bookmark temporarily so it won't get moved unintentionally # Deactivate bookmark temporarily so it won't get moved
# unintentionally
bname = repo._activebookmark bname = repo._activebookmark
if bname and repo._bookmarks[bname] != ctx.node(): if bname and repo._bookmarks[bname] != ctx.node():
bookmarks.deactivate(repo) bookmarks.deactivate(repo)
wnode = repo[b'.'].node() wnode = repo[b'.'].node()
top = None top = None
try: try:
top = dosplit(ui, repo, tr, ctx, opts) top = dosplit(ui, repo, tr, ctx, opts)
finally: finally:
# top is None: split failed, need update --clean recovery. # top is None: split failed, need update --clean recovery.
# wnode == ctx.node(): wnode split, no need to update. # wnode == ctx.node(): wnode split, no need to update.
if top is None or wnode != ctx.node(): if top is None or wnode != ctx.node():
hg.clean(repo, wnode, show_stats=False) hg.clean(repo, wnode, show_stats=False)
if bname: if bname:
bookmarks.activate(repo, bname) bookmarks.activate(repo, bname)
if torebase and top: if torebase and top:
dorebase(ui, repo, torebase, top) dorebase(ui, repo, torebase, top)
def dosplit(ui, repo, tr, ctx, opts): def dosplit(ui, repo, tr, ctx, opts):
committed = [] # [ctx] committed = [] # [ctx]
# Set working parent to ctx.p1(), and keep working copy as ctx's content # Set working parent to ctx.p1(), and keep working copy as ctx's content
if ctx.node() != repo.dirstate.p1(): if ctx.node() != repo.dirstate.p1():
hg.clean(repo, ctx.node(), show_stats=False) hg.clean(repo, ctx.node(), show_stats=False)