( )⚙ D3257 wireproto: move value encoding functions to wireprototypes (API)

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D3257

wireproto: move value encoding functions to wireprototypes (API)
ClosedPublic

Authored by indygreg on Apr 11 2018, 7:42 PM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHG5e71dea79aae: wireproto: move value encoding functions to wireprototypes (API)
Summary

These functions should live in the same place. I plan to separate
client from server code in upcoming commits. wireprototypes is
where we are putting shared code like this.

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 11 2018, 7:42 PM
durin42 accepted this revision.Apr 12 2018, 6:21 PM
This revision is now accepted and ready to land.Apr 12 2018, 6:21 PM
Closed by commit rHG5e71dea79aae: wireproto: move value encoding functions to wireprototypes (API) (authored by indygreg). · Explain WhyApr 12 2018, 6:23 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 8098

hgext/infinitepush/__init__.py

localrepo, localrepo,
peer, peer,
phases, phases,
pushkey, pushkey,
pycompat, pycompat,
registrar, registrar,
util, util,
wireproto, wireproto,
wireprototypes,
) )
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
index, partorder.pop(partorder.index(scratchbranchparttype))) index, partorder.pop(partorder.index(scratchbranchparttype)))
def _checkheads(orig, pushop): def _checkheads(orig, pushop):
if pushop.ui.configbool(experimental, configscratchpush, False): if pushop.ui.configbool(experimental, configscratchpush, False):
return return
return orig(pushop) return orig(pushop)
def wireprotolistkeyspatterns(repo, proto, namespace, patterns): def wireprotolistkeyspatterns(repo, proto, namespace, patterns):
patterns = wireproto.decodelist(patterns) patterns = wireprototypes.decodelist(patterns)
d = repo.listkeys(encoding.tolocal(namespace), patterns).iteritems() d = repo.listkeys(encoding.tolocal(namespace), patterns).iteritems()
return pushkey.encodekeys(d) return pushkey.encodekeys(d)
def localrepolistkeys(orig, self, namespace, patterns=None): def localrepolistkeys(orig, self, namespace, patterns=None):
if namespace == 'bookmarks' and patterns: if namespace == 'bookmarks' and patterns:
index = self.bundlestore.index index = self.bundlestore.index
results = {} results = {}
bookmarks = orig(self, namespace) bookmarks = orig(self, namespace)
def listkeyspatterns(self, namespace, patterns): def listkeyspatterns(self, namespace, patterns):
if not self.capable('pushkey'): if not self.capable('pushkey'):
yield {}, None yield {}, None
f = peer.future() f = peer.future()
self.ui.debug('preparing listkeys for "%s" with pattern "%s"\n' % self.ui.debug('preparing listkeys for "%s" with pattern "%s"\n' %
(namespace, patterns)) (namespace, patterns))
yield { yield {
'namespace': encoding.fromlocal(namespace), 'namespace': encoding.fromlocal(namespace),
'patterns': wireproto.encodelist(patterns) 'patterns': wireprototypes.encodelist(patterns)
}, f }, f
d = f.value d = f.value
self.ui.debug('received listkey for "%s": %i bytes\n' self.ui.debug('received listkey for "%s": %i bytes\n'
% (namespace, len(d))) % (namespace, len(d)))
yield pushkey.decodekeys(d) yield pushkey.decodekeys(d)
def _readbundlerevs(bundlerepo): def _readbundlerevs(bundlerepo):
return list(bundlerepo.revs('bundle()')) return list(bundlerepo.revs('bundle()'))

mercurial/wireproto.py

