This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9069

largefiles: prevent in-memory merge instead of switching to on-disk
ClosedPublic

Authored by martinvonz on Sep 23 2020, 3:12 AM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHGe5e1285b6f6f: largefiles: prevent in-memory merge instead of switching to on-disk
Summary

I enabled in-memory merge by default while testing some changes. I
spent quite some time troubleshooting why largefiles was still
creating an on-disk mergestate. Then I found out that it ignores the
callers wc argument to mergemod._update() and always uses on-disk
merge. This patch changes that so we raise an error if largefiles is
used with in-memory merge. That way we'll notice if in-memory merge is
used with largefiles instead of silently replacing ignoring the
overlayworkingctx instance and updating the working copy instead.

I felt a little bad that this would break things more for users with
both largefiles and in-memory rebase enabled. So I also added a
higher-level override to make sure that largefiles disables in-memory
rebase. It turns out that that fixes `run-tests.py -k largefiles
--extra-config-opt rebase.experimental.inmemory=1`.

Diff Detail

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

Revision Contents
Changeset List

Diff 22769

hgext/largefiles/__init__.py

proto.httpoldcallstream = httppeer.httppeer._callstream proto.httpoldcallstream = httppeer.httppeer._callstream
sshpeer.sshv1peer._callstream = proto.sshrepocallstream sshpeer.sshv1peer._callstream = proto.sshrepocallstream
httppeer.httppeer._callstream = proto.httprepocallstream httppeer.httppeer._callstream = proto.httprepocallstream
# override some extensions' stuff as well # override some extensions' stuff as well
for name, module in extensions.extensions(): for name, module in extensions.extensions():
if name == b'rebase': if name == b'rebase':
# TODO: teach exthelper to handle this # TODO: teach exthelper to handle this
extensions.wrapfunction(module, b'rebase', overrides.overriderebase) extensions.wrapfunction(
module, b'rebase', overrides.overriderebasecmd
)
revsetpredicate = eh.revsetpredicate revsetpredicate = eh.revsetpredicate

hgext/largefiles/overrides.py

if missing != 0: if missing != 0:
return None return None
return result return result
@eh.wrapcommand(b'rebase', extension=b'rebase') @eh.wrapcommand(b'rebase', extension=b'rebase')
def overriderebase(orig, ui, repo, **opts): def overriderebasecmd(orig, ui, repo, **opts):
if not util.safehasattr(repo, b'_largefilesenabled'): if not util.safehasattr(repo, b'_largefilesenabled'):
return orig(ui, repo, **opts) return orig(ui, repo, **opts)
resuming = opts.get('continue') resuming = opts.get('continue')
repo._lfcommithooks.append(lfutil.automatedcommithook(resuming)) repo._lfcommithooks.append(lfutil.automatedcommithook(resuming))
repo._lfstatuswriters.append(lambda *msg, **opts: None) repo._lfstatuswriters.append(lambda *msg, **opts: None)
try: try:
with ui.configoverride(
{(b'rebase', b'experimental.inmemory'): False}, b"largefiles"
):
return orig(ui, repo, **opts) return orig(ui, repo, **opts)
finally: finally:
repo._lfstatuswriters.pop() repo._lfstatuswriters.pop()
repo._lfcommithooks.pop() repo._lfcommithooks.pop()
@eh.extsetup
def overriderebase(ui):
try:
rebase = extensions.find(b'rebase')
except KeyError:
pass
else:
def _dorebase(orig, *args, **kwargs):
kwargs['inmemory'] = False
return orig(*args, **kwargs)
extensions.wrapfunction(rebase, b'_dorebase', _dorebase)
@eh.wrapcommand(b'archive') @eh.wrapcommand(b'archive')
def overridearchivecmd(orig, ui, repo, dest, **opts): def overridearchivecmd(orig, ui, repo, dest, **opts):
with lfstatus(repo.unfiltered()): with lfstatus(repo.unfiltered()):
return orig(ui, repo.unfiltered(), dest, **opts) return orig(ui, repo.unfiltered(), dest, **opts)
@eh.wrapfunction(webcommands, b'archive') @eh.wrapfunction(webcommands, b'archive')
def hgwebarchive(orig, web): def hgwebarchive(orig, web):
lfutil.updatestandin(repo, lfile, fstandin) lfutil.updatestandin(repo, lfile, fstandin)
# mark all clean largefiles as dirty, just in case the update gets # mark all clean largefiles as dirty, just in case the update gets
# interrupted before largefiles and lfdirstate are synchronized # interrupted before largefiles and lfdirstate are synchronized
for lfile in oldclean: for lfile in oldclean:
lfdirstate.normallookup(lfile) lfdirstate.normallookup(lfile)
lfdirstate.write() lfdirstate.write()
oldstandins = lfutil.getstandinsstate(repo) oldstandins = lfutil.getstandinsstate(repo)
# Make sure the merge runs on disk, not in-memory. largefiles is not a wc = kwargs.get('wc')
# good candidate for in-memory merge (large files, custom dirstate, if wc and wc.isinmemory():
# matcher usage). # largefiles is not a good candidate for in-memory merge (large
kwargs['wc'] = repo[None] # files, custom dirstate, matcher usage).
raise error.ProgrammingError(
b'largefiles is not compatible with in-memory merge'
)
result = orig(repo, node, branchmerge, force, *args, **kwargs) result = orig(repo, node, branchmerge, force, *args, **kwargs)
newstandins = lfutil.getstandinsstate(repo) newstandins = lfutil.getstandinsstate(repo)
filelist = lfutil.getlfilestoupdate(oldstandins, newstandins) filelist = lfutil.getlfilestoupdate(oldstandins, newstandins)
# to avoid leaving all largefiles as dirty and thus rehash them, mark # to avoid leaving all largefiles as dirty and thus rehash them, mark
# all the ones that didn't change as clean # all the ones that didn't change as clean
for lfile in oldclean.difference(filelist): for lfile in oldclean.difference(filelist):