This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4890

wireprotoserver: move narrow capabilities to wireprototypes.py
ClosedPublic

Authored by pulkit on Oct 5 2018, 4:17 PM.

Details

Reviewers
durin42
martinvonz
Group Reviewers
hg-reviewers
Commits
rHGf7011b44d205: wireprotoserver: move narrow capabilities to wireprototypes.py
Summary

This is done because wireprotoserver import wireprotov1server, so you cannot
import wireprotoserver in wireprotov1server to use the capabilities constants.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

pulkit created this revision.Oct 5 2018, 4:17 PM
Closed by commit rHGf7011b44d205: wireprotoserver: move narrow capabilities to wireprototypes.py (authored by pulkit). · Explain WhyOct 5 2018, 5:57 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 11709

hgext/narrow/narrowcommands.py

node, node,
pycompat, pycompat,
registrar, registrar,
repair, repair,
repository, repository,
repoview, repoview,
sparse, sparse,
util, util,
wireprotoserver, wireprototypes,
) )
table = {} table = {}
command = registrar.command(table) command = registrar.command(table)
def setup(): def setup():
"""Wraps user-facing mercurial commands with narrow-aware versions.""" """Wraps user-facing mercurial commands with narrow-aware versions."""
opts[r'exclude'] = excludes opts[r'exclude'] = excludes
return orig(ui, repo, *args, **opts) return orig(ui, repo, *args, **opts)
def pullbundle2extraprepare(orig, pullop, kwargs): def pullbundle2extraprepare(orig, pullop, kwargs):
repo = pullop.repo repo = pullop.repo
if repository.NARROW_REQUIREMENT not in repo.requirements: if repository.NARROW_REQUIREMENT not in repo.requirements:
return orig(pullop, kwargs) return orig(pullop, kwargs)
if wireprotoserver.NARROWCAP not in pullop.remote.capabilities(): if wireprototypes.NARROWCAP not in pullop.remote.capabilities():
raise error.Abort(_("server does not support narrow clones")) raise error.Abort(_("server does not support narrow clones"))
orig(pullop, kwargs) orig(pullop, kwargs)
kwargs['narrow'] = True kwargs['narrow'] = True
include, exclude = repo.narrowpats include, exclude = repo.narrowpats
kwargs['oldincludepats'] = include kwargs['oldincludepats'] = include
kwargs['oldexcludepats'] = exclude kwargs['oldexcludepats'] = exclude
kwargs['includepats'] = include kwargs['includepats'] = include
kwargs['excludepats'] = exclude kwargs['excludepats'] = exclude
# calculate known nodes only in ellipses cases because in non-ellipses cases # calculate known nodes only in ellipses cases because in non-ellipses cases
# we have all the nodes # we have all the nodes
if wireprotoserver.ELLIPSESCAP in pullop.remote.capabilities(): if wireprototypes.ELLIPSESCAP in pullop.remote.capabilities():
kwargs['known'] = [node.hex(ctx.node()) for ctx in kwargs['known'] = [node.hex(ctx.node()) for ctx in
repo.set('::%ln', pullop.common) repo.set('::%ln', pullop.common)
if ctx.node() != node.nullid] if ctx.node() != node.nullid]
if not kwargs['known']: if not kwargs['known']:
# Mercurial serializes an empty list as '' and deserializes it as # Mercurial serializes an empty list as '' and deserializes it as
# [''], so delete it instead to avoid handling the empty string on # [''], so delete it instead to avoid handling the empty string on
# the server. # the server.
del kwargs['known'] del kwargs['known']
newmatch = narrowspec.match(repo.root, newincludes, newexcludes) newmatch = narrowspec.match(repo.root, newincludes, newexcludes)
# for now we assume that if a server has ellipses enabled, we will be # for now we assume that if a server has ellipses enabled, we will be
# exchanging ellipses nodes. In future we should add ellipses as a client # exchanging ellipses nodes. In future we should add ellipses as a client
# side requirement (maybe) to distinguish a client is shallow or not and # side requirement (maybe) to distinguish a client is shallow or not and
# then send that information to server whether we want ellipses or not. # then send that information to server whether we want ellipses or not.
# Theoretically a non-ellipses repo should be able to use narrow # Theoretically a non-ellipses repo should be able to use narrow
# functionality from an ellipses enabled server # functionality from an ellipses enabled server
ellipsesremote = wireprotoserver.ELLIPSESCAP in remote.capabilities() ellipsesremote = wireprototypes.ELLIPSESCAP in remote.capabilities()
def pullbundle2extraprepare_widen(orig, pullop, kwargs): def pullbundle2extraprepare_widen(orig, pullop, kwargs):
orig(pullop, kwargs) orig(pullop, kwargs)
# The old{in,ex}cludepats have already been set by orig() # The old{in,ex}cludepats have already been set by orig()
kwargs['includepats'] = newincludes kwargs['includepats'] = newincludes
kwargs['excludepats'] = newexcludes kwargs['excludepats'] = newexcludes
wrappedextraprepare = extensions.wrappedfunction(exchange, wrappedextraprepare = extensions.wrappedfunction(exchange,
'_pullbundle2extraprepare', pullbundle2extraprepare_widen) '_pullbundle2extraprepare', pullbundle2extraprepare_widen)
remotepath = ui.expandpath(remotepath or 'default') remotepath = ui.expandpath(remotepath or 'default')
url, branches = hg.parseurl(remotepath) url, branches = hg.parseurl(remotepath)
ui.status(_('comparing with %s\n') % util.hidepassword(url)) ui.status(_('comparing with %s\n') % util.hidepassword(url))
remote = hg.peer(repo, opts, url) remote = hg.peer(repo, opts, url)
# check narrow support before doing anything if widening needs to be # check narrow support before doing anything if widening needs to be
# performed. In future we should also abort if client is ellipses and # performed. In future we should also abort if client is ellipses and
# server does not support ellipses # server does not support ellipses
if widening and wireprotoserver.NARROWCAP not in remote.capabilities(): if widening and wireprototypes.NARROWCAP not in remote.capabilities():
raise error.Abort(_("server does not support narrow clones")) raise error.Abort(_("server does not support narrow clones"))
commoninc = discovery.findcommonincoming(repo, remote) commoninc = discovery.findcommonincoming(repo, remote)
oldincludes, oldexcludes = repo.narrowpats oldincludes, oldexcludes = repo.narrowpats
if narrowing: if narrowing:
newincludes = oldincludes - removedincludes newincludes = oldincludes - removedincludes
newexcludes = oldexcludes | addedexcludes newexcludes = oldexcludes | addedexcludes

