This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9041

mergedriver: delete it
ClosedPublic

Authored by martinvonz on Sep 18 2020, 1:59 AM.

Details

Reviewers
pulkit
indygreg
Group Reviewers
hg-reviewers
Commits
rHG32ce4cbaec4b: mergedriver: delete it
Summary

The merge driver code was added in late 2015. I think
'406a654b::6f045b56 & user("sid0")' is a reasonable revset for finding
the relevant commits, including preparation for it. The code is very
poorly tested, which makes it very hard to maintain. It seems it's
only used by FB and they don't use this code base anymore, so let's
remove the code to make it easier for us to maintain our product.

Diff Detail

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

Event Timeline

martinvonz created this revision.Sep 18 2020, 1:59 AM
martinvonz retitled this revision from RFC: mergedriver: delete it to mergedriver: delete it.Sep 18 2020, 11:40 AM
martinvonz edited the summary of this revision. (Show Details)
martinvonz updated this revision to Diff 22728.
pulkit accepted this revision.Sep 19 2020, 3:33 AM
pulkit added a subscriber: pulkit.

Looks good to me. Will push it if I don't hear any concerns in the next 4 days.

This revision is now accepted and ready to land.Sep 19 2020, 3:33 AM
indygreg accepted this revision.Sep 22 2020, 10:05 PM
martinvonz added a commit: rHG32ce4cbaec4b: mergedriver: delete it.Sep 22 2020, 10:23 PM
Closed by commit rHG32ce4cbaec4b: mergedriver: delete it (authored by martinvonz). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 22708

mercurial/commands.py

