This is an archive of the discontinued Mercurial Phabricator instance.

Differential D3400

wireproto: rename wireproto to wireprotov1server (API)
ClosedPublic

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

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHGb4d85bc122bd: wireproto: rename wireproto to wireprotov1server (API)
Summary

We have wireprotov2server, wireprotov1peer, and wireprotov2peer.
wireproto only contains server functionality. So it makes sense to
rename it to wireprotov1server so the naming aligns with everything
else.

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:26 PM
This revision is now accepted and ready to land.Apr 18 2018, 2:26 PM
Closed by commit rHGb4d85bc122bd: wireproto: rename wireproto to wireprotov1server (API) (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 8389

hgext/clonebundles.py

instructions when a failure occurs, thus driving more load to the original instructions when a failure occurs, thus driving more load to the original
Mercurial server when the bundle hosting service fails. Mercurial server when the bundle hosting service fails.
""" """
from __future__ import absolute_import from __future__ import absolute_import
from mercurial import ( from mercurial import (
extensions, extensions,
wireproto, wireprotov1server,
) )
testedwith = 'ships-with-hg-core' testedwith = 'ships-with-hg-core'
def capabilities(orig, repo, proto): def capabilities(orig, repo, proto):
caps = orig(repo, proto) caps = orig(repo, proto)
# Only advertise if a manifest exists. This does add some I/O to requests. # Only advertise if a manifest exists. This does add some I/O to requests.
# But this should be cheaper than a wasted network round trip due to # But this should be cheaper than a wasted network round trip due to
# missing file. # missing file.
if repo.vfs.exists('clonebundles.manifest'): if repo.vfs.exists('clonebundles.manifest'):
caps.append('clonebundles') caps.append('clonebundles')
return caps return caps
def extsetup(ui): def extsetup(ui):
extensions.wrapfunction(wireproto, '_capabilities', capabilities) extensions.wrapfunction(wireprotov1server, '_capabilities', capabilities)

hgext/infinitepush/__init__.py

extensions, extensions,
hg, hg,
localrepo, localrepo,
phases, phases,
pushkey, pushkey,
pycompat, pycompat,
registrar, registrar,
util, util,
wireproto,
wireprototypes, wireprototypes,
wireprotov1peer, wireprotov1peer,
wireprotov1server,
) )
from . import ( from . import (
bundleparts, bundleparts,
common, common,
) )
# Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
def extsetup(ui): def extsetup(ui):
commonsetup(ui) commonsetup(ui)
if _isserver(ui): if _isserver(ui):
serverextsetup(ui) serverextsetup(ui)
else: else:
clientextsetup(ui) clientextsetup(ui)
def commonsetup(ui): def commonsetup(ui):
wireproto.commands['listkeyspatterns'] = ( wireprotov1server.commands['listkeyspatterns'] = (
wireprotolistkeyspatterns, 'namespace patterns') wireprotolistkeyspatterns, 'namespace patterns')
scratchbranchpat = ui.config('infinitepush', 'branchpattern') scratchbranchpat = ui.config('infinitepush', 'branchpattern')
if scratchbranchpat: if scratchbranchpat:
global _scratchbranchmatcher global _scratchbranchmatcher
kind, pat, _scratchbranchmatcher = \ kind, pat, _scratchbranchmatcher = \
stringutil.stringmatcher(scratchbranchpat) stringutil.stringmatcher(scratchbranchpat)
def serverextsetup(ui): def serverextsetup(ui):
origpushkeyhandler = bundle2.parthandlermapping['pushkey'] origpushkeyhandler = bundle2.parthandlermapping['pushkey']
def newpushkeyhandler(*args, **kwargs): def newpushkeyhandler(*args, **kwargs):
bundle2pushkey(origpushkeyhandler, *args, **kwargs) bundle2pushkey(origpushkeyhandler, *args, **kwargs)
newpushkeyhandler.params = origpushkeyhandler.params newpushkeyhandler.params = origpushkeyhandler.params
bundle2.parthandlermapping['pushkey'] = newpushkeyhandler bundle2.parthandlermapping['pushkey'] = newpushkeyhandler
orighandlephasehandler = bundle2.parthandlermapping['phase-heads'] orighandlephasehandler = bundle2.parthandlermapping['phase-heads']
newphaseheadshandler = lambda *args, **kwargs: \ newphaseheadshandler = lambda *args, **kwargs: \
bundle2handlephases(orighandlephasehandler, *args, **kwargs) bundle2handlephases(orighandlephasehandler, *args, **kwargs)
newphaseheadshandler.params = orighandlephasehandler.params newphaseheadshandler.params = orighandlephasehandler.params
bundle2.parthandlermapping['phase-heads'] = newphaseheadshandler bundle2.parthandlermapping['phase-heads'] = newphaseheadshandler
extensions.wrapfunction(localrepo.localrepository, 'listkeys', extensions.wrapfunction(localrepo.localrepository, 'listkeys',
localrepolistkeys) localrepolistkeys)
wireproto.commands['lookup'] = ( wireprotov1server.commands['lookup'] = (
_lookupwrap(wireproto.commands['lookup'][0]), 'key') _lookupwrap(wireprotov1server.commands['lookup'][0]), 'key')
extensions.wrapfunction(exchange, 'getbundlechunks', getbundlechunks) extensions.wrapfunction(exchange, 'getbundlechunks', getbundlechunks)
extensions.wrapfunction(bundle2, 'processparts', processparts) extensions.wrapfunction(bundle2, 'processparts', processparts)
def clientextsetup(ui): def clientextsetup(ui):
entry = extensions.wrapcommand(commands.table, 'push', _push) entry = extensions.wrapcommand(commands.table, 'push', _push)
entry[1].append( entry[1].append(

hgext/largefiles/uisetup.py

hg, hg,
httppeer, httppeer,
merge, merge,
scmutil, scmutil,
sshpeer, sshpeer,
subrepo, subrepo,
upgrade, upgrade,
url, url,
wireproto, wireprotov1server,
) )
from . import ( from . import (
overrides, overrides,
proto, proto,
) )
def uisetup(ui): def uisetup(ui):
overrides.postcommitstatus) overrides.postcommitstatus)
extensions.wrapfunction(scmutil, 'marktouched', extensions.wrapfunction(scmutil, 'marktouched',
overrides.scmutilmarktouched) overrides.scmutilmarktouched)
extensions.wrapfunction(url, 'open', extensions.wrapfunction(url, 'open',
overrides.openlargefile) overrides.openlargefile)
# create the new wireproto commands ... # create the new wireproto commands ...
wireproto.wireprotocommand('putlfile', 'sha', permission='push')( wireprotov1server.wireprotocommand('putlfile', 'sha', permission='push')(
proto.putlfile) proto.putlfile)
wireproto.wireprotocommand('getlfile', 'sha', permission='pull')( wireprotov1server.wireprotocommand('getlfile', 'sha', permission='pull')(
proto.getlfile) proto.getlfile)
wireproto.wireprotocommand('statlfile', 'sha', permission='pull')( wireprotov1server.wireprotocommand('statlfile', 'sha', permission='pull')(
proto.statlfile) proto.statlfile)
wireproto.wireprotocommand('lheads', '', permission='pull')( wireprotov1server.wireprotocommand('lheads', '', permission='pull')(
wireproto.heads) wireprotov1server.heads)
# ... and wrap some existing ones # ... and wrap some existing ones
extensions.wrapfunction(wireproto.commands['heads'], 'func', proto.heads) extensions.wrapfunction(wireprotov1server.commands['heads'], 'func',
proto.heads)
# TODO also wrap wireproto.commandsv2 once heads is implemented there. # TODO also wrap wireproto.commandsv2 once heads is implemented there.
extensions.wrapfunction(webcommands, 'decodepath', overrides.decodepath) extensions.wrapfunction(webcommands, 'decodepath', overrides.decodepath)
extensions.wrapfunction(wireproto, '_capabilities', proto._capabilities) extensions.wrapfunction(wireprotov1server, '_capabilities',
proto._capabilities)
# can't do this in reposetup because it needs to have happened before # can't do this in reposetup because it needs to have happened before
# wirerepo.__init__ is called # wirerepo.__init__ is called
proto.ssholdcallstream = sshpeer.sshv1peer._callstream proto.ssholdcallstream = sshpeer.sshv1peer._callstream
proto.httpoldcallstream = httppeer.httppeer._callstream proto.httpoldcallstream = httppeer.httppeer._callstream
sshpeer.sshv1peer._callstream = proto.sshrepocallstream sshpeer.sshv1peer._callstream = proto.sshrepocallstream
httppeer.httppeer._callstream = proto.httprepocallstream httppeer.httppeer._callstream = proto.httprepocallstream

