This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9663

largefiles: redo heads interception
ClosedPublic

Authored by joerg.sonnenberger on Dec 27 2020, 9:40 PM.

Details

Reviewers
marmoute
pulkit
Group Reviewers
hg-reviewers
Commits
rHGbd31462a86a2: largefiles: redo heads interception
Summary

The largefiles extension replaces the "heads" wire command and tries to
redirect all uses towards the custom "lheads" wire command. As seen in
issue6384, this doesn't currently work for ssh. Instead of hooking into
the _callstream interface, properly register the command for the peer
instance and monkeypatch the executor to do the redirection. This works
transparently for both all kinds of peers and both for the batch and
non-batch case.

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 accepted this revision.Jan 7 2021, 8:23 AM
marmoute added a subscriber: marmoute.

This looks simpler and cleaner.

pulkit accepted this revision.Jan 9 2021, 5:07 AM
This revision is now accepted and ready to land.Jan 9 2021, 5:07 AM
joerg.sonnenberger added a commit: rHGbd31462a86a2: largefiles: redo heads interception.Jan 9 2021, 6:12 AM
Closed by commit rHGbd31462a86a2: largefiles: redo heads interception (authored by joerg.sonnenberger). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 24689

hgext/largefiles/__init__.py

wireprotov1server.heads wireprotov1server.heads
) )
extensions.wrapfunction( extensions.wrapfunction(
wireprotov1server.commands[b'heads'], b'func', proto.heads wireprotov1server.commands[b'heads'], b'func', proto.heads
) )
# TODO also wrap wireproto.commandsv2 once heads is implemented there. # TODO also wrap wireproto.commandsv2 once heads is implemented there.
# can't do this in reposetup because it needs to have happened before
# wirerepo.__init__ is called
proto.ssholdcallstream = sshpeer.sshv1peer._callstream
proto.httpoldcallstream = httppeer.httppeer._callstream
sshpeer.sshv1peer._callstream = proto.sshrepocallstream
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( extensions.wrapfunction(
module, b'rebase', overrides.overriderebasecmd module, b'rebase', overrides.overriderebasecmd
) )
revsetpredicate = eh.revsetpredicate revsetpredicate = eh.revsetpredicate

hgext/largefiles/proto.py

LARGEFILES_REQUIRED_MSG = ( LARGEFILES_REQUIRED_MSG = (
b'\nThis repository uses the largefiles extension.' b'\nThis repository uses the largefiles extension.'
b'\n\nPlease enable it in your Mercurial config ' b'\n\nPlease enable it in your Mercurial config '
b'file.\n' b'file.\n'
) )
eh = exthelper.exthelper() eh = exthelper.exthelper()
# these will all be replaced by largefiles.uisetup
ssholdcallstream = None
httpoldcallstream = None
def putlfile(repo, proto, sha): def putlfile(repo, proto, sha):
"""Server command for putting a largefile into a repository's local store """Server command for putting a largefile into a repository's local store
and into the user cache.""" and into the user cache."""
with proto.mayberedirectstdio() as output: with proto.mayberedirectstdio() as output:
path = lfutil.storepath(repo, sha) path = lfutil.storepath(repo, sha)
util.makedirs(os.path.dirname(path)) util.makedirs(os.path.dirname(path))
tmpfp = util.atomictempfile(path, createmode=repo.store.createmode) tmpfp = util.atomictempfile(path, createmode=repo.store.createmode)
server side.""" server side."""
filename = lfutil.findfile(repo, sha) filename = lfutil.findfile(repo, sha)
if not filename: if not filename:
return wireprototypes.bytesresponse(b'2\n') return wireprototypes.bytesresponse(b'2\n')
return wireprototypes.bytesresponse(b'0\n') return wireprototypes.bytesresponse(b'0\n')
def wirereposetup(ui, repo): def wirereposetup(ui, repo):
orig_commandexecutor = repo.commandexecutor
class lfileswirerepository(repo.__class__): class lfileswirerepository(repo.__class__):
def commandexecutor(self):
executor = orig_commandexecutor()
if self.capable(b'largefiles'):
orig_callcommand = executor.callcommand
class lfscommandexecutor(executor.__class__):
def callcommand(self, command, args):
if command == b'heads':
command = b'lheads'
return orig_callcommand(command, args)
executor.__class__ = lfscommandexecutor
return executor
@wireprotov1peer.batchable
def lheads(self):
return self.heads.batchable(self)
def putlfile(self, sha, fd): def putlfile(self, sha, fd):
# unfortunately, httprepository._callpush tries to convert its # unfortunately, httprepository._callpush tries to convert its
# input file-like into a bundle before sending it, so we can't use # input file-like into a bundle before sending it, so we can't use
# it ... # it ...
if issubclass(self.__class__, httppeer.httppeer): if issubclass(self.__class__, httppeer.httppeer):
res = self._call( res = self._call(
b'putlfile', b'putlfile',
data=fd, data=fd,
def heads(orig, repo, proto): def heads(orig, repo, proto):
"""Wrap server command - largefile capable clients will know to call """Wrap server command - largefile capable clients will know to call
lheads instead""" lheads instead"""
if lfutil.islfilesrepo(repo): if lfutil.islfilesrepo(repo):
return wireprototypes.ooberror(LARGEFILES_REQUIRED_MSG) return wireprototypes.ooberror(LARGEFILES_REQUIRED_MSG)
return orig(repo, proto) return orig(repo, proto)
def sshrepocallstream(self, cmd, **args):
if cmd == b'heads' and self.capable(b'largefiles'):
cmd = b'lheads'
if cmd == b'batch' and self.capable(b'largefiles'):
args['cmds'] = args[r'cmds'].replace(b'heads ', b'lheads ')
return ssholdcallstream(self, cmd, **args)
headsre = re.compile(br'(^|;)heads\b')
def httprepocallstream(self, cmd, **args):
if cmd == b'heads' and self.capable(b'largefiles'):
cmd = b'lheads'
if cmd == b'batch' and self.capable(b'largefiles'):
args['cmds'] = headsre.sub(b'lheads', args['cmds'])
return httpoldcallstream(self, cmd, **args)