hgext/narrow/narrowrepo.py

# narrowrepo.py - repository which supports narrow revlogs, lazy loading # narrowrepo.py - repository which supports narrow revlogs, lazy loading
# #
# Copyright 2017 Google, Inc. # Copyright 2017 Google, Inc.
# #
# 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
from mercurial import ( from mercurial import (
wireprotoserver, wireprototypes,
) )
from . import ( from . import (
narrowdirstate, narrowdirstate,
) )
def wraprepo(repo): def wraprepo(repo):
"""Enables narrow clone functionality on a single local repository.""" """Enables narrow clone functionality on a single local repository."""
class narrowrepository(repo.__class__): class narrowrepository(repo.__class__):
def _makedirstate(self): def _makedirstate(self):
dirstate = super(narrowrepository, self)._makedirstate() dirstate = super(narrowrepository, self)._makedirstate()
return narrowdirstate.wrapdirstate(self, dirstate) return narrowdirstate.wrapdirstate(self, dirstate)
def peer(self): def peer(self):
peer = super(narrowrepository, self).peer() peer = super(narrowrepository, self).peer()
peer._caps.add(wireprotoserver.NARROWCAP) peer._caps.add(wireprototypes.NARROWCAP)
peer._caps.add(wireprotoserver.ELLIPSESCAP) peer._caps.add(wireprototypes.ELLIPSESCAP)
return peer return peer
repo.__class__ = narrowrepository repo.__class__ = narrowrepository