hgext/lfs/__init__.py

pycompat, pycompat,
registrar, registrar,
revlog, revlog,
scmutil, scmutil,
templateutil, templateutil,
upgrade, upgrade,
util, util,
vfs as vfsmod, vfs as vfsmod,
wireproto,
wireprotoserver, wireprotoserver,
wireprotov1server,
) )
from . import ( from . import (
blobstore, blobstore,
wireprotolfsserver, wireprotolfsserver,
wrapper, wrapper,
) )
wrapfunction(upgrade, 'supporteddestrequirements', wrapfunction(upgrade, 'supporteddestrequirements',
wrapper.upgraderequirements) wrapper.upgraderequirements)
wrapfunction(changegroup, wrapfunction(changegroup,
'allsupportedversions', 'allsupportedversions',
wrapper.allsupportedversions) wrapper.allsupportedversions)
wrapfunction(exchange, 'push', wrapper.push) wrapfunction(exchange, 'push', wrapper.push)
wrapfunction(wireproto, '_capabilities', wrapper._capabilities) wrapfunction(wireprotov1server, '_capabilities', wrapper._capabilities)
wrapfunction(wireprotoserver, 'handlewsgirequest', wrapfunction(wireprotoserver, 'handlewsgirequest',
wireprotolfsserver.handlewsgirequest) wireprotolfsserver.handlewsgirequest)
wrapfunction(context.basefilectx, 'cmp', wrapper.filectxcmp) wrapfunction(context.basefilectx, 'cmp', wrapper.filectxcmp)
wrapfunction(context.basefilectx, 'isbinary', wrapper.filectxisbinary) wrapfunction(context.basefilectx, 'isbinary', wrapper.filectxisbinary)
context.basefilectx.islfs = wrapper.filectxislfs context.basefilectx.islfs = wrapper.filectxislfs
revlog.addflagprocessor( revlog.addflagprocessor(

mercurial/sshpeer.py

import re import re
import uuid import uuid
from .i18n import _ from .i18n import _
from . import ( from . import (
error, error,
pycompat, pycompat,
util, util,
wireproto,
wireprotoserver, wireprotoserver,
wireprototypes, wireprototypes,
wireprotov1peer, wireprotov1peer,
wireprotov1server,
) )
from .utils import ( from .utils import (
procutil, procutil,
) )
def _serverquote(s): def _serverquote(s):
"""quote a string for the remote shell ... which we assume is sh""" """quote a string for the remote shell ... which we assume is sh"""
if not s: if not s:
for key, value in sorted(args.items()): for key, value in sorted(args.items()):
if not isinstance(value, dict): if not isinstance(value, dict):
dbg(line % ' %s: %d bytes' % (key, len(value))) dbg(line % ' %s: %d bytes' % (key, len(value)))
else: else:
for dk, dv in sorted(value.items()): for dk, dv in sorted(value.items()):
dbg(line % ' %s-%s: %d' % (key, dk, len(dv))) dbg(line % ' %s-%s: %d' % (key, dk, len(dv)))
self.ui.debug("sending %s command\n" % cmd) self.ui.debug("sending %s command\n" % cmd)
self._pipeo.write("%s\n" % cmd) self._pipeo.write("%s\n" % cmd)
_func, names = wireproto.commands[cmd] _func, names = wireprotov1server.commands[cmd]
keys = names.split() keys = names.split()
wireargs = {} wireargs = {}
for k in keys: for k in keys:
if k == '*': if k == '*':
wireargs['*'] = args wireargs['*'] = args
break break
else: else:
wireargs[k] = args[k] wireargs[k] = args[k]

mercurial/wireproto.py

  • This file was moved to mercurial/wireprotov1server.py.

mercurial/wireprotoserver.py

interface as zi, interface as zi,
) )
from . import ( from . import (
encoding, encoding,
error, error,
hook, hook,
pycompat, pycompat,
util, util,
wireproto,
wireprototypes, wireprototypes,
wireprotov1server,
wireprotov2server, wireprotov2server,
) )
from .utils import ( from .utils import (
procutil, procutil,
) )
stringio = util.stringio stringio = util.stringio
def checkperm(self, perm): def checkperm(self, perm):
return self._checkperm(perm) return self._checkperm(perm)
# This method exists mostly so that extensions like remotefilelog can # This method exists mostly so that extensions like remotefilelog can
# disable a kludgey legacy method only over http. As of early 2018, # disable a kludgey legacy method only over http. As of early 2018,
# there are no other known users, so with any luck we can discard this # there are no other known users, so with any luck we can discard this
# hook if remotefilelog becomes a first-party extension. # hook if remotefilelog becomes a first-party extension.
def iscmd(cmd): def iscmd(cmd):
return cmd in wireproto.commands return cmd in wireprotov1server.commands
def handlewsgirequest(rctx, req, res, checkperm): def handlewsgirequest(rctx, req, res, checkperm):
"""Possibly process a wire protocol request. """Possibly process a wire protocol request.
If the current request is a wire protocol request, the request is If the current request is a wire protocol request, the request is
processed by this function. processed by this function.
``req`` is a ``parsedrequest`` instance. ``req`` is a ``parsedrequest`` instance.
# on the request parameters. # on the request parameters.
if '0.2' in proto.getprotocaps(): if '0.2' in proto.getprotocaps():
# All clients are expected to support uncompressed data. # All clients are expected to support uncompressed data.
if prefer_uncompressed: if prefer_uncompressed:
return HGTYPE2, util._noopengine(), {} return HGTYPE2, util._noopengine(), {}
# Now find an agreed upon compression format. # Now find an agreed upon compression format.
compformats = wireproto.clientcompressionsupport(proto) compformats = wireprotov1server.clientcompressionsupport(proto)
for engine in wireprototypes.supportedcompengines(ui, util.SERVERROLE): for engine in wireprototypes.supportedcompengines(ui, util.SERVERROLE):
if engine.wireprotosupport().name in compformats: if engine.wireprotosupport().name in compformats:
opts = {} opts = {}
level = ui.configint('server', '%slevel' % engine.name()) level = ui.configint('server', '%slevel' % engine.name())
if level is not None: if level is not None:
opts['level'] = level opts['level'] = level
return HGTYPE2, engine, opts return HGTYPE2, engine, opts
handler = API_HANDLERS[api] handler = API_HANDLERS[api]
descriptorfn = handler.get('apidescriptor') descriptorfn = handler.get('apidescriptor')
if not descriptorfn: if not descriptorfn:
continue continue
descriptors[api] = descriptorfn(req, repo) descriptors[api] = descriptorfn(req, repo)
v1caps = wireproto.dispatch(repo, proto, 'capabilities') v1caps = wireprotov1server.dispatch(repo, proto, 'capabilities')
assert isinstance(v1caps, wireprototypes.bytesresponse) assert isinstance(v1caps, wireprototypes.bytesresponse)
m = { m = {
# TODO allow this to be configurable. # TODO allow this to be configurable.
'apibase': 'api/', 'apibase': 'api/',
'apis': descriptors, 'apis': descriptors,
'v1capabilities': v1caps.data, 'v1capabilities': v1caps.data,
} }
res.headers['Content-Type'] = contenttype res.headers['Content-Type'] = contenttype
if bodybytes is not None: if bodybytes is not None:
res.setbodybytes(bodybytes) res.setbodybytes(bodybytes)
if bodygen is not None: if bodygen is not None:
res.setbodygen(bodygen) res.setbodygen(bodygen)
if not wireproto.commands.commandavailable(cmd, proto): if not wireprotov1server.commands.commandavailable(cmd, proto):
setresponse(HTTP_OK, HGERRTYPE, setresponse(HTTP_OK, HGERRTYPE,
_('requested wire protocol command is not available over ' _('requested wire protocol command is not available over '
'HTTP')) 'HTTP'))
return return
proto.checkperm(wireproto.commands[cmd].permission) proto.checkperm(wireprotov1server.commands[cmd].permission)
# Possibly handle a modern client wanting to switch protocols. # Possibly handle a modern client wanting to switch protocols.
if (cmd == 'capabilities' and if (cmd == 'capabilities' and
processcapabilitieshandshake(repo, req, res, proto)): processcapabilitieshandshake(repo, req, res, proto)):
return return
rsp = wireproto.dispatch(repo, proto, cmd) rsp = wireprotov1server.dispatch(repo, proto, cmd)
if isinstance(rsp, bytes): if isinstance(rsp, bytes):
setresponse(HTTP_OK, HGTYPE, bodybytes=rsp) setresponse(HTTP_OK, HGTYPE, bodybytes=rsp)
elif isinstance(rsp, wireprototypes.bytesresponse): elif isinstance(rsp, wireprototypes.bytesresponse):
setresponse(HTTP_OK, HGTYPE, bodybytes=rsp.data) setresponse(HTTP_OK, HGTYPE, bodybytes=rsp.data)
elif isinstance(rsp, wireprototypes.streamreslegacy): elif isinstance(rsp, wireprototypes.streamreslegacy):
setresponse(HTTP_OK, HGTYPE, bodygen=rsp.gen) setresponse(HTTP_OK, HGTYPE, bodygen=rsp.gen)
elif isinstance(rsp, wireprototypes.streamres): elif isinstance(rsp, wireprototypes.streamres):
b'cannot upgrade protocols multiple ' b'cannot upgrade protocols multiple '
b'times') b'times')
state = 'shutdown' state = 'shutdown'
continue continue
state = 'upgrade-initial' state = 'upgrade-initial'
continue continue
available = wireproto.commands.commandavailable(request, proto) available = wireprotov1server.commands.commandavailable(
request, proto)
# This command isn't available. Send an empty response and go # This command isn't available. Send an empty response and go
# back to waiting for a new command. # back to waiting for a new command.
if not available: if not available:
_sshv1respondbytes(fout, b'') _sshv1respondbytes(fout, b'')
continue continue
rsp = wireproto.dispatch(repo, proto, request) rsp = wireprotov1server.dispatch(repo, proto, request)
if isinstance(rsp, bytes): if isinstance(rsp, bytes):
_sshv1respondbytes(fout, rsp) _sshv1respondbytes(fout, rsp)
elif isinstance(rsp, wireprototypes.bytesresponse): elif isinstance(rsp, wireprototypes.bytesresponse):
_sshv1respondbytes(fout, rsp.data) _sshv1respondbytes(fout, rsp.data)
elif isinstance(rsp, wireprototypes.streamres): elif isinstance(rsp, wireprototypes.streamres):
_sshv1respondstream(fout, rsp) _sshv1respondstream(fout, rsp)
elif isinstance(rsp, wireprototypes.streamreslegacy): elif isinstance(rsp, wireprototypes.streamreslegacy):
continue continue
state = 'upgrade-v2-finish' state = 'upgrade-v2-finish'
continue continue
elif state == 'upgrade-v2-finish': elif state == 'upgrade-v2-finish':
# Send the upgrade response. # Send the upgrade response.
fout.write(b'upgraded %s %s\n' % (token, SSHV2)) fout.write(b'upgraded %s %s\n' % (token, SSHV2))
servercaps = wireproto.capabilities(repo, proto) servercaps = wireprotov1server.capabilities(repo, proto)
rsp = b'capabilities: %s' % servercaps.data rsp = b'capabilities: %s' % servercaps.data
fout.write(b'%d\n%s\n' % (len(rsp), rsp)) fout.write(b'%d\n%s\n' % (len(rsp), rsp))
fout.flush() fout.flush()
proto = sshv2protocolhandler(ui, fin, fout) proto = sshv2protocolhandler(ui, fin, fout)
protoswitched = True protoswitched = True
state = 'protov2-serving' state = 'protov2-serving'

