This is an archive of the discontinued Mercurial Phabricator instance.

Differential D1998

wireproto: define and use types for wire protocol commands
ClosedPublic

Authored by indygreg on Feb 1 2018, 6:37 PM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHGef683a0fd21f: wireproto: define and use types for wire protocol commands
Summary

Wire protocol commands have historically been declared as
2-tuples in wireproto.commands. There are some additional features I'd
like to implement that require going beyond 2-tuples. But because
the 2-tuple API (both destructuring assignment and direct assignment
into the dict) is used throughout the code base and in 3rd party
extensions, we can't do a trivial type change.

This commit creates a new "commandentry" type to represent declared
wire protocol commands. It implements getitem and iter so
it can quack like a 2-tuple. The @wireprotocommand decorator now
creates "commandentry" instances.

We also create a "commanddict" type to represent the dictionary of
declared wire protocol commands. It inherits from "dict" but provides
a custom setitem to coerce passed 2-tuples to "commandentry"
instances. wireproto.commands is now an instance of this type.

Various callers in core rely on the new functionality. And tests
pass. So I'm reasonably confident things will "just work" in 3rd
party extensions as well.

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.Feb 1 2018, 6:37 PM
durin42 added a subscriber: durin42.Feb 7 2018, 5:19 PM

I'm curious what registrations you need that don't fit in 2-tuples. Can I see a sample of where that's going?

indygreg added a comment.Feb 7 2018, 5:26 PM
In D1998#34740, @durin42 wrote:

I'm curious what registrations you need that don't fit in 2-tuples. Can I see a sample of where that's going?

I'll be adding additional attributes to @wireprotocommand in future series. One thing I know I'll add is a mechanism to limit which wire protocol versions/transports to expose a command to. This will prevent legacy commands from being exposed to modern protocols and vice versa.

durin42 accepted this revision.Feb 7 2018, 5:29 PM

I'm sold.

This revision is now accepted and ready to land.Feb 7 2018, 5:29 PM
Closed by commit rHGef683a0fd21f: wireproto: define and use types for wire protocol commands (authored by indygreg). · Explain WhyFeb 7 2018, 5:41 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/wireproto.py (62 lines)

Diff 5305

mercurial/wireproto.py

if not compengines: if not compengines:
raise error.Abort(_('%s config option does not specify any known ' raise error.Abort(_('%s config option does not specify any known '
'compression engines') % config, 'compression engines') % config,
hint=_('usable compression engines: %s') % hint=_('usable compression engines: %s') %
', '.sorted(validnames)) ', '.sorted(validnames))
return compengines return compengines
# list of commands class commandentry(object):
commands = {} """Represents a declared wire protocol command."""
def __init__(self, func, args=''):
self.func = func
self.args = args
def _merge(self, func, args):
"""Merge this instance with an incoming 2-tuple.
This is called when a caller using the old 2-tuple API attempts
to replace an instance. The incoming values are merged with
data not captured by the 2-tuple and a new instance containing
the union of the two objects is returned.
"""
return commandentry(func, args)
# Old code treats instances as 2-tuples. So expose that interface.
def __iter__(self):
yield self.func
yield self.args
def __getitem__(self, i):
if i == 0:
return self.func
elif i == 1:
return self.args
else:
raise IndexError('can only access elements 0 and 1')
class commanddict(dict):
"""Container for registered wire protocol commands.
It behaves like a dict. But __setitem__ is overwritten to allow silent
coercion of values from 2-tuples for API compatibility.
"""
def __setitem__(self, k, v):
if isinstance(v, commandentry):
pass
# Cast 2-tuples to commandentry instances.
elif isinstance(v, tuple):
if len(v) != 2:
raise ValueError('command tuples must have exactly 2 elements')
# It is common for extensions to wrap wire protocol commands via
# e.g. ``wireproto.commands[x] = (newfn, args)``. Because callers
# doing this aren't aware of the new API that uses objects to store
# command entries, we automatically merge old state with new.
if k in self:
v = self[k]._merge(v[0], v[1])
else:
v = commandentry(v[0], v[1])
else:
raise ValueError('command entries must be commandentry instances '
'or 2-tuples')
return super(commanddict, self).__setitem__(k, v)
commands = commanddict()
def wireprotocommand(name, args=''): def wireprotocommand(name, args=''):
"""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`` is a space-delimited list of named arguments that the command ``args`` is a space-delimited list of named arguments that the command
accepts. ``*`` is a special value that says to accept all arguments. accepts. ``*`` is a special value that says to accept all arguments.
""" """
def register(func): def register(func):
commands[name] = (func, args) commands[name] = commandentry(func, args)
return func return func
return register return register
@wireprotocommand('batch', 'cmds *') @wireprotocommand('batch', 'cmds *')
def batch(repo, proto, cmds, others): def batch(repo, proto, cmds, others):
repo = repo.filtered("served") repo = repo.filtered("served")
res = [] res = []
for pair in cmds.split(';'): for pair in cmds.split(';'):