mergestatemod.MERGE_RECORD_UNRESOLVED_PATH: ( mergestatemod.MERGE_RECORD_UNRESOLVED_PATH: (
b'resolve.unresolved', b'resolve.unresolved',
b'P', b'P',
), ),
mergestatemod.MERGE_RECORD_RESOLVED_PATH: ( mergestatemod.MERGE_RECORD_RESOLVED_PATH: (
b'resolve.resolved', b'resolve.resolved',
b'R', b'R',
), ),
mergestatemod.MERGE_RECORD_DRIVER_RESOLVED: (
b'resolve.driverresolved',
b'D',
),
} }
for f in ms: for f in ms:
if not m(f): if not m(f):
continue continue
label, key = mergestateinfo[ms[f]] label, key = mergestateinfo[ms[f]]
fm.startitem() fm.startitem()
fm.context(ctx=wctx) fm.context(ctx=wctx)
fm.condwrite(not nostatus, b'mergestatus', b'%s ', key, label=label) fm.condwrite(not nostatus, b'mergestatus', b'%s ', key, label=label)
fm.data(path=f) fm.data(path=f)
fm.plain(b'%s\n' % uipathfn(f), label=label) fm.plain(b'%s\n' % uipathfn(f), label=label)
fm.end() fm.end()
return 0 return 0
with repo.wlock(): with repo.wlock():
ms = mergestatemod.mergestate.read(repo) ms = mergestatemod.mergestate.read(repo)
if not (ms.active() or repo.dirstate.p2() != nullid): if not (ms.active() or repo.dirstate.p2() != nullid):
raise error.Abort( raise error.Abort(
_(b'resolve command not applicable when not merging') _(b'resolve command not applicable when not merging')
) )
wctx = repo[None] wctx = repo[None]
if (
ms.mergedriver
and ms.mdstate() == mergestatemod.MERGE_DRIVER_STATE_UNMARKED
):
proceed = mergemod.driverpreprocess(repo, ms, wctx)
ms.commit()
# allow mark and unmark to go through
if not mark and not unmark and not proceed:
return 1
m = scmutil.match(wctx, pats, opts) m = scmutil.match(wctx, pats, opts)
ret = 0 ret = 0
didwork = False didwork = False
runconclude = False
tocomplete = [] tocomplete = []
hasconflictmarkers = [] hasconflictmarkers = []
if mark: if mark:
markcheck = ui.config(b'commands', b'resolve.mark-check') markcheck = ui.config(b'commands', b'resolve.mark-check')
if markcheck not in [b'warn', b'abort']: if markcheck not in [b'warn', b'abort']:
# Treat all invalid / unrecognized values as 'none'. # Treat all invalid / unrecognized values as 'none'.
markcheck = False markcheck = False
for f in ms: for f in ms:
if not m(f): if not m(f):
continue continue
didwork = True didwork = True
# don't let driver-resolved files be marked, and run the conclude
# step if asked to resolve
if ms[f] == mergestatemod.MERGE_RECORD_DRIVER_RESOLVED:
exact = m.exact(f)
if mark:
if exact:
ui.warn(
_(b'not marking %s as it is driver-resolved\n')
% uipathfn(f)
)
elif unmark:
if exact:
ui.warn(
_(b'not unmarking %s as it is driver-resolved\n')
% uipathfn(f)
)
else:
runconclude = True
continue
# path conflicts must be resolved manually # path conflicts must be resolved manually
if ms[f] in ( if ms[f] in (
mergestatemod.MERGE_RECORD_UNRESOLVED_PATH, mergestatemod.MERGE_RECORD_UNRESOLVED_PATH,
mergestatemod.MERGE_RECORD_RESOLVED_PATH, mergestatemod.MERGE_RECORD_RESOLVED_PATH,
): ):
if mark: if mark:
ms.mark(f, mergestatemod.MERGE_RECORD_RESOLVED_PATH) ms.mark(f, mergestatemod.MERGE_RECORD_RESOLVED_PATH)
elif unmark: elif unmark:
hint = _(b"(try: hg resolve %s%s)\n") % ( hint = _(b"(try: hg resolve %s%s)\n") % (
flags, flags,
b' '.join(pats), b' '.join(pats),
) )
break break
ui.warn(_(b"arguments do not match paths that need resolving\n")) ui.warn(_(b"arguments do not match paths that need resolving\n"))
if hint: if hint:
ui.warn(hint) ui.warn(hint)
elif ms.mergedriver and ms.mdstate() != b's':
# run conclude step when either a driver-resolved file is requested
# or there are no driver-resolved files
# we can't use 'ret' to determine whether any files are unresolved
# because we might not have tried to resolve some
if (runconclude or not list(ms.driverresolved())) and not list(
ms.unresolved()
):
proceed = mergemod.driverconclude(repo, ms, wctx)
ms.commit()
if not proceed:
return 1
# Nudge users into finishing an unfinished operation # Nudge users into finishing an unfinished operation
unresolvedf = list(ms.unresolved()) unresolvedf = list(ms.unresolved())
driverresolvedf = list(ms.driverresolved()) if not unresolvedf:
if not unresolvedf and not driverresolvedf:
ui.status(_(b'(no more unresolved files)\n')) ui.status(_(b'(no more unresolved files)\n'))
cmdutil.checkafterresolved(repo) cmdutil.checkafterresolved(repo)
elif not unresolvedf:
ui.status(
_(
b'(no more unresolved files -- '
b'run "hg resolve --all" to conclude)\n'
)
)
return ret return ret
@command( @command(
b'revert', b'revert',
[ [
(b'a', b'all', None, _(b'revert all changes when no arguments given')), (b'a', b'all', None, _(b'revert all changes when no arguments given')),

mercurial/configitems.py

b'experimental', b'httppeer.advertise-v2', default=False, b'experimental', b'httppeer.advertise-v2', default=False,
) )
coreconfigitem( coreconfigitem(
b'experimental', b'httppeer.v2-encoder-order', default=None, b'experimental', b'httppeer.v2-encoder-order', default=None,
) )
coreconfigitem( coreconfigitem(
b'experimental', b'httppostargs', default=False, b'experimental', b'httppostargs', default=False,
) )
coreconfigitem(
b'experimental', b'mergedriver', default=None,
)
coreconfigitem(b'experimental', b'nointerrupt', default=False) coreconfigitem(b'experimental', b'nointerrupt', default=False)
coreconfigitem(b'experimental', b'nointerrupt-interactiveonly', default=True) coreconfigitem(b'experimental', b'nointerrupt-interactiveonly', default=True)
coreconfigitem( coreconfigitem(
b'experimental', b'obsmarkers-exchange-debug', default=False, b'experimental', b'obsmarkers-exchange-debug', default=False,
) )
coreconfigitem( coreconfigitem(
b'experimental', b'remotenames', default=False, b'experimental', b'remotenames', default=False,

mercurial/helptext/internals/mergestate.txt

lowercase, the record can be safely ignored. lowercase, the record can be safely ignored.
Currently known records: Currently known records:
| * L: the node of the "local" part of the merge (hexified version) | * L: the node of the "local" part of the merge (hexified version)
| * O: the node of the "other" part of the merge (hexified version) | * O: the node of the "other" part of the merge (hexified version)
| * F: a file to be merged entry | * F: a file to be merged entry
| * C: a change/delete or delete/change conflict | * C: a change/delete or delete/change conflict
| * D: a file that the external merge driver will merge internally
| (experimental)
| * P: a path conflict (file vs directory) | * P: a path conflict (file vs directory)
| * m: the external merge driver defined for this merge plus its run state
| (experimental)
| * f: a (filename, dictionary) tuple of optional values for a given file | * f: a (filename, dictionary) tuple of optional values for a given file
| * X: unsupported mandatory record type (used in tests) | * X: unsupported mandatory record type (used in tests)
| * x: unsupported advisory record type (used in tests) | * x: unsupported advisory record type (used in tests)
| * l: the labels for the parts of the merge. | * l: the labels for the parts of the merge.
Merge driver run states (experimental):
| * u: driver-resolved files unmarked -- needs to be run next time we're
| about to resolve or commit
| * m: driver-resolved files marked -- only needs to be run before commit
| * s: success/skipped -- does not need to be run any more
Merge record states (indexed by filename): Merge record states (indexed by filename):
| * u: unresolved conflict | * u: unresolved conflict
| * r: resolved conflict | * r: resolved conflict
| * pu: unresolved path conflict (file conflicts with directory) | * pu: unresolved path conflict (file conflicts with directory)
| * pr: resolved path conflict | * pr: resolved path conflict
| * d: driver-resolved conflict
The resolve command transitions between 'u' and 'r' for conflicts and The resolve command transitions between 'u' and 'r' for conflicts and
'pu' and 'pr' for path conflicts. 'pu' and 'pr' for path conflicts.
This format is a list of arbitrary records of the form: This format is a list of arbitrary records of the form:
[type][length][content] [type][length][content]

mercurial/merge.py

_(b"case-folding collision between %s and directory of %s") _(b"case-folding collision between %s and directory of %s")
% (lastfull, f) % (lastfull, f)
) )
foldprefix = fold + b'/' foldprefix = fold + b'/'
unfoldprefix = f + b'/' unfoldprefix = f + b'/'
lastfull = f lastfull = f
def driverpreprocess(repo, ms, wctx, labels=None):
"""run the preprocess step of the merge driver, if any
This is currently not implemented -- it's an extension point."""
return True
def driverconclude(repo, ms, wctx, labels=None):
"""run the conclude step of the merge driver, if any
This is currently not implemented -- it's an extension point."""
return True
def _filesindirs(repo, manifest, dirs): def _filesindirs(repo, manifest, dirs):
""" """
Generator that yields pairs of all the files in the manifest that are found Generator that yields pairs of all the files in the manifest that are found
inside the directories listed in dirs, and which directory they are found inside the directories listed in dirs, and which directory they are found
in. in.
""" """
for f in manifest: for f in manifest:
for p in pathutil.finddirs(f): for p in pathutil.finddirs(f):
updated = mresult.len( updated = mresult.len(
( (
mergestatemod.ACTION_GET, mergestatemod.ACTION_GET,
mergestatemod.ACTION_EXEC, mergestatemod.ACTION_EXEC,
mergestatemod.ACTION_LOCAL_DIR_RENAME_GET, mergestatemod.ACTION_LOCAL_DIR_RENAME_GET,
mergestatemod.ACTION_DIR_RENAME_MOVE_LOCAL, mergestatemod.ACTION_DIR_RENAME_MOVE_LOCAL,
) )
) )
# the ordering is important here -- ms.mergedriver will raise if the merge
# driver has changed, and we want to be able to bypass it when overwrite is
# True
usemergedriver = not overwrite and mergeactions and ms.mergedriver
if usemergedriver:
ms.commit()
proceed = driverpreprocess(repo, ms, wctx, labels=labels)
# the driver might leave some files unresolved
unresolvedf = set(ms.unresolved())
if not proceed:
# XXX setting unresolved to at least 1 is a hack to make sure we
# error out
return updateresult(
updated, merged, removed, max(len(unresolvedf), 1)
)
newactions = []
for f, args, msg in mergeactions:
if f in unresolvedf:
newactions.append((f, args, msg))
mergeactions = newactions
try: try:
# premerge # premerge
tocomplete = [] tocomplete = []
for f, args, msg in mergeactions: for f, args, msg in mergeactions:
repo.ui.debug(b" %s: %s -> m (premerge)\n" % (f, msg)) repo.ui.debug(b" %s: %s -> m (premerge)\n" % (f, msg))
progress.increment(item=f) progress.increment(item=f)
if f == b'.hgsubstate': # subrepo states need updating if f == b'.hgsubstate': # subrepo states need updating
progress.increment(item=f, total=numupdates) progress.increment(item=f, total=numupdates)
ms.resolve(f, wctx) ms.resolve(f, wctx)
finally: finally:
ms.commit() ms.commit()
unresolved = ms.unresolvedcount() unresolved = ms.unresolvedcount()
if (
usemergedriver
and not unresolved
and ms.mdstate() != mergestatemod.MERGE_DRIVER_STATE_SUCCESS
):
if not driverconclude(repo, ms, wctx, labels=labels):
# XXX setting unresolved to at least 1 is a hack to make sure we
# error out
unresolved = max(unresolved, 1)
ms.commit()
msupdated, msmerged, msremoved = ms.counts() msupdated, msmerged, msremoved = ms.counts()
updated += msupdated updated += msupdated
merged += msmerged merged += msmerged
removed += msremoved removed += msremoved
extraactions = ms.actions() extraactions = ms.actions()
if extraactions: if extraactions:
mfiles = {
a[0] for a in mresult.getactions((mergestatemod.ACTION_MERGE,))
}
for k, acts in pycompat.iteritems(extraactions): for k, acts in pycompat.iteritems(extraactions):
for a in acts: for a in acts:
mresult.addfile(a[0], k, *a[1:]) mresult.addfile(a[0], k, *a[1:])
if k == mergestatemod.ACTION_GET and wantfiledata: if k == mergestatemod.ACTION_GET and wantfiledata:
# no filedata until mergestate is updated to provide it # no filedata until mergestate is updated to provide it
for a in acts: for a in acts:
getfiledata[a[0]] = None getfiledata[a[0]] = None
# Remove these files from actions[ACTION_MERGE] as well. This is
# important because in recordupdates, files in actions[ACTION_MERGE]
# are processed after files in other actions, and the merge driver
# might add files to those actions via extraactions above. This can
# lead to a file being recorded twice, with poor results. This is
# especially problematic for actions[ACTION_REMOVE] (currently only
# possible with the merge driver in the initial merge process;
# interrupted merges don't go through this flow).
#
# The real fix here is to have indexes by both file and action so
# that when the action for a file is changed it is automatically
# reflected in the other action lists. But that involves a more
# complex data structure, so this will do for now.
#
# We don't need to do the same operation for 'dc' and 'cd' because
# those lists aren't consulted again.
mfiles.difference_update(a[0] for a in acts)
for a in list(mresult.getactions((mergestatemod.ACTION_MERGE,))):
if a[0] not in mfiles:
mresult.removefile(a[0])
progress.complete() progress.complete()
assert len(getfiledata) == ( assert len(getfiledata) == (
mresult.len((mergestatemod.ACTION_GET,)) if wantfiledata else 0 mresult.len((mergestatemod.ACTION_GET,)) if wantfiledata else 0
) )
return updateresult(updated, merged, removed, unresolved), getfiledata return updateresult(updated, merged, removed, unresolved), getfiledata

mercurial/mergestate.py

#### ####
# merge records which records metadata about a current merge # merge records which records metadata about a current merge
# exists only once in a mergestate # exists only once in a mergestate
##### #####
RECORD_LOCAL = b'L' RECORD_LOCAL = b'L'
RECORD_OTHER = b'O' RECORD_OTHER = b'O'
# record merge labels # record merge labels
RECORD_LABELS = b'l' RECORD_LABELS = b'l'
# store info about merge driver used and it's state
RECORD_MERGE_DRIVER_STATE = b'm'
##### #####
# record extra information about files, with one entry containing info about one # record extra information about files, with one entry containing info about one
# file. Hence, multiple of them can exists # file. Hence, multiple of them can exists
##### #####
RECORD_FILE_VALUES = b'f' RECORD_FILE_VALUES = b'f'
##### #####
# merge records which represents state of individual merges of files/folders # merge records which represents state of individual merges of files/folders
# These are top level records for each entry containing merge related info. # These are top level records for each entry containing merge related info.
# Each record of these has info about one file. Hence multiple of them can # Each record of these has info about one file. Hence multiple of them can
# exists # exists
##### #####
RECORD_MERGED = b'F' RECORD_MERGED = b'F'
RECORD_CHANGEDELETE_CONFLICT = b'C' RECORD_CHANGEDELETE_CONFLICT = b'C'
RECORD_MERGE_DRIVER_MERGE = b'D'
# the path was dir on one side of merge and file on another # the path was dir on one side of merge and file on another
RECORD_PATH_CONFLICT = b'P' RECORD_PATH_CONFLICT = b'P'
##### #####
# possible state which a merge entry can have. These are stored inside top-level # possible state which a merge entry can have. These are stored inside top-level
# merge records mentioned just above. # merge records mentioned just above.
##### #####
MERGE_RECORD_UNRESOLVED = b'u' MERGE_RECORD_UNRESOLVED = b'u'
MERGE_RECORD_RESOLVED = b'r' MERGE_RECORD_RESOLVED = b'r'
MERGE_RECORD_UNRESOLVED_PATH = b'pu' MERGE_RECORD_UNRESOLVED_PATH = b'pu'
MERGE_RECORD_RESOLVED_PATH = b'pr' MERGE_RECORD_RESOLVED_PATH = b'pr'
MERGE_RECORD_DRIVER_RESOLVED = b'd'
# represents that the file was automatically merged in favor # represents that the file was automatically merged in favor
# of other version. This info is used on commit. # of other version. This info is used on commit.
# This is now deprecated and commit related information is now # This is now deprecated and commit related information is now
# stored in RECORD_FILE_VALUES # stored in RECORD_FILE_VALUES
MERGE_RECORD_MERGED_OTHER = b'o' MERGE_RECORD_MERGED_OTHER = b'o'
##### #####
# top level record which stores other unknown records. Multiple of these can # top level record which stores other unknown records. Multiple of these can
# exists # exists
##### #####
RECORD_OVERRIDE = b't' RECORD_OVERRIDE = b't'
##### #####
# possible states which a merge driver can have. These are stored inside a
# RECORD_MERGE_DRIVER_STATE entry
#####
MERGE_DRIVER_STATE_UNMARKED = b'u'
MERGE_DRIVER_STATE_MARKED = b'm'
MERGE_DRIVER_STATE_SUCCESS = b's'
#####
# legacy records which are no longer used but kept to prevent breaking BC # legacy records which are no longer used but kept to prevent breaking BC
##### #####
# This record was release in 5.4 and usage was removed in 5.5 # This record was release in 5.4 and usage was removed in 5.5
LEGACY_RECORD_RESOLVED_OTHER = b'R' LEGACY_RECORD_RESOLVED_OTHER = b'R'
# This record was release in 3.7 and usage was removed in 5.6
LEGACY_RECORD_DRIVER_RESOLVED = b'd'
# This record was release in 3.7 and usage was removed in 5.6
LEGACY_MERGE_DRIVER_STATE = b'm'
# This record was release in 3.7 and usage was removed in 5.6
LEGACY_MERGE_DRIVER_MERGE = b'D'
ACTION_FORGET = b'f' ACTION_FORGET = b'f'
ACTION_REMOVE = b'r' ACTION_REMOVE = b'r'
ACTION_ADD = b'a' ACTION_ADD = b'a'
ACTION_GET = b'g' ACTION_GET = b'g'
ACTION_PATH_CONFLICT = b'p' ACTION_PATH_CONFLICT = b'p'
ACTION_PATH_CONFLICT_RESOLVE = b'pr' ACTION_PATH_CONFLICT_RESOLVE = b'pr'
lowercase, the record can be safely ignored. lowercase, the record can be safely ignored.
Currently known records: Currently known records:
L: the node of the "local" part of the merge (hexified version) L: the node of the "local" part of the merge (hexified version)
O: the node of the "other" part of the merge (hexified version) O: the node of the "other" part of the merge (hexified version)
F: a file to be merged entry F: a file to be merged entry
C: a change/delete or delete/change conflict C: a change/delete or delete/change conflict
D: a file that the external merge driver will merge internally
(experimental)
P: a path conflict (file vs directory) P: a path conflict (file vs directory)
m: the external merge driver defined for this merge plus its run state
(experimental)
f: a (filename, dictionary) tuple of optional values for a given file f: a (filename, dictionary) tuple of optional values for a given file
l: the labels for the parts of the merge. l: the labels for the parts of the merge.
Merge driver run states (experimental):
u: driver-resolved files unmarked -- needs to be run next time we're about
to resolve or commit
m: driver-resolved files marked -- only needs to be run before commit
s: success/skipped -- does not need to be run any more
Merge record states (stored in self._state, indexed by filename): Merge record states (stored in self._state, indexed by filename):
u: unresolved conflict u: unresolved conflict
r: resolved conflict r: resolved conflict
pu: unresolved path conflict (file conflicts with directory) pu: unresolved path conflict (file conflicts with directory)
pr: resolved path conflict pr: resolved path conflict
d: driver-resolved conflict
The resolve command transitions between 'u' and 'r' for conflicts and The resolve command transitions between 'u' and 'r' for conflicts and
'pu' and 'pr' for path conflicts. 'pu' and 'pr' for path conflicts.
''' '''
def __init__(self, repo): def __init__(self, repo):
"""Initialize the merge state. """Initialize the merge state.
Do not use this directly! Instead call read() or clean().""" Do not use this directly! Instead call read() or clean()."""
self._repo = repo self._repo = repo
self._state = {} self._state = {}
self._stateextras = collections.defaultdict(dict) self._stateextras = collections.defaultdict(dict)
self._local = None self._local = None
self._other = None self._other = None
self._labels = None self._labels = None
self._readmergedriver = None
self._mdstate = MERGE_DRIVER_STATE_UNMARKED
# contains a mapping of form: # contains a mapping of form:
# {filename : (merge_return_value, action_to_be_performed} # {filename : (merge_return_value, action_to_be_performed}
# these are results of re-running merge process # these are results of re-running merge process
# this dict is used to perform actions on dirstate caused by re-running # this dict is used to perform actions on dirstate caused by re-running
# the merge # the merge
self._results = {} self._results = {}
self._dirty = False self._dirty = False
def reset(self): def reset(self):
shutil.rmtree(self._repo.vfs.join(b'merge'), True) shutil.rmtree(self._repo.vfs.join(b'merge'), True)
def start(self, node, other, labels=None): def start(self, node, other, labels=None):
self._local = node self._local = node
self._other = other self._other = other
self._labels = labels self._labels = labels
if self.mergedriver:
self._mdstate = MERGE_DRIVER_STATE_SUCCESS
@util.propertycache
def mergedriver(self):
# protect against the following:
# - A configures a malicious merge driver in their hgrc, then
# pauses the merge
# - A edits their hgrc to remove references to the merge driver
# - A gives a copy of their entire repo, including .hg, to B
# - B inspects .hgrc and finds it to be clean
# - B then continues the merge and the malicious merge driver
# gets invoked
configmergedriver = self._repo.ui.config(
b'experimental', b'mergedriver'
)
if (
self._readmergedriver is not None
and self._readmergedriver != configmergedriver
):
raise error.ConfigError(
_(b"merge driver changed since merge started"),
hint=_(b"revert merge driver change or abort merge"),
)
return configmergedriver
@util.propertycache @util.propertycache
def local(self): def local(self):
if self._local is None: if self._local is None:
msg = b"local accessed but self._local isn't set" msg = b"local accessed but self._local isn't set"
raise error.ProgrammingError(msg) raise error.ProgrammingError(msg)
return self._local return self._local
records = self._makerecords() records = self._makerecords()
self._writerecords(records) self._writerecords(records)
self._dirty = False self._dirty = False
def _makerecords(self): def _makerecords(self):
records = [] records = []
records.append((RECORD_LOCAL, hex(self._local))) records.append((RECORD_LOCAL, hex(self._local)))
records.append((RECORD_OTHER, hex(self._other))) records.append((RECORD_OTHER, hex(self._other)))
if self.mergedriver:
records.append(
(
RECORD_MERGE_DRIVER_STATE,
b'\0'.join([self.mergedriver, self._mdstate]),
)
)
# Write out state items. In all cases, the value of the state map entry # Write out state items. In all cases, the value of the state map entry
# is written as the contents of the record. The record type depends on # is written as the contents of the record. The record type depends on
# the type of state that is stored, and capital-letter records are used # the type of state that is stored, and capital-letter records are used
# to prevent older versions of Mercurial that do not support the feature # to prevent older versions of Mercurial that do not support the feature
# from loading them. # from loading them.
for filename, v in pycompat.iteritems(self._state): for filename, v in pycompat.iteritems(self._state):
if v[0] == MERGE_RECORD_DRIVER_RESOLVED: if v[0] in (
# Driver-resolved merge. These are stored in 'D' records.
records.append(
(RECORD_MERGE_DRIVER_MERGE, b'\0'.join([filename] + v))
)
elif v[0] in (
MERGE_RECORD_UNRESOLVED_PATH, MERGE_RECORD_UNRESOLVED_PATH,
MERGE_RECORD_RESOLVED_PATH, MERGE_RECORD_RESOLVED_PATH,
): ):
# Path conflicts. These are stored in 'P' records. The current # Path conflicts. These are stored in 'P' records. The current
# resolution state ('pu' or 'pr') is stored within the record. # resolution state ('pu' or 'pr') is stored within the record.
records.append( records.append(
(RECORD_PATH_CONFLICT, b'\0'.join([filename] + v)) (RECORD_PATH_CONFLICT, b'\0'.join([filename] + v))
) )
def files(self): def files(self):
return self._state.keys() return self._state.keys()
def mark(self, dfile, state): def mark(self, dfile, state):
self._state[dfile][0] = state self._state[dfile][0] = state
self._dirty = True self._dirty = True
def mdstate(self):
return self._mdstate
def unresolved(self): def unresolved(self):
"""Obtain the paths of unresolved files.""" """Obtain the paths of unresolved files."""
for f, entry in pycompat.iteritems(self._state): for f, entry in pycompat.iteritems(self._state):
if entry[0] in ( if entry[0] in (
MERGE_RECORD_UNRESOLVED, MERGE_RECORD_UNRESOLVED,
MERGE_RECORD_UNRESOLVED_PATH, MERGE_RECORD_UNRESOLVED_PATH,
): ):
yield f yield f
def driverresolved(self):
"""Obtain the paths of driver-resolved files."""
for f, entry in self._state.items():
if entry[0] == MERGE_RECORD_DRIVER_RESOLVED:
yield f
def extras(self, filename): def extras(self, filename):
return self._stateextras[filename] return self._stateextras[filename]
def _resolve(self, preresolve, dfile, wctx): def _resolve(self, preresolve, dfile, wctx):
"""rerun merge process for file path `dfile`. """rerun merge process for file path `dfile`.
Returns whether the merge was completed and the return value of merge Returns whether the merge was completed and the return value of merge
obtained from filemerge._filemerge(). obtained from filemerge._filemerge().
""" """
if self[dfile] in (MERGE_RECORD_RESOLVED, MERGE_RECORD_DRIVER_RESOLVED): if self[dfile] in (
MERGE_RECORD_RESOLVED,
LEGACY_RECORD_DRIVER_RESOLVED,
):
return True, 0 return True, 0
stateentry = self._state[dfile] stateentry = self._state[dfile]
state, localkey, lfile, afile, anode, ofile, onode, flags = stateentry state, localkey, lfile, afile, anode, ofile, onode, flags = stateentry
octx = self._repo[self._other] octx = self._repo[self._other]
extras = self.extras(dfile) extras = self.extras(dfile)
anccommitnode = extras.get(b'ancestorlinknode') anccommitnode = extras.get(b'ancestorlinknode')
if anccommitnode: if anccommitnode:
actx = self._repo[anccommitnode] actx = self._repo[anccommitnode]
ACTION_ADD_MODIFIED: [], ACTION_ADD_MODIFIED: [],
ACTION_GET: [], ACTION_GET: [],
} }
for f, (r, action) in pycompat.iteritems(self._results): for f, (r, action) in pycompat.iteritems(self._results):
if action is not None: if action is not None:
actions[action].append((f, None, b"merge result")) actions[action].append((f, None, b"merge result"))
return actions return actions
def queueremove(self, f):
"""queues a file to be removed from the dirstate
Meant for use by custom merge drivers."""
self._results[f] = 0, ACTION_REMOVE
def queueadd(self, f):
"""queues a file to be added to the dirstate
Meant for use by custom merge drivers."""
self._results[f] = 0, ACTION_ADD
def queueget(self, f):
"""queues a file to be marked modified in the dirstate
Meant for use by custom merge drivers."""
self._results[f] = 0, ACTION_GET
class mergestate(_mergestate_base): class mergestate(_mergestate_base):
statepathv1 = b'merge/state' statepathv1 = b'merge/state'
statepathv2 = b'merge/state2' statepathv2 = b'merge/state2'
@staticmethod @staticmethod
def clean(repo): def clean(repo):
return ms return ms
def _read(self): def _read(self):
"""Analyse each record content to restore a serialized state from disk """Analyse each record content to restore a serialized state from disk
This function process "record" entry produced by the de-serialization This function process "record" entry produced by the de-serialization
of on disk file. of on disk file.
""" """
self._mdstate = MERGE_DRIVER_STATE_SUCCESS
unsupported = set() unsupported = set()
records = self._readrecords() records = self._readrecords()
for rtype, record in records: for rtype, record in records:
if rtype == RECORD_LOCAL: if rtype == RECORD_LOCAL:
self._local = bin(record) self._local = bin(record)
elif rtype == RECORD_OTHER: elif rtype == RECORD_OTHER:
self._other = bin(record) self._other = bin(record)
elif rtype == RECORD_MERGE_DRIVER_STATE: elif rtype == LEGACY_MERGE_DRIVER_STATE:
bits = record.split(b'\0', 1) pass
mdstate = bits[1]
if len(mdstate) != 1 or mdstate not in (
MERGE_DRIVER_STATE_UNMARKED,
MERGE_DRIVER_STATE_MARKED,
MERGE_DRIVER_STATE_SUCCESS,
):
# the merge driver should be idempotent, so just rerun it
mdstate = MERGE_DRIVER_STATE_UNMARKED
self._readmergedriver = bits[0]
self._mdstate = mdstate
elif rtype in ( elif rtype in (
RECORD_MERGED, RECORD_MERGED,
RECORD_CHANGEDELETE_CONFLICT, RECORD_CHANGEDELETE_CONFLICT,
RECORD_PATH_CONFLICT, RECORD_PATH_CONFLICT,
RECORD_MERGE_DRIVER_MERGE, LEGACY_MERGE_DRIVER_MERGE,
LEGACY_RECORD_RESOLVED_OTHER, LEGACY_RECORD_RESOLVED_OTHER,
): ):
bits = record.split(b'\0') bits = record.split(b'\0')
# merge entry type MERGE_RECORD_MERGED_OTHER is deprecated # merge entry type MERGE_RECORD_MERGED_OTHER is deprecated
# and we now store related information in _stateextras, so # and we now store related information in _stateextras, so
# lets write to _stateextras directly # lets write to _stateextras directly
if bits[1] == MERGE_RECORD_MERGED_OTHER: if bits[1] == MERGE_RECORD_MERGED_OTHER:
self._stateextras[bits[0]][b'filenode-source'] = b'other' self._stateextras[bits[0]][b'filenode-source'] = b'other'
self._backups = {} self._backups = {}
def _make_backup(self, fctx, localkey): def _make_backup(self, fctx, localkey):
self._backups[localkey] = fctx.data() self._backups[localkey] = fctx.data()
def _restore_backup(self, fctx, localkey, flags): def _restore_backup(self, fctx, localkey, flags):
fctx.write(self._backups[localkey], flags) fctx.write(self._backups[localkey], flags)
@util.propertycache
def mergedriver(self):
configmergedriver = self._repo.ui.config(
b'experimental', b'mergedriver'
)
if configmergedriver:
raise error.InMemoryMergeConflictsError(
b"in-memory merge does not support mergedriver"
)
return None
def commit(self): def commit(self):
pass pass
def recordupdates(repo, actions, branchmerge, getfiledata): def recordupdates(repo, actions, branchmerge, getfiledata):
"""record merge actions to the dirstate""" """record merge actions to the dirstate"""
# remove (must come first) # remove (must come first)
for f, args, msg in actions.get(ACTION_REMOVE, []): for f, args, msg in actions.get(ACTION_REMOVE, []):