mercurial/wireprotov1server.py

  • This file was moved from mercurial/wireproto.py.
# wireproto.py - generic wire protocol support functions # wireprotov1server.py - Wire protocol version 1 server functionality
# #
# Copyright 2005-2010 Matt Mackall <mpm@selenic.com> # Copyright 2005-2010 Matt Mackall <mpm@selenic.com>
# #
# 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

tests/sshprotoext.py

from __future__ import absolute_import from __future__ import absolute_import
from mercurial import ( from mercurial import (
error, error,
extensions, extensions,
registrar, registrar,
sshpeer, sshpeer,
wireproto,
wireprotoserver, wireprotoserver,
wireprotov1server,
) )
configtable = {} configtable = {}
configitem = registrar.configitem(configtable) configitem = registrar.configitem(configtable)
configitem(b'sshpeer', b'mode', default=None) configitem(b'sshpeer', b'mode', default=None)
configitem(b'sshpeer', b'handshake-mode', default=None) configitem(b'sshpeer', b'handshake-mode', default=None)
l = self._fin.readline() l = self._fin.readline()
assert l == b'hello\n' assert l == b'hello\n'
# Respond to unknown commands with an empty reply. # Respond to unknown commands with an empty reply.
wireprotoserver._sshv1respondbytes(self._fout, b'') wireprotoserver._sshv1respondbytes(self._fout, b'')
l = self._fin.readline() l = self._fin.readline()
assert l == b'between\n' assert l == b'between\n'
proto = wireprotoserver.sshv1protocolhandler(self._ui, self._fin, proto = wireprotoserver.sshv1protocolhandler(self._ui, self._fin,
self._fout) self._fout)
rsp = wireproto.dispatch(self._repo, proto, b'between') rsp = wireprotov1server.dispatch(self._repo, proto, b'between')
wireprotoserver._sshv1respondbytes(self._fout, rsp.data) wireprotoserver._sshv1respondbytes(self._fout, rsp.data)
super(prehelloserver, self).serve_forever() super(prehelloserver, self).serve_forever()
def performhandshake(orig, ui, stdin, stdout, stderr): def performhandshake(orig, ui, stdin, stdout, stderr):
"""Wrapped version of sshpeer._performhandshake to send extra commands.""" """Wrapped version of sshpeer._performhandshake to send extra commands."""
mode = ui.config(b'sshpeer', b'handshake-mode') mode = ui.config(b'sshpeer', b'handshake-mode')
if mode == b'pre-no-args': if mode == b'pre-no-args':