yield finalfuture.value yield finalfuture.value
# Forward a couple of names from peer to make wireproto interactions # Forward a couple of names from peer to make wireproto interactions
# slightly more sensible. # slightly more sensible.
batchable = peer.batchable batchable = peer.batchable
future = peer.future future = peer.future
# list of nodes encoding / decoding
def decodelist(l, sep=' '):
if l:
return [bin(v) for v in l.split(sep)]
return []
def encodelist(l, sep=' '):
try:
return sep.join(map(hex, l))
except TypeError:
raise
# batched call argument encoding
def escapearg(plain):
return (plain
.replace(':', ':c')
.replace(',', ':o')
.replace(';', ':s')
.replace('=', ':e'))
def unescapearg(escaped):
return (escaped
.replace(':e', '=')
.replace(':s', ';')
.replace(':o', ',')
.replace(':c', ':'))
def encodebatchcmds(req): def encodebatchcmds(req):
"""Return a ``cmds`` argument value for the ``batch`` command.""" """Return a ``cmds`` argument value for the ``batch`` command."""
escapearg = wireprototypes.escapebatcharg
cmds = [] cmds = []
for op, argsdict in req: for op, argsdict in req:
# Old servers didn't properly unescape argument names. So prevent # Old servers didn't properly unescape argument names. So prevent
# the sending of argument names that may not be decoded properly by # the sending of argument names that may not be decoded properly by
# servers. # servers.
assert all(escapearg(k) == k for k in argsdict) assert all(escapearg(k) == k for k in argsdict)
args = ','.join('%s=%s' % (escapearg(k), escapearg(v)) args = ','.join('%s=%s' % (escapearg(k), escapearg(v))
self._abort(error.RepoError(data)) self._abort(error.RepoError(data))
@batchable @batchable
def heads(self): def heads(self):
f = future() f = future()
yield {}, f yield {}, f
d = f.value d = f.value
try: try:
yield decodelist(d[:-1]) yield wireprototypes.decodelist(d[:-1])
except ValueError: except ValueError:
self._abort(error.ResponseError(_("unexpected response:"), d)) self._abort(error.ResponseError(_("unexpected response:"), d))
@batchable @batchable
def known(self, nodes): def known(self, nodes):
f = future() f = future()
yield {'nodes': encodelist(nodes)}, f yield {'nodes': wireprototypes.encodelist(nodes)}, f
d = f.value d = f.value
try: try:
yield [bool(int(b)) for b in d] yield [bool(int(b)) for b in d]
except ValueError: except ValueError:
self._abort(error.ResponseError(_("unexpected response:"), d)) self._abort(error.ResponseError(_("unexpected response:"), d))
@batchable @batchable
def branchmap(self): def branchmap(self):
f = future() f = future()
yield {}, f yield {}, f
d = f.value d = f.value
try: try:
branchmap = {} branchmap = {}
for branchpart in d.splitlines(): for branchpart in d.splitlines():
branchname, branchheads = branchpart.split(' ', 1) branchname, branchheads = branchpart.split(' ', 1)
branchname = encoding.tolocal(urlreq.unquote(branchname)) branchname = encoding.tolocal(urlreq.unquote(branchname))
branchheads = decodelist(branchheads) branchheads = wireprototypes.decodelist(branchheads)
branchmap[branchname] = branchheads branchmap[branchname] = branchheads
yield branchmap yield branchmap
except TypeError: except TypeError:
self._abort(error.ResponseError(_("unexpected response:"), d)) self._abort(error.ResponseError(_("unexpected response:"), d))
@batchable @batchable
def listkeys(self, namespace): def listkeys(self, namespace):
if not self.capable('pushkey'): if not self.capable('pushkey'):
for key, value in kwargs.iteritems(): for key, value in kwargs.iteritems():
if value is None: if value is None:
continue continue
keytype = gboptsmap.get(key) keytype = gboptsmap.get(key)
if keytype is None: if keytype is None:
raise error.ProgrammingError( raise error.ProgrammingError(
'Unexpectedly None keytype for key %s' % key) 'Unexpectedly None keytype for key %s' % key)
elif keytype == 'nodes': elif keytype == 'nodes':
value = encodelist(value) value = wireprototypes.encodelist(value)
elif keytype == 'csv': elif keytype == 'csv':
value = ','.join(value) value = ','.join(value)
elif keytype == 'scsv': elif keytype == 'scsv':
value = ','.join(sorted(value)) value = ','.join(sorted(value))
elif keytype == 'boolean': elif keytype == 'boolean':
value = '%i' % bool(value) value = '%i' % bool(value)
elif keytype != 'plain': elif keytype != 'plain':
raise KeyError('unknown getbundle option type %s' raise KeyError('unknown getbundle option type %s'
When pushing a bundle20 stream, return a bundle20 stream. When pushing a bundle20 stream, return a bundle20 stream.
`url` is the url the client thinks it's pushing to, which is `url` is the url the client thinks it's pushing to, which is
visible to hooks. visible to hooks.
''' '''
if heads != ['force'] and self.capable('unbundlehash'): if heads != ['force'] and self.capable('unbundlehash'):
heads = encodelist(['hashed', heads = wireprototypes.encodelist(
hashlib.sha1(''.join(sorted(heads))).digest()]) ['hashed', hashlib.sha1(''.join(sorted(heads))).digest()])
else: else:
heads = encodelist(heads) heads = wireprototypes.encodelist(heads)
if util.safehasattr(cg, 'deltaheader'): if util.safehasattr(cg, 'deltaheader'):
# this a bundle10, do the old style call sequence # this a bundle10, do the old style call sequence
ret, output = self._callpush("unbundle", cg, heads=heads) ret, output = self._callpush("unbundle", cg, heads=heads)
if ret == "": if ret == "":
raise error.ResponseError( raise error.ResponseError(
_('push failed:'), output) _('push failed:'), output)
try: try:
ret = bundle2.getunbundler(self.ui, stream) ret = bundle2.getunbundler(self.ui, stream)
return ret return ret
# End of ipeercommands interface. # End of ipeercommands interface.
# Begin of ipeerlegacycommands interface. # Begin of ipeerlegacycommands interface.
def branches(self, nodes): def branches(self, nodes):
n = encodelist(nodes) n = wireprototypes.encodelist(nodes)
d = self._call("branches", nodes=n) d = self._call("branches", nodes=n)
try: try:
br = [tuple(decodelist(b)) for b in d.splitlines()] br = [tuple(wireprototypes.decodelist(b)) for b in d.splitlines()]
return br return br
except ValueError: except ValueError:
self._abort(error.ResponseError(_("unexpected response:"), d)) self._abort(error.ResponseError(_("unexpected response:"), d))
def between(self, pairs): def between(self, pairs):
batch = 8 # avoid giant requests batch = 8 # avoid giant requests
r = [] r = []
for i in xrange(0, len(pairs), batch): for i in xrange(0, len(pairs), batch):
n = " ".join([encodelist(p, '-') for p in pairs[i:i + batch]]) n = " ".join([wireprototypes.encodelist(p, '-')
for p in pairs[i:i + batch]])
d = self._call("between", pairs=n) d = self._call("between", pairs=n)
try: try:
r.extend(l and decodelist(l) or [] for l in d.splitlines()) r.extend(l and wireprototypes.decodelist(l) or []
for l in d.splitlines())
except ValueError: except ValueError:
self._abort(error.ResponseError(_("unexpected response:"), d)) self._abort(error.ResponseError(_("unexpected response:"), d))
return r return r
def changegroup(self, nodes, kind): def changegroup(self, nodes, kind):
n = encodelist(nodes) n = wireprototypes.encodelist(nodes)
f = self._callcompressable("changegroup", roots=n) f = self._callcompressable("changegroup", roots=n)
return changegroupmod.cg1unpacker(f, 'UN') return changegroupmod.cg1unpacker(f, 'UN')
def changegroupsubset(self, bases, heads, kind): def changegroupsubset(self, bases, heads, kind):
self.requirecap('changegroupsubset', _('look up remote changes')) self.requirecap('changegroupsubset', _('look up remote changes'))
bases = encodelist(bases) bases = wireprototypes.encodelist(bases)
heads = encodelist(heads) heads = wireprototypes.encodelist(heads)
f = self._callcompressable("changegroupsubset", f = self._callcompressable("changegroupsubset",
bases=bases, heads=heads) bases=bases, heads=heads)
return changegroupmod.cg1unpacker(f, 'UN') return changegroupmod.cg1unpacker(f, 'UN')
# End of ipeerlegacycommands interface. # End of ipeerlegacycommands interface.
def _submitbatch(self, req): def _submitbatch(self, req):
"""run batch request <req> on the server """run batch request <req> on the server
Returns an iterator of the raw responses from the server. Returns an iterator of the raw responses from the server.
""" """
ui = self.ui ui = self.ui
if ui.debugflag and ui.configbool('devel', 'debug.peer-request'): if ui.debugflag and ui.configbool('devel', 'debug.peer-request'):
ui.debug('devel-peer-request: batched-content\n') ui.debug('devel-peer-request: batched-content\n')
for op, args in req: for op, args in req:
msg = 'devel-peer-request: - %s (%d arguments)\n' msg = 'devel-peer-request: - %s (%d arguments)\n'
ui.debug(msg % (op, len(args))) ui.debug(msg % (op, len(args)))
unescapearg = wireprototypes.unescapebatcharg
rsp = self._callstream("batch", cmds=encodebatchcmds(req)) rsp = self._callstream("batch", cmds=encodebatchcmds(req))
chunk = rsp.read(1024) chunk = rsp.read(1024)
work = [chunk] work = [chunk]
while chunk: while chunk:
while ';' not in chunk and chunk: while ';' not in chunk and chunk:
chunk = rsp.read(1024) chunk = rsp.read(1024)
work.append(chunk) work.append(chunk)
merged = ''.join(work) merged = ''.join(work)
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',
transportpolicy=POLICY_V1_ONLY) transportpolicy=POLICY_V1_ONLY)
def batch(repo, proto, cmds, others): def batch(repo, proto, cmds, others):
unescapearg = wireprototypes.unescapebatcharg
repo = repo.filtered("served") repo = repo.filtered("served")
res = [] res = []
for pair in cmds.split(';'): for pair in cmds.split(';'):
op, args = pair.split(' ', 1) op, args = pair.split(' ', 1)
vals = {} vals = {}
for a in args.split(','): for a in args.split(','):
if a: if a:
n, v = a.split('=') n, v = a.split('=')
if isinstance(result, wireprototypes.ooberror): if isinstance(result, wireprototypes.ooberror):
return result return result
# For now, all batchable commands must return bytesresponse or # For now, all batchable commands must return bytesresponse or
# raw bytes (for backwards compatibility). # raw bytes (for backwards compatibility).
assert isinstance(result, (wireprototypes.bytesresponse, bytes)) assert isinstance(result, (wireprototypes.bytesresponse, bytes))
if isinstance(result, wireprototypes.bytesresponse): if isinstance(result, wireprototypes.bytesresponse):
result = result.data result = result.data
res.append(escapearg(result)) res.append(wireprototypes.escapebatcharg(result))
return wireprototypes.bytesresponse(';'.join(res)) return wireprototypes.bytesresponse(';'.join(res))
@wireprotocommand('between', 'pairs', transportpolicy=POLICY_V1_ONLY, @wireprotocommand('between', 'pairs', transportpolicy=POLICY_V1_ONLY,
permission='pull') permission='pull')
def between(repo, proto, pairs): def between(repo, proto, pairs):
pairs = [decodelist(p, '-') for p in pairs.split(" ")] pairs = [wireprototypes.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(wireprototypes.encodelist(b) + "\n")
return wireprototypes.bytesresponse(''.join(r)) return wireprototypes.bytesresponse(''.join(r))
@wireprotocommand('branchmap', permission='pull', @wireprotocommand('branchmap', permission='pull',
transportpolicy=POLICY_V1_ONLY) transportpolicy=POLICY_V1_ONLY)
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 = wireprototypes.encodelist(nodes)
heads.append('%s %s' % (branchname, branchnodes)) heads.append('%s %s' % (branchname, branchnodes))
return wireprototypes.bytesresponse('\n'.join(heads)) return wireprototypes.bytesresponse('\n'.join(heads))
@wireprotocommand('branches', 'nodes', transportpolicy=POLICY_V1_ONLY, @wireprotocommand('branches', 'nodes', transportpolicy=POLICY_V1_ONLY,
permission='pull') permission='pull')
def branches(repo, proto, nodes): def branches(repo, proto, nodes):
nodes = decodelist(nodes) nodes = wireprototypes.decodelist(nodes)
r = [] r = []
for b in repo.branches(nodes): for b in repo.branches(nodes):
r.append(encodelist(b) + "\n") r.append(wireprototypes.encodelist(b) + "\n")
return wireprototypes.bytesresponse(''.join(r)) return wireprototypes.bytesresponse(''.join(r))
@wireprotocommand('clonebundles', '', permission='pull', @wireprotocommand('clonebundles', '', permission='pull',
transportpolicy=POLICY_V1_ONLY) transportpolicy=POLICY_V1_ONLY)
def clonebundles(repo, proto): def clonebundles(repo, proto):
"""Server command for returning info for available bundles to seed clones. """Server command for returning info for available bundles to seed clones.
transportpolicy=POLICY_V1_ONLY) transportpolicy=POLICY_V1_ONLY)
def capabilities(repo, proto): def capabilities(repo, proto):
caps = _capabilities(repo, proto) caps = _capabilities(repo, proto)
return wireprototypes.bytesresponse(' '.join(sorted(caps))) return wireprototypes.bytesresponse(' '.join(sorted(caps)))
@wireprotocommand('changegroup', 'roots', transportpolicy=POLICY_V1_ONLY, @wireprotocommand('changegroup', 'roots', transportpolicy=POLICY_V1_ONLY,
permission='pull') permission='pull')
def changegroup(repo, proto, roots): def changegroup(repo, proto, roots):
nodes = decodelist(roots) nodes = wireprototypes.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 wireprototypes.streamres(gen=gen) return wireprototypes.streamres(gen=gen)
@wireprotocommand('changegroupsubset', 'bases heads', @wireprotocommand('changegroupsubset', 'bases heads',
transportpolicy=POLICY_V1_ONLY, transportpolicy=POLICY_V1_ONLY,
permission='pull') permission='pull')
def changegroupsubset(repo, proto, bases, heads): def changegroupsubset(repo, proto, bases, heads):
bases = decodelist(bases) bases = wireprototypes.decodelist(bases)
heads = decodelist(heads) heads = wireprototypes.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 wireprototypes.streamres(gen=gen) return wireprototypes.streamres(gen=gen)
@wireprotocommand('debugwireargs', 'one two *', @wireprotocommand('debugwireargs', 'one two *',
permission='pull', transportpolicy=POLICY_V1_ONLY) permission='pull', transportpolicy=POLICY_V1_ONLY)
@wireprotocommand('getbundle', '*', permission='pull', @wireprotocommand('getbundle', '*', permission='pull',
transportpolicy=POLICY_V1_ONLY) transportpolicy=POLICY_V1_ONLY)
def getbundle(repo, proto, others): def getbundle(repo, proto, others):
opts = options('getbundle', gboptsmap.keys(), others) opts = options('getbundle', gboptsmap.keys(), others)
for k, v in opts.iteritems(): for k, v in opts.iteritems():
keytype = gboptsmap[k] keytype = gboptsmap[k]
if keytype == 'nodes': if keytype == 'nodes':
opts[k] = decodelist(v) opts[k] = wireprototypes.decodelist(v)
elif keytype == 'csv': elif keytype == 'csv':
opts[k] = list(v.split(',')) opts[k] = list(v.split(','))
elif keytype == 'scsv': elif keytype == 'scsv':
opts[k] = set(v.split(',')) opts[k] = set(v.split(','))
elif keytype == 'boolean': elif keytype == 'boolean':
# Client should serialize False as '0', which is a non-empty string # Client should serialize False as '0', which is a non-empty string
# so it evaluates as a True bool. # so it evaluates as a True bool.
if v == '0': if v == '0':
prefercompressed = False prefercompressed = False
return wireprototypes.streamres( return wireprototypes.streamres(
gen=chunks, prefer_uncompressed=not prefercompressed) gen=chunks, prefer_uncompressed=not prefercompressed)
@wireprotocommand('heads', permission='pull', transportpolicy=POLICY_V1_ONLY) @wireprotocommand('heads', permission='pull', transportpolicy=POLICY_V1_ONLY)
def heads(repo, proto): def heads(repo, proto):
h = repo.heads() h = repo.heads()
return wireprototypes.bytesresponse(encodelist(h) + '\n') return wireprototypes.bytesresponse(wireprototypes.encodelist(h) + '\n')
@wireprotocommand('hello', permission='pull', transportpolicy=POLICY_V1_ONLY) @wireprotocommand('hello', permission='pull', transportpolicy=POLICY_V1_ONLY)
def hello(repo, proto): def hello(repo, proto):
"""Called as part of SSH handshake to obtain server info. """Called as part of SSH handshake to obtain server info.
Returns a list of lines describing interesting things about the Returns a list of lines describing interesting things about the
server, in an RFC822-like format. server, in an RFC822-like format.
except Exception as inst: except Exception as inst:
r = stringutil.forcebytestr(inst) r = stringutil.forcebytestr(inst)
success = 0 success = 0
return wireprototypes.bytesresponse('%d %s\n' % (success, r)) return wireprototypes.bytesresponse('%d %s\n' % (success, r))
@wireprotocommand('known', 'nodes *', permission='pull', @wireprotocommand('known', 'nodes *', permission='pull',
transportpolicy=POLICY_V1_ONLY) transportpolicy=POLICY_V1_ONLY)
def known(repo, proto, nodes, others): def known(repo, proto, nodes, others):
v = ''.join(b and '1' or '0' for b in repo.known(decodelist(nodes))) v = ''.join(b and '1' or '0'
for b in repo.known(wireprototypes.decodelist(nodes)))
return wireprototypes.bytesresponse(v) return wireprototypes.bytesresponse(v)
@wireprotocommand('protocaps', 'caps', permission='pull', @wireprotocommand('protocaps', 'caps', permission='pull',
transportpolicy=POLICY_V1_ONLY) transportpolicy=POLICY_V1_ONLY)
def protocaps(repo, proto, caps): def protocaps(repo, proto, caps):
if proto.name == wireprototypes.SSHV1: if proto.name == wireprototypes.SSHV1:
proto._protocaps = set(caps.split(' ')) proto._protocaps = set(caps.split(' '))
return wireprototypes.bytesresponse('OK') return wireprototypes.bytesresponse('OK')
it is serving. Client checks to see if it understands the format. it is serving. Client checks to see if it understands the format.
''' '''
return wireprototypes.streamreslegacy( return wireprototypes.streamreslegacy(
streamclone.generatev1wireproto(repo)) streamclone.generatev1wireproto(repo))
@wireprotocommand('unbundle', 'heads', permission='push', @wireprotocommand('unbundle', 'heads', permission='push',
transportpolicy=POLICY_V1_ONLY) transportpolicy=POLICY_V1_ONLY)
def unbundle(repo, proto, heads): def unbundle(repo, proto, heads):
their_heads = decodelist(heads) their_heads = wireprototypes.decodelist(heads)
with proto.mayberedirectstdio() as output: with proto.mayberedirectstdio() as output:
try: try:
exchange.check_heads(repo, their_heads, 'preparing changes') exchange.check_heads(repo, their_heads, 'preparing changes')
cleanup = lambda: None cleanup = lambda: None
try: try:
payload = proto.getpayload() payload = proto.getpayload()
if repo.ui.configbool('server', 'streamunbundle'): if repo.ui.configbool('server', 'streamunbundle'):

mercurial/wireprototypes.py

# Copyright 2018 Gregory Szorc <gregory.szorc@gmail.com> # Copyright 2018 Gregory Szorc <gregory.szorc@gmail.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
from .node import (
bin,
hex,
)
from .thirdparty.zope import ( from .thirdparty.zope import (
interface as zi, interface as zi,
) )
# Names of the SSH protocol implementations. # Names of the SSH protocol implementations.
SSHV1 = 'ssh-v1' SSHV1 = 'ssh-v1'
# These are advertised over the wire. Increment the counters at the end # These are advertised over the wire. Increment the counters at the end
# to reflect BC breakages. # to reflect BC breakages.
def __init__(self, gen=None): def __init__(self, gen=None):
self.gen = gen self.gen = gen
class cborresponse(object): class cborresponse(object):
"""Encode the response value as CBOR.""" """Encode the response value as CBOR."""
def __init__(self, v): def __init__(self, v):
self.value = v self.value = v
# list of nodes encoding / decoding
def decodelist(l, sep=' '):
if l:
return [bin(v) for v in l.split(sep)]
return []
def encodelist(l, sep=' '):
try:
return sep.join(map(hex, l))
except TypeError:
raise
# batched call argument encoding
def escapebatcharg(plain):
return (plain
.replace(':', ':c')
.replace(',', ':o')
.replace(';', ':s')
.replace('=', ':e'))
def unescapebatcharg(escaped):
return (escaped
.replace(':e', '=')
.replace(':s', ';')
.replace(':o', ',')
.replace(':c', ':'))
class baseprotocolhandler(zi.Interface): class baseprotocolhandler(zi.Interface):
"""Abstract base class for wire protocol handlers. """Abstract base class for wire protocol handlers.
A wire protocol handler serves as an interface between protocol command A wire protocol handler serves as an interface between protocol command
handlers and the wire protocol transport layer. Protocol handlers provide handlers and the wire protocol transport layer. Protocol handlers provide
methods to read command arguments, redirect stdio for the duration of methods to read command arguments, redirect stdio for the duration of
the request, handle response types, etc. the request, handle response types, etc.
""" """