This is an archive of the discontinued Mercurial Phabricator instance.

Differential D1999

wireproto: function for testing if wire protocol command is available
ClosedPublic

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

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHG5a56bf4180ad: wireproto: function for testing if wire protocol command is available
Summary

Currently, we perform simple membership testing for whether a wire
command is available. In the future, not all wire protocol commands
will be available on all transports. For example, a legacy transport
may not support newer commands.

In preparation of this, teach the protocol handlers to call into a
function to determine if a wire protocol command is available. That
function currently does membership testing like before, so behavior
should be identical.

In the case of the HTTP server, behavior is a bit wonkier. "cmd" is
used by both the wire protocol and hgweb. We do want the protocol
handler to handle requests for all commands that look like wire
protocol commands, even if they aren't available. Otherwise, the
fallback to hgweb would only confuse automated clients and make it
easier for hgweb to accidentally implement a "cmd" that is identical
to wire protocol commands (since they aren't centrally registered).

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
indygreg updated this revision to Diff 5258.Feb 6 2018, 4:04 PM
durin42 accepted this revision.Feb 7 2018, 5:18 PM
This revision is now accepted and ready to land.Feb 7 2018, 5:18 PM
Closed by commit rHG5a56bf4180ad: wireproto: function for testing if wire protocol command is available (authored by indygreg). · Explain WhyFeb 7 2018, 5:41 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 5307

mercurial/hgweb/hgweb_mod.py

repo_parts = req.env.get(r'REPO_NAME', r'').split(r'/') repo_parts = req.env.get(r'REPO_NAME', r'').split(r'/')
if parts[:len(repo_parts)] == repo_parts: if parts[:len(repo_parts)] == repo_parts:
parts = parts[len(repo_parts):] parts = parts[len(repo_parts):]
query = '/'.join(parts) query = '/'.join(parts)
else: else:
query = req.env[r'QUERY_STRING'].partition(r'&')[0] query = req.env[r'QUERY_STRING'].partition(r'&')[0]
query = query.partition(r';')[0] query = query.partition(r';')[0]
# The ``cmd`` request parameter is used by both the wire protocol
# and hgweb. We route all known wire protocol commands to the
# wire protocol handler, even if the command isn't available for
# this transport. That's better for machine clients in the case
# of an errant request to an unavailable protocol command. And it
# prevents hgweb from accidentally using ``cmd`` values used by
# the wire protocol.
# process this if it's a protocol request # process this if it's a protocol request
# protocol bits don't need to create any URLs # protocol bits don't need to create any URLs
# and the clients always use the old URL structure # and the clients always use the old URL structure
cmd = pycompat.sysbytes(req.form.get(r'cmd', [r''])[0]) cmd = pycompat.sysbytes(req.form.get(r'cmd', [r''])[0])
if wireprotoserver.iscmd(cmd): if wireprotoserver.iscmd(cmd):
try: try:
if query: if query:

mercurial/wireproto.py

else: else:
v = commandentry(v[0], v[1]) v = commandentry(v[0], v[1])
else: else:
raise ValueError('command entries must be commandentry instances ' raise ValueError('command entries must be commandentry instances '
'or 2-tuples') 'or 2-tuples')
return super(commanddict, self).__setitem__(k, v) return super(commanddict, self).__setitem__(k, v)
def commandavailable(self, command, proto):
"""Determine if a command is available for the requested protocol."""
# For now, commands are available for all protocols. So do a simple
# membership test.
return command in self
commands = commanddict() 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

mercurial/wireprotoserver.py

assert 0 < len(name) < 256 assert 0 < len(name) < 256
yield struct.pack('B', len(name)) yield struct.pack('B', len(name))
yield name yield name
for chunk in gen: for chunk in gen:
yield chunk yield chunk
rsp = wireproto.dispatch(repo, proto, cmd) rsp = wireproto.dispatch(repo, proto, cmd)
if not wireproto.commands.commandavailable(cmd, proto):
req.respond(HTTP_OK, HGERRTYPE,
body=_('requested wire protocol command is not available '
'over HTTP'))
return []
if isinstance(rsp, bytes): if isinstance(rsp, bytes):
req.respond(HTTP_OK, HGTYPE, body=rsp) req.respond(HTTP_OK, HGTYPE, body=rsp)
return [] return []
elif isinstance(rsp, wireproto.streamres_legacy): elif isinstance(rsp, wireproto.streamres_legacy):
gen = rsp.gen gen = rsp.gen
req.respond(HTTP_OK, HGTYPE) req.respond(HTTP_OK, HGTYPE)
return gen return gen
elif isinstance(rsp, wireproto.streamres): elif isinstance(rsp, wireproto.streamres):
wireproto.streamres_legacy: _sendstream, wireproto.streamres_legacy: _sendstream,
wireproto.pushres: _sendpushresponse, wireproto.pushres: _sendpushresponse,
wireproto.pusherr: _sendpusherror, wireproto.pusherr: _sendpusherror,
wireproto.ooberror: _sendooberror, wireproto.ooberror: _sendooberror,
} }
def serve_one(self): def serve_one(self):
cmd = self._fin.readline()[:-1] cmd = self._fin.readline()[:-1]
if cmd and cmd in wireproto.commands: if cmd and wireproto.commands.commandavailable(cmd, self):
rsp = wireproto.dispatch(self._repo, self, cmd) rsp = wireproto.dispatch(self._repo, self, cmd)
self._handlers[rsp.__class__](self, rsp) self._handlers[rsp.__class__](self, rsp)
elif cmd: elif cmd:
self._sendresponse("") self._sendresponse("")
return cmd != '' return cmd != ''
def _client(self): def _client(self):
client = encoding.environ.get('SSH_CLIENT', '').split(' ', 1)[0] client = encoding.environ.get('SSH_CLIENT', '').split(' ', 1)[0]
return 'remote:ssh:' + client return 'remote:ssh:' + client