tests/test-http-permissions.t

#require killdaemons #require killdaemons
$ cat > fakeremoteuser.py << EOF $ cat > fakeremoteuser.py << EOF
> import os > import os
> from mercurial.hgweb import hgweb_mod > from mercurial.hgweb import hgweb_mod
> from mercurial import wireproto > from mercurial import wireprotov1server
> class testenvhgweb(hgweb_mod.hgweb): > class testenvhgweb(hgweb_mod.hgweb):
> def __call__(self, env, respond): > def __call__(self, env, respond):
> # Allow REMOTE_USER to define authenticated user. > # Allow REMOTE_USER to define authenticated user.
> if r'REMOTE_USER' in os.environ: > if r'REMOTE_USER' in os.environ:
> env[r'REMOTE_USER'] = os.environ[r'REMOTE_USER'] > env[r'REMOTE_USER'] = os.environ[r'REMOTE_USER']
> # Allow REQUEST_METHOD to override HTTP method > # Allow REQUEST_METHOD to override HTTP method
> if r'REQUEST_METHOD' in os.environ: > if r'REQUEST_METHOD' in os.environ:
> env[r'REQUEST_METHOD'] = os.environ[r'REQUEST_METHOD'] > env[r'REQUEST_METHOD'] = os.environ[r'REQUEST_METHOD']
> return super(testenvhgweb, self).__call__(env, respond) > return super(testenvhgweb, self).__call__(env, respond)
> hgweb_mod.hgweb = testenvhgweb > hgweb_mod.hgweb = testenvhgweb
> >
> @wireproto.wireprotocommand('customreadnoperm') > @wireprotov1server.wireprotocommand('customreadnoperm')
> def customread(repo, proto): > def customread(repo, proto):
> return b'read-only command no defined permissions\n' > return b'read-only command no defined permissions\n'
> @wireproto.wireprotocommand('customwritenoperm') > @wireprotov1server.wireprotocommand('customwritenoperm')
> def customwritenoperm(repo, proto): > def customwritenoperm(repo, proto):
> return b'write command no defined permissions\n' > return b'write command no defined permissions\n'
> @wireproto.wireprotocommand('customreadwithperm', permission='pull') > @wireprotov1server.wireprotocommand('customreadwithperm', permission='pull')
> def customreadwithperm(repo, proto): > def customreadwithperm(repo, proto):
> return b'read-only command w/ defined permissions\n' > return b'read-only command w/ defined permissions\n'
> @wireproto.wireprotocommand('customwritewithperm', permission='push') > @wireprotov1server.wireprotocommand('customwritewithperm', permission='push')
> def customwritewithperm(repo, proto): > def customwritewithperm(repo, proto):
> return b'write command w/ defined permissions\n' > return b'write command w/ defined permissions\n'
> EOF > EOF
$ cat >> $HGRCPATH << EOF $ cat >> $HGRCPATH << EOF
> [extensions] > [extensions]
> fakeremoteuser = $TESTTMP/fakeremoteuser.py > fakeremoteuser = $TESTTMP/fakeremoteuser.py
> strip = > strip =