hgext/narrow/narrowwirepeer.py

from mercurial import ( from mercurial import (
bundle2, bundle2,
error, error,
extensions, extensions,
hg, hg,
match as matchmod, match as matchmod,
narrowspec, narrowspec,
pycompat, pycompat,
wireprotoserver,
wireprototypes, wireprototypes,
wireprotov1peer, wireprotov1peer,
wireprotov1server, wireprotov1server,
) )
def uisetup(): def uisetup():
extensions.wrapfunction(wireprotov1server, '_capabilities', addnarrowcap) extensions.wrapfunction(wireprotov1server, '_capabilities', addnarrowcap)
wireprotov1peer.wirepeer.narrow_widen = peernarrowwiden wireprotov1peer.wirepeer.narrow_widen = peernarrowwiden
def addnarrowcap(orig, repo, proto): def addnarrowcap(orig, repo, proto):
"""add the narrow capability to the server""" """add the narrow capability to the server"""
caps = orig(repo, proto) caps = orig(repo, proto)
caps.append(wireprotoserver.NARROWCAP) caps.append(wireprototypes.NARROWCAP)
if repo.ui.configbool('experimental', 'narrowservebrokenellipses'): if repo.ui.configbool('experimental', 'narrowservebrokenellipses'):
caps.append(wireprotoserver.ELLIPSESCAP) caps.append(wireprototypes.ELLIPSESCAP)
return caps return caps
def reposetup(repo): def reposetup(repo):
def wirereposetup(ui, peer): def wirereposetup(ui, peer):
def wrapped(orig, cmd, *args, **kwargs): def wrapped(orig, cmd, *args, **kwargs):
if cmd == 'unbundle': if cmd == 'unbundle':
# TODO: don't blindly add include/exclude wireproto # TODO: don't blindly add include/exclude wireproto
# arguments to unbundle. # arguments to unbundle.

mercurial/wireprotoserver.py

urlreq = util.urlreq urlreq = util.urlreq
HTTP_OK = 200 HTTP_OK = 200
HGTYPE = 'application/mercurial-0.1' HGTYPE = 'application/mercurial-0.1'
HGTYPE2 = 'application/mercurial-0.2' HGTYPE2 = 'application/mercurial-0.2'
HGERRTYPE = 'application/hg-error' HGERRTYPE = 'application/hg-error'
NARROWCAP = 'exp-narrow-1'
ELLIPSESCAP = 'exp-ellipses-1'
SSHV1 = wireprototypes.SSHV1 SSHV1 = wireprototypes.SSHV1
SSHV2 = wireprototypes.SSHV2 SSHV2 = wireprototypes.SSHV2
def decodevaluefromheaders(req, headerprefix): def decodevaluefromheaders(req, headerprefix):
"""Decode a long value from multiple HTTP request headers. """Decode a long value from multiple HTTP request headers.
Returns the value as a bytes, not a str. Returns the value as a bytes, not a str.
""" """

mercurial/wireprototypes.py

# Names of the SSH protocol implementations. # Names of the SSH protocol implementations.
SSHV1 = 'ssh-v1' SSHV1 = 'ssh-v1'
# These are advertised over the wire. Increment the counters at the end # These are advertised over the wire. Increment the counters at the end
# to reflect BC breakages. # to reflect BC breakages.
SSHV2 = 'exp-ssh-v2-0002' SSHV2 = 'exp-ssh-v2-0002'
HTTP_WIREPROTO_V2 = 'exp-http-v2-0002' HTTP_WIREPROTO_V2 = 'exp-http-v2-0002'
NARROWCAP = 'exp-narrow-1'
ELLIPSESCAP = 'exp-ellipses-1'
# All available wire protocol transports. # All available wire protocol transports.
TRANSPORTS = { TRANSPORTS = {
SSHV1: { SSHV1: {
'transport': 'ssh', 'transport': 'ssh',
'version': 1, 'version': 1,
}, },
SSHV2: { SSHV2: {
'transport': 'ssh', 'transport': 'ssh',