mercurial/mergeutil.py

from . import error from . import error
def checkunresolved(ms): def checkunresolved(ms):
if list(ms.unresolved()): if list(ms.unresolved()):
raise error.Abort( raise error.Abort(
_(b"unresolved merge conflicts (see 'hg help resolve')") _(b"unresolved merge conflicts (see 'hg help resolve')")
) )
if ms.mdstate() != b's' or list(ms.driverresolved()):
raise error.Abort(
_(b'driver-resolved merge conflicts'),
hint=_(b'run "hg resolve --all" to resolve'),
)

tests/test-resolve.t

R file1 R file1
R file2 R file2
cleanup cleanup
$ hg resolve -u $ hg resolve -u
$ cd .. $ cd ..
$ rmdir nested $ rmdir nested
don't allow marking or unmarking driver-resolved files
$ cat > $TESTTMP/markdriver.py << EOF
> '''mark and unmark files as driver-resolved'''
> from mercurial import (
> mergestate,
> pycompat,
> registrar,
> scmutil,
> )
> cmdtable = {}
> command = registrar.command(cmdtable)
> @command(b'markdriver',
> [(b'u', b'unmark', None, b'')],
> b'FILE...')
> def markdriver(ui, repo, *pats, **opts):
> wlock = repo.wlock()
> opts = pycompat.byteskwargs(opts)
> try:
> ms = mergestate.mergestate.read(repo)
> m = scmutil.match(repo[None], pats, opts)
> for f in ms:
> if not m(f):
> continue
> if not opts[b'unmark']:
> ms.mark(f, b'd')
> else:
> ms.mark(f, b'u')
> ms.commit()
> finally:
> wlock.release()
> EOF
$ hg --config extensions.markdriver=$TESTTMP/markdriver.py markdriver file1
$ hg resolve --list
D file1
U file2
$ hg resolve --mark file1
not marking file1 as it is driver-resolved
this should not print out file1
$ hg resolve --mark --all
(no more unresolved files -- run "hg resolve --all" to conclude)
$ hg resolve --mark 'glob:file*'
(no more unresolved files -- run "hg resolve --all" to conclude)
$ hg resolve --list
D file1
R file2
$ hg resolve --unmark file1
not unmarking file1 as it is driver-resolved
(no more unresolved files -- run "hg resolve --all" to conclude)
$ hg resolve --unmark --all
$ hg resolve --list
D file1
U file2
$ hg --config extensions.markdriver=$TESTTMP/markdriver.py markdriver --unmark file1
$ hg resolve --list
U file1
U file2
resolve the failure resolve the failure
$ echo resolved > file1 $ echo resolved > file1
$ hg resolve -m file1 $ hg resolve -m file1
resolve -l should show resolved file as resolved resolve -l should show resolved file as resolved
$ hg resolve -l $ hg resolve -l