tests/test-sshserver.py

from __future__ import absolute_import, print_function from __future__ import absolute_import, print_function
import io import io
import unittest import unittest
import silenttestrunner import silenttestrunner
from mercurial import ( from mercurial import (
wireproto,
wireprotoserver, wireprotoserver,
wireprotov1server,
) )
from mercurial.utils import ( from mercurial.utils import (
procutil, procutil,
) )
class SSHServerGetArgsTests(unittest.TestCase): class SSHServerGetArgsTests(unittest.TestCase):
def testparseknown(self): def testparseknown(self):
tests = [ tests = [
(b'* 0\nnodes 0\n', [b'', {}]), (b'* 0\nnodes 0\n', [b'', {}]),
(b'* 0\nnodes 40\n1111111111111111111111111111111111111111\n', (b'* 0\nnodes 40\n1111111111111111111111111111111111111111\n',
[b'1111111111111111111111111111111111111111', {}]), [b'1111111111111111111111111111111111111111', {}]),
] ]
for input, expected in tests: for input, expected in tests:
self.assertparse(b'known', input, expected) self.assertparse(b'known', input, expected)
def assertparse(self, cmd, input, expected): def assertparse(self, cmd, input, expected):
server = mockserver(input) server = mockserver(input)
proto = wireprotoserver.sshv1protocolhandler(server._ui, proto = wireprotoserver.sshv1protocolhandler(server._ui,
server._fin, server._fin,
server._fout) server._fout)
_func, spec = wireproto.commands[cmd] _func, spec = wireprotov1server.commands[cmd]
self.assertEqual(proto.getargs(spec), expected) self.assertEqual(proto.getargs(spec), expected)
def mockserver(inbytes): def mockserver(inbytes):
ui = mockui(inbytes) ui = mockui(inbytes)
repo = mockrepo(ui) repo = mockrepo(ui)
return wireprotoserver.sshserver(ui, repo) return wireprotoserver.sshserver(ui, repo)
class mockrepo(object): class mockrepo(object):

