This is an archive of the discontinued Mercurial Phabricator instance.

Differential D3395

wireproto: make version 2 @wireprotocommand an independent function
ClosedPublic

Authored by indygreg on Apr 17 2018, 1:30 AM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHG8acd3a9ac4fd: wireproto: make version 2 @wireprotocommand an independent function
Summary

Previously, the code for this decorator was shared between version 1
and version 2 commands. Very few parts of the function were identical.
So I don't think sharing is justified.

wireprotov2server now has its own @wireprotocommand decorator function.
Because the decorator is no longer shared, code for configuring the
transport policy has been removed. i.e. commands must have separate
implementations for each wire protocol version.

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

indygreg created this revision.Apr 17 2018, 1:30 AM
durin42 accepted this revision.Apr 18 2018, 2:25 PM
This revision is now accepted and ready to land.Apr 18 2018, 2:25 PM
Closed by commit rHG8acd3a9ac4fd: wireproto: make version 2 @wireprotocommand an independent function (authored by indygreg). · Explain WhyApr 18 2018, 2:41 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 8383

mercurial/wireproto.py

if not entry: if not entry:
return False return False
if proto.name not in entry.transports: if proto.name not in entry.transports:
return False return False
return True return True
# Constants specifying which transports a wire protocol command should be
# available on. For use with @wireprotocommand.
POLICY_V1_ONLY = 'v1-only'
POLICY_V2_ONLY = 'v2-only'
# For version 1 transports. # For version 1 transports.
commands = commanddict() commands = commanddict()
# For version 2 transports. # For version 2 transports.
commandsv2 = commanddict() commandsv2 = commanddict()
def wireprotocommand(name, args=None, transportpolicy=POLICY_V1_ONLY, def wireprotocommand(name, args=None, permission='push'):
permission='push'):
"""Decorator to declare a wire protocol command. """Decorator to declare a wire protocol command.
``name`` is the name of the wire protocol command being provided. ``name`` is the name of the wire protocol command being provided.
``args`` defines the named arguments accepted by the command. It is ``args`` defines the named arguments accepted by the command. It is
ideally a dict mapping argument names to their types. For backwards a space-delimited list of argument names. ``*`` denotes a special value
compatibility, it can be a space-delimited list of argument names. For that says to accept all named arguments.
version 1 transports, ``*`` denotes a special value that says to accept
all named arguments.
``transportpolicy`` is a POLICY_* constant denoting which transports
this wire protocol command should be exposed to. By default, commands
are exposed to all wire protocol transports.
``permission`` defines the permission type needed to run this command. ``permission`` defines the permission type needed to run this command.
Can be ``push`` or ``pull``. These roughly map to read-write and read-only, Can be ``push`` or ``pull``. These roughly map to read-write and read-only,
respectively. Default is to assume command requires ``push`` permissions respectively. Default is to assume command requires ``push`` permissions
because otherwise commands not declaring their permissions could modify because otherwise commands not declaring their permissions could modify
a repository that is supposed to be read-only. a repository that is supposed to be read-only.
""" """
if transportpolicy == POLICY_V1_ONLY:
transports = {k for k, v in wireprototypes.TRANSPORTS.items() transports = {k for k, v in wireprototypes.TRANSPORTS.items()
if v['version'] == 1} if v['version'] == 1}
transportversion = 1
elif transportpolicy == POLICY_V2_ONLY:
transports = {k for k, v in wireprototypes.TRANSPORTS.items()
if v['version'] == 2}
transportversion = 2
else:
raise error.ProgrammingError('invalid transport policy value: %s' %
transportpolicy)
# Because SSHv2 is a mirror of SSHv1, we allow "batch" commands through to # Because SSHv2 is a mirror of SSHv1, we allow "batch" commands through to
# SSHv2. # SSHv2.
# TODO undo this hack when SSH is using the unified frame protocol. # TODO undo this hack when SSH is using the unified frame protocol.
if name == b'batch': if name == b'batch':
transports.add(wireprototypes.SSHV2) transports.add(wireprototypes.SSHV2)
if permission not in ('push', 'pull'): if permission not in ('push', 'pull'):
raise error.ProgrammingError('invalid wire protocol permission; ' raise error.ProgrammingError('invalid wire protocol permission; '
'got %s; expected "push" or "pull"' % 'got %s; expected "push" or "pull"' %
permission) permission)
if transportversion == 1:
if args is None: if args is None:
args = '' args = ''
if not isinstance(args, bytes): if not isinstance(args, bytes):
raise error.ProgrammingError('arguments for version 1 commands ' raise error.ProgrammingError('arguments for version 1 commands '
'must be declared as bytes') 'must be declared as bytes')
elif transportversion == 2:
if args is None:
args = {}
if not isinstance(args, dict):
raise error.ProgrammingError('arguments for version 2 commands '
'must be declared as dicts')
def register(func): def register(func):
if transportversion == 1:
if name in commands: if name in commands:
raise error.ProgrammingError('%s command already registered ' raise error.ProgrammingError('%s command already registered '
'for version 1' % name) 'for version 1' % name)
commands[name] = commandentry(func, args=args, commands[name] = commandentry(func, args=args,
transports=transports, transports=transports,
permission=permission) permission=permission)
elif transportversion == 2:
if name in commandsv2:
raise error.ProgrammingError('%s command already registered '
'for version 2' % name)
commandsv2[name] = commandentry(func, args=args,
transports=transports,
permission=permission)
else:
raise error.ProgrammingError('unhandled transport version: %d' %
transportversion)
return func return func
return register return register
# TODO define a more appropriate permissions type to use for this. # TODO define a more appropriate permissions type to use for this.
@wireprotocommand('batch', 'cmds *', permission='pull') @wireprotocommand('batch', 'cmds *', permission='pull')
def batch(repo, proto, cmds, others): def batch(repo, proto, cmds, others):
unescapearg = wireprototypes.unescapebatcharg unescapearg = wireprototypes.unescapebatcharg

