This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2485

wireproto: don't expose legacy commands to version 2 of wire protocol
ClosedPublic

Authored by indygreg on Feb 27 2018, 6:49 PM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHG6906547c8476: wireproto: don't expose legacy commands to version 2 of wire protocol
Summary

Now that we have the ability to control which transports a wire
protocol command is exposed on, let's put it to use.

We flag the "branches," "changegroup," and "changegroupsubset"
commands as only available on version 1. "branches" was used by the
legacy discovery mechanism and was replaced by the "known" and
"heads" commands. "changegroup" and "changegroupsubset" were
replaced by "getbundle."

"between" is also legacy. However, since it is used by the SSH
handshake protocol, marking it as legacy is a bit more complicated
and will be done in a later commit.

Another nuanced issue with this change is that the server-advertised
capabilities still list "changegroupsubset" despite the command not
being available. This will be addressed in a subsequent commit.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

indygreg created this revision.Feb 27 2018, 6:49 PM
indygreg updated this revision to Diff 6336.Mar 2 2018, 9:50 AM
durin42 accepted this revision.Mar 2 2018, 7:05 PM
This revision is now accepted and ready to land.Mar 2 2018, 7:05 PM
Closed by commit rHG6906547c8476: wireproto: don't expose legacy commands to version 2 of wire protocol (authored by indygreg). · Explain WhyMar 2 2018, 7:13 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/wireproto.py (9 lines)
Mtests/test-ssh-proto.t (27 lines)

Diff 6184

mercurial/wireproto.py

# raw bytes (for backwards compatibility). # raw bytes (for backwards compatibility).
assert isinstance(result, (bytesresponse, bytes)) assert isinstance(result, (bytesresponse, bytes))
if isinstance(result, bytesresponse): if isinstance(result, bytesresponse):
result = result.data result = result.data
res.append(escapearg(result)) res.append(escapearg(result))
return bytesresponse(';'.join(res)) return bytesresponse(';'.join(res))
# TODO mark as version 1 transport only once interaction with
# SSH handshake mechanism is figured out.
@wireprotocommand('between', 'pairs') @wireprotocommand('between', 'pairs')
def between(repo, proto, pairs): def between(repo, proto, pairs):
pairs = [decodelist(p, '-') for p in pairs.split(" ")] pairs = [decodelist(p, '-') for p in pairs.split(" ")]
r = [] r = []
for b in repo.between(pairs): for b in repo.between(pairs):
r.append(encodelist(b) + "\n") r.append(encodelist(b) + "\n")
return bytesresponse(''.join(r)) return bytesresponse(''.join(r))
@wireprotocommand('branchmap') @wireprotocommand('branchmap')
def branchmap(repo, proto): def branchmap(repo, proto):
branchmap = repo.branchmap() branchmap = repo.branchmap()
heads = [] heads = []
for branch, nodes in branchmap.iteritems(): for branch, nodes in branchmap.iteritems():
branchname = urlreq.quote(encoding.fromlocal(branch)) branchname = urlreq.quote(encoding.fromlocal(branch))
branchnodes = encodelist(nodes) branchnodes = encodelist(nodes)
heads.append('%s %s' % (branchname, branchnodes)) heads.append('%s %s' % (branchname, branchnodes))
return bytesresponse('\n'.join(heads)) return bytesresponse('\n'.join(heads))
@wireprotocommand('branches', 'nodes') @wireprotocommand('branches', 'nodes', transportpolicy=POLICY_V1_ONLY)
def branches(repo, proto, nodes): def branches(repo, proto, nodes):
nodes = decodelist(nodes) nodes = decodelist(nodes)
r = [] r = []
for b in repo.branches(nodes): for b in repo.branches(nodes):
r.append(encodelist(b) + "\n") r.append(encodelist(b) + "\n")
return bytesresponse(''.join(r)) return bytesresponse(''.join(r))
return caps return caps
# If you are writing an extension and consider wrapping this function. Wrap # If you are writing an extension and consider wrapping this function. Wrap
# `_capabilities` instead. # `_capabilities` instead.
@wireprotocommand('capabilities') @wireprotocommand('capabilities')
def capabilities(repo, proto): def capabilities(repo, proto):
return bytesresponse(' '.join(_capabilities(repo, proto))) return bytesresponse(' '.join(_capabilities(repo, proto)))
@wireprotocommand('changegroup', 'roots') @wireprotocommand('changegroup', 'roots', transportpolicy=POLICY_V1_ONLY)
def changegroup(repo, proto, roots): def changegroup(repo, proto, roots):
nodes = decodelist(roots) nodes = decodelist(roots)
outgoing = discovery.outgoing(repo, missingroots=nodes, outgoing = discovery.outgoing(repo, missingroots=nodes,
missingheads=repo.heads()) missingheads=repo.heads())
cg = changegroupmod.makechangegroup(repo, outgoing, '01', 'serve') cg = changegroupmod.makechangegroup(repo, outgoing, '01', 'serve')
gen = iter(lambda: cg.read(32768), '') gen = iter(lambda: cg.read(32768), '')
return streamres(gen=gen) return streamres(gen=gen)
@wireprotocommand('changegroupsubset', 'bases heads') @wireprotocommand('changegroupsubset', 'bases heads',
transportpolicy=POLICY_V1_ONLY)
def changegroupsubset(repo, proto, bases, heads): def changegroupsubset(repo, proto, bases, heads):
bases = decodelist(bases) bases = decodelist(bases)
heads = decodelist(heads) heads = decodelist(heads)
outgoing = discovery.outgoing(repo, missingroots=bases, outgoing = discovery.outgoing(repo, missingroots=bases,
missingheads=heads) missingheads=heads)
cg = changegroupmod.makechangegroup(repo, outgoing, '01', 'serve') cg = changegroupmod.makechangegroup(repo, outgoing, '01', 'serve')
gen = iter(lambda: cg.read(32768), '') gen = iter(lambda: cg.read(32768), '')
return streamres(gen=gen) return streamres(gen=gen)

tests/test-ssh-proto.t

i> between\n i> between\n
i> invalid\n i> invalid\n
o> readline() -> 1: o> readline() -> 1:
o> \n o> \n
e> read(-1) -> 49: e> read(-1) -> 49:
e> malformed handshake protocol: missing pairs 81\n e> malformed handshake protocol: missing pairs 81\n
e> -\n e> -\n
Legacy commands are not exposed to version 2 of protocol
$ hg --config experimental.sshpeer.advertise-v2=true debugwireproto --localssh << EOF
> command branches
> nodes 0000000000000000000000000000000000000000
> EOF
creating ssh peer from handshake results
sending branches command
response:
$ hg --config experimental.sshpeer.advertise-v2=true debugwireproto --localssh << EOF
> command changegroup
> roots 0000000000000000000000000000000000000000
> EOF
creating ssh peer from handshake results
sending changegroup command
response:
$ hg --config experimental.sshpeer.advertise-v2=true debugwireproto --localssh << EOF
> command changegroupsubset
> bases 0000000000000000000000000000000000000000
> heads 0000000000000000000000000000000000000000
> EOF
creating ssh peer from handshake results
sending changegroupsubset command
response:
$ cd .. $ cd ..
Test listkeys for listing namespaces Test listkeys for listing namespaces
$ hg init empty $ hg init empty
$ cd empty $ cd empty
$ debugwireproto << EOF $ debugwireproto << EOF
> command listkeys > command listkeys