tests/test-wireproto.py

from __future__ import absolute_import, print_function from __future__ import absolute_import, print_function
from mercurial import ( from mercurial import (
error, error,
pycompat, pycompat,
ui as uimod, ui as uimod,
util, util,
wireproto,
wireprototypes, wireprototypes,
wireprotov1peer, wireprotov1peer,
wireprotov1server,
) )
stringio = util.stringio stringio = util.stringio
class proto(object): class proto(object):
def __init__(self, args): def __init__(self, args):
self.args = args self.args = args
self.name = 'dummyproto' self.name = 'dummyproto'
def close(self): def close(self):
pass pass
def capabilities(self): def capabilities(self):
return [b'batch'] return [b'batch']
def _call(self, cmd, **args): def _call(self, cmd, **args):
args = pycompat.byteskwargs(args) args = pycompat.byteskwargs(args)
res = wireproto.dispatch(self.serverrepo, proto(args), cmd) res = wireprotov1server.dispatch(self.serverrepo, proto(args), cmd)
if isinstance(res, wireprototypes.bytesresponse): if isinstance(res, wireprototypes.bytesresponse):
return res.data return res.data
elif isinstance(res, bytes): elif isinstance(res, bytes):
return res return res
else: else:
raise error.Abort('dummy client does not support response type') raise error.Abort('dummy client does not support response type')
def _callstream(self, cmd, **args): def _callstream(self, cmd, **args):
def mangle(s): def mangle(s):
return b''.join(pycompat.bytechr(ord(c) + 1) for c in pycompat.bytestr(s)) return b''.join(pycompat.bytechr(ord(c) + 1) for c in pycompat.bytestr(s))
def unmangle(s): def unmangle(s):
return b''.join(pycompat.bytechr(ord(c) - 1) for c in pycompat.bytestr(s)) return b''.join(pycompat.bytechr(ord(c) - 1) for c in pycompat.bytestr(s))
def greet(repo, proto, name): def greet(repo, proto, name):
return mangle(repo.greet(unmangle(name))) return mangle(repo.greet(unmangle(name)))
wireproto.commands[b'greet'] = (greet, b'name',) wireprotov1server.commands[b'greet'] = (greet, b'name')
srv = serverrepo() srv = serverrepo()
clt = clientpeer(srv, uimod.ui()) clt = clientpeer(srv, uimod.ui())
print(clt.greet(b"Foobar")) print(clt.greet(b"Foobar"))
with clt.commandexecutor() as e: with clt.commandexecutor() as e:
fgreet1 = e.callcommand(b'greet', {b'name': b'Fo, =;:<o'}) fgreet1 = e.callcommand(b'greet', {b'name': b'Fo, =;:<o'})
fgreet2 = e.callcommand(b'greet', {b'name': b'Bar'}) fgreet2 = e.callcommand(b'greet', {b'name': b'Bar'})
print([f.result() for f in (fgreet1, fgreet2)]) print([f.result() for f in (fgreet1, fgreet2)])

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,
wireprotov1server,
wireprotov2server, wireprotov2server,
wireproto,
) )
@wireproto.wireprotocommand('customreadonly', permission='pull') @wireprotov1server.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')
@wireprotov2server.wireprotocommand('customreadonly', permission='pull') @wireprotov2server.wireprotocommand('customreadonly', permission='pull')
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') @wireprotov1server.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')
@wireprotov2server.wireprotocommand('customreadwrite', permission='push') @wireprotov2server.wireprotocommand('customreadwrite', permission='push')
def customreadwritev2(repo, proto): def customreadwritev2(repo, proto):
return wireprototypes.cborresponse(b'customreadwrite bytes response') return wireprototypes.cborresponse(b'customreadwrite bytes response')
EOF EOF