mercurial/wireprotov2server.py

} }
if streamclone.allowservergeneration(repo): if streamclone.allowservergeneration(repo):
caps['rawrepoformats'] = sorted(repo.requirements & caps['rawrepoformats'] = sorted(repo.requirements &
repo.supportedformats) repo.supportedformats)
return proto.addcapabilities(repo, caps) return proto.addcapabilities(repo, caps)
def wireprotocommand(*args, **kwargs): def wireprotocommand(name, args=None, permission='push'):
"""Decorator to declare a wire protocol command.
``name`` is the name of the wire protocol command being provided.
``args`` is a dict of argument names to example values.
``permission`` defines the permission type needed to run this command.
Can be ``push`` or ``pull``. These roughly map to read-write and read-only,
respectively. Default is to assume command requires ``push`` permissions
because otherwise commands not declaring their permissions could modify
a repository that is supposed to be read-only.
"""
transports = {k for k, v in wireprototypes.TRANSPORTS.items()
if v['version'] == 2}
if permission not in ('push', 'pull'):
raise error.ProgrammingError('invalid wire protocol permission; '
'got %s; expected "push" or "pull"' %
permission)
if args is None:
args = {}
if not isinstance(args, dict):
raise error.ProgrammingError('arguments for version 2 commands '
'must be declared as dicts')
def register(func): def register(func):
return wireproto.wireprotocommand( if name in wireproto.commandsv2:
*args, transportpolicy=wireproto.POLICY_V2_ONLY, **kwargs)(func) raise error.ProgrammingError('%s command already registered '
'for version 2' % name)
wireproto.commandsv2[name] = wireproto.commandentry(
func, args=args, transports=transports, permission=permission)
return func
return register return register
@wireprotocommand('branchmap', permission='pull') @wireprotocommand('branchmap', permission='pull')
def branchmapv2(repo, proto): def branchmapv2(repo, proto):
branchmap = {encoding.fromlocal(k): v branchmap = {encoding.fromlocal(k): v
for k, v in repo.branchmap().iteritems()} for k, v in repo.branchmap().iteritems()}

tests/wireprotohelpers.sh

sendhttpv2peerhandshake() { sendhttpv2peerhandshake() {
hg --verbose debugwireproto --peer http2 http://$LOCALIP:$HGPORT/ hg --verbose debugwireproto --peer http2 http://$LOCALIP:$HGPORT/
} }
cat > dummycommands.py << EOF cat > dummycommands.py << EOF
from mercurial import ( from mercurial import (
wireprototypes, wireprototypes,
wireprotov2server,
wireproto, wireproto,
) )
@wireproto.wireprotocommand('customreadonly', permission='pull') @wireproto.wireprotocommand('customreadonly', permission='pull')
def customreadonlyv1(repo, proto): def customreadonlyv1(repo, proto):
return wireprototypes.bytesresponse(b'customreadonly bytes response') return wireprototypes.bytesresponse(b'customreadonly bytes response')
@wireproto.wireprotocommand('customreadonly', permission='pull', @wireprotov2server.wireprotocommand('customreadonly', permission='pull')
transportpolicy=wireproto.POLICY_V2_ONLY)
def customreadonlyv2(repo, proto): def customreadonlyv2(repo, proto):
return wireprototypes.cborresponse(b'customreadonly bytes response') return wireprototypes.cborresponse(b'customreadonly bytes response')
@wireproto.wireprotocommand('customreadwrite', permission='push') @wireproto.wireprotocommand('customreadwrite', permission='push')
def customreadwrite(repo, proto): def customreadwrite(repo, proto):
return wireprototypes.bytesresponse(b'customreadwrite bytes response') return wireprototypes.bytesresponse(b'customreadwrite bytes response')
@wireproto.wireprotocommand('customreadwrite', permission='push', @wireprotov2server.wireprotocommand('customreadwrite', permission='push')
transportpolicy=wireproto.POLICY_V2_ONLY)
def customreadwritev2(repo, proto): def customreadwritev2(repo, proto):
return wireprototypes.cborresponse(b'customreadwrite bytes response') return wireprototypes.cborresponse(b'customreadwrite bytes response')
EOF EOF
cat >> $HGRCPATH << EOF cat >> $HGRCPATH << EOF
[extensions] [extensions]
drawdag = $TESTDIR/drawdag.py drawdag = $TESTDIR/drawdag.py
EOF EOF