| durin42 |
| hg-reviewers |
We generally shy away from aliasing module symbols. I think I
was keeping this around for API compatibility. We've already made
tons of other API breaks in the wire protocol code this release.
What's one more?
.. api::
``wireproto`` module no longer re-exports various types used to define responses to wire protocol commands. Access these types from the ``wireprototypes`` module.
| Automatic diff as part of commit; lint not applicable. |
| Automatic diff as part of commit; unit tests not applicable. |
| Path | Packages | |||
|---|---|---|---|---|
| M | hgext/largefiles/proto.py (9 lines) | |||
| M | mercurial/wireproto.py (73 lines) |
| tmpfp._fp.seek(0) | tmpfp._fp.seek(0) | ||||
| if sha != lfutil.hexsha1(tmpfp._fp): | if sha != lfutil.hexsha1(tmpfp._fp): | ||||
| raise IOError(0, _('largefile contents do not match hash')) | raise IOError(0, _('largefile contents do not match hash')) | ||||
| tmpfp.close() | tmpfp.close() | ||||
| lfutil.linktousercache(repo, sha) | lfutil.linktousercache(repo, sha) | ||||
| except IOError as e: | except IOError as e: | ||||
| repo.ui.warn(_('largefiles: failed to put %s into store: %s\n') % | repo.ui.warn(_('largefiles: failed to put %s into store: %s\n') % | ||||
| (sha, e.strerror)) | (sha, e.strerror)) | ||||
| return wireproto.pushres(1, output.getvalue() if output else '') | return wireprototypes.pushres( | ||||
| 1, output.getvalue() if output else '') | |||||
| finally: | finally: | ||||
| tmpfp.discard() | tmpfp.discard() | ||||
| return wireproto.pushres(0, output.getvalue() if output else '') | return wireprototypes.pushres(0, output.getvalue() if output else '') | ||||
| def getlfile(repo, proto, sha): | def getlfile(repo, proto, sha): | ||||
| '''Server command for retrieving a largefile from the repository-local | '''Server command for retrieving a largefile from the repository-local | ||||
| cache or user cache.''' | cache or user cache.''' | ||||
| filename = lfutil.findfile(repo, sha) | filename = lfutil.findfile(repo, sha) | ||||
| if not filename: | if not filename: | ||||
| raise error.Abort(_('requested largefile %s not present in cache') | raise error.Abort(_('requested largefile %s not present in cache') | ||||
| % sha) | % sha) | ||||
| f = open(filename, 'rb') | f = open(filename, 'rb') | ||||
| length = os.fstat(f.fileno())[6] | length = os.fstat(f.fileno())[6] | ||||
| # Since we can't set an HTTP content-length header here, and | # Since we can't set an HTTP content-length header here, and | ||||
| # Mercurial core provides no way to give the length of a streamres | # Mercurial core provides no way to give the length of a streamres | ||||
| # (and reading the entire file into RAM would be ill-advised), we | # (and reading the entire file into RAM would be ill-advised), we | ||||
| # just send the length on the first line of the response, like the | # just send the length on the first line of the response, like the | ||||
| # ssh proto does for string responses. | # ssh proto does for string responses. | ||||
| def generator(): | def generator(): | ||||
| yield '%d\n' % length | yield '%d\n' % length | ||||
| for chunk in util.filechunkiter(f): | for chunk in util.filechunkiter(f): | ||||
| yield chunk | yield chunk | ||||
| return wireproto.streamres_legacy(gen=generator()) | return wireprototypes.streamreslegacy(gen=generator()) | ||||
| def statlfile(repo, proto, sha): | def statlfile(repo, proto, sha): | ||||
| '''Server command for checking if a largefile is present - returns '2\n' if | '''Server command for checking if a largefile is present - returns '2\n' if | ||||
| the largefile is missing, '0\n' if it seems to be in good condition. | the largefile is missing, '0\n' if it seems to be in good condition. | ||||
| The value 1 is reserved for mismatched checksum, but that is too expensive | The value 1 is reserved for mismatched checksum, but that is too expensive | ||||
| to be verified on every stat and must be caught be running 'hg verify' | to be verified on every stat and must be caught be running 'hg verify' | ||||
| server side.''' | server side.''' | ||||
| caps = orig(repo, proto) | caps = orig(repo, proto) | ||||
| caps.append('largefiles=serve') | caps.append('largefiles=serve') | ||||
| return caps | return caps | ||||
| def heads(repo, proto): | def heads(repo, proto): | ||||
| '''Wrap server command - largefile capable clients will know to call | '''Wrap server command - largefile capable clients will know to call | ||||
| lheads instead''' | lheads instead''' | ||||
| if lfutil.islfilesrepo(repo): | if lfutil.islfilesrepo(repo): | ||||
| return wireproto.ooberror(LARGEFILES_REQUIRED_MSG) | return wireprototypes.ooberror(LARGEFILES_REQUIRED_MSG) | ||||
| return wireproto.heads(repo, proto) | return wireproto.heads(repo, proto) | ||||
| def sshrepocallstream(self, cmd, **args): | def sshrepocallstream(self, cmd, **args): | ||||
| if cmd == 'heads' and self.capable('largefiles'): | if cmd == 'heads' and self.capable('largefiles'): | ||||
| cmd = 'lheads' | cmd = 'lheads' | ||||
| if cmd == 'batch' and self.capable('largefiles'): | if cmd == 'batch' and self.capable('largefiles'): | ||||
| args[r'cmds'] = args[r'cmds'].replace('heads ', 'lheads ') | args[r'cmds'] = args[r'cmds'].replace('heads ', 'lheads ') | ||||
| return ssholdcallstream(self, cmd, **args) | return ssholdcallstream(self, cmd, **args) | ||||
| from .utils import ( | from .utils import ( | ||||
| procutil, | procutil, | ||||
| stringutil, | stringutil, | ||||
| ) | ) | ||||
| urlerr = util.urlerr | urlerr = util.urlerr | ||||
| urlreq = util.urlreq | urlreq = util.urlreq | ||||
| bytesresponse = wireprototypes.bytesresponse | |||||
| ooberror = wireprototypes.ooberror | |||||
| pushres = wireprototypes.pushres | |||||
| pusherr = wireprototypes.pusherr | |||||
| streamres = wireprototypes.streamres | |||||
| streamres_legacy = wireprototypes.streamreslegacy | |||||
| bundle2requiredmain = _('incompatible Mercurial client; bundle2 required') | bundle2requiredmain = _('incompatible Mercurial client; bundle2 required') | ||||
| bundle2requiredhint = _('see https://www.mercurial-scm.org/wiki/' | bundle2requiredhint = _('see https://www.mercurial-scm.org/wiki/' | ||||
| 'IncompatibleClient') | 'IncompatibleClient') | ||||
| bundle2required = '%s\n(%s)\n' % (bundle2requiredmain, bundle2requiredhint) | bundle2required = '%s\n(%s)\n' % (bundle2requiredmain, bundle2requiredhint) | ||||
| class remoteiterbatcher(peer.iterbatcher): | class remoteiterbatcher(peer.iterbatcher): | ||||
| def __init__(self, remote): | def __init__(self, remote): | ||||
| super(remoteiterbatcher, self).__init__() | super(remoteiterbatcher, self).__init__() | ||||
| if key not in keys: | if key not in keys: | ||||
| star[key] = vals[key] | star[key] = vals[key] | ||||
| data['*'] = star | data['*'] = star | ||||
| else: | else: | ||||
| data[k] = vals[k] | data[k] = vals[k] | ||||
| result = func(repo, proto, *[data[k] for k in keys]) | result = func(repo, proto, *[data[k] for k in keys]) | ||||
| else: | else: | ||||
| result = func(repo, proto) | result = func(repo, proto) | ||||
| if isinstance(result, 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, (bytesresponse, bytes)) | assert isinstance(result, (wireprototypes.bytesresponse, bytes)) | ||||
| if isinstance(result, bytesresponse): | if isinstance(result, wireprototypes.bytesresponse): | ||||
| result = result.data | result = result.data | ||||
| res.append(escapearg(result)) | res.append(escapearg(result)) | ||||
| return 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 = [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(encodelist(b) + "\n") | ||||
| return bytesresponse(''.join(r)) | return wireprototypes.bytesresponse(''.join(r)) | ||||
| @wireprotocommand('branchmap', permission='pull') | @wireprotocommand('branchmap', permission='pull') | ||||
| 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 = encodelist(nodes) | ||||
| heads.append('%s %s' % (branchname, branchnodes)) | heads.append('%s %s' % (branchname, branchnodes)) | ||||
| return 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 = decodelist(nodes) | ||||
| r = [] | r = [] | ||||
| for b in repo.branches(nodes): | for b in repo.branches(nodes): | ||||
| r.append(encodelist(b) + "\n") | r.append(encodelist(b) + "\n") | ||||
| return bytesresponse(''.join(r)) | return wireprototypes.bytesresponse(''.join(r)) | ||||
| @wireprotocommand('clonebundles', '', permission='pull') | @wireprotocommand('clonebundles', '', permission='pull') | ||||
| 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. | ||||
| Clients will parse this response and determine what bundle to fetch. | Clients will parse this response and determine what bundle to fetch. | ||||
| Extensions may wrap this command to filter or dynamically emit data | Extensions may wrap this command to filter or dynamically emit data | ||||
| depending on the request. e.g. you could advertise URLs for the closest | depending on the request. e.g. you could advertise URLs for the closest | ||||
| data center given the client's IP address. | data center given the client's IP address. | ||||
| """ | """ | ||||
| return bytesresponse(repo.vfs.tryread('clonebundles.manifest')) | return wireprototypes.bytesresponse( | ||||
| repo.vfs.tryread('clonebundles.manifest')) | |||||
| wireprotocaps = ['lookup', 'branchmap', 'pushkey', | wireprotocaps = ['lookup', 'branchmap', 'pushkey', | ||||
| 'known', 'getbundle', 'unbundlehash'] | 'known', 'getbundle', 'unbundlehash'] | ||||
| def _capabilities(repo, proto): | def _capabilities(repo, proto): | ||||
| """return a list of capabilities for a repo | """return a list of capabilities for a repo | ||||
| This function exists to allow extensions to easily wrap capabilities | This function exists to allow extensions to easily wrap capabilities | ||||
| caps.append('unbundle=%s' % ','.join(bundle2.bundlepriority)) | caps.append('unbundle=%s' % ','.join(bundle2.bundlepriority)) | ||||
| return proto.addcapabilities(repo, caps) | return proto.addcapabilities(repo, caps) | ||||
| # If you are writing an extension and consider wrapping this function. Wrap | # If you are writing an extension and consider wrapping this function. Wrap | ||||
| # `_capabilities` instead. | # `_capabilities` instead. | ||||
| @wireprotocommand('capabilities', permission='pull') | @wireprotocommand('capabilities', permission='pull') | ||||
| def capabilities(repo, proto): | def capabilities(repo, proto): | ||||
| return bytesresponse(' '.join(_capabilities(repo, proto))) | return wireprototypes.bytesresponse(' '.join(_capabilities(repo, proto))) | ||||
| @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 = 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 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 = decodelist(bases) | ||||
| heads = decodelist(heads) | heads = 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 streamres(gen=gen) | return wireprototypes.streamres(gen=gen) | ||||
| @wireprotocommand('debugwireargs', 'one two *', | @wireprotocommand('debugwireargs', 'one two *', | ||||
| permission='pull') | permission='pull') | ||||
| def debugwireargs(repo, proto, one, two, others): | def debugwireargs(repo, proto, one, two, others): | ||||
| # only accept optional args from the known set | # only accept optional args from the known set | ||||
| opts = options('debugwireargs', ['three', 'four'], others) | opts = options('debugwireargs', ['three', 'four'], others) | ||||
| return bytesresponse(repo.debugwireargs(one, two, | return wireprototypes.bytesresponse(repo.debugwireargs( | ||||
| **pycompat.strkwargs(opts))) | one, two, **pycompat.strkwargs(opts))) | ||||
| @wireprotocommand('getbundle', '*', permission='pull') | @wireprotocommand('getbundle', '*', permission='pull') | ||||
| 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] = decodelist(v) | ||||
| opts[k] = bool(v) | opts[k] = bool(v) | ||||
| elif keytype != 'plain': | elif keytype != 'plain': | ||||
| raise KeyError('unknown getbundle option type %s' | raise KeyError('unknown getbundle option type %s' | ||||
| % keytype) | % keytype) | ||||
| if not bundle1allowed(repo, 'pull'): | if not bundle1allowed(repo, 'pull'): | ||||
| if not exchange.bundle2requested(opts.get('bundlecaps')): | if not exchange.bundle2requested(opts.get('bundlecaps')): | ||||
| if proto.name == 'http-v1': | if proto.name == 'http-v1': | ||||
| return ooberror(bundle2required) | return wireprototypes.ooberror(bundle2required) | ||||
| raise error.Abort(bundle2requiredmain, | raise error.Abort(bundle2requiredmain, | ||||
| hint=bundle2requiredhint) | hint=bundle2requiredhint) | ||||
| prefercompressed = True | prefercompressed = True | ||||
| try: | try: | ||||
| if repo.ui.configbool('server', 'disablefullbundle'): | if repo.ui.configbool('server', 'disablefullbundle'): | ||||
| # Check to see if this is a full clone. | # Check to see if this is a full clone. | ||||
| info, chunks = exchange.getbundlechunks(repo, 'serve', | info, chunks = exchange.getbundlechunks(repo, 'serve', | ||||
| **pycompat.strkwargs(opts)) | **pycompat.strkwargs(opts)) | ||||
| prefercompressed = info.get('prefercompressed', True) | prefercompressed = info.get('prefercompressed', True) | ||||
| except error.Abort as exc: | except error.Abort as exc: | ||||
| # cleanly forward Abort error to the client | # cleanly forward Abort error to the client | ||||
| if not exchange.bundle2requested(opts.get('bundlecaps')): | if not exchange.bundle2requested(opts.get('bundlecaps')): | ||||
| if proto.name == 'http-v1': | if proto.name == 'http-v1': | ||||
| return ooberror(pycompat.bytestr(exc) + '\n') | return wireprototypes.ooberror(pycompat.bytestr(exc) + '\n') | ||||
| raise # cannot do better for bundle1 + ssh | raise # cannot do better for bundle1 + ssh | ||||
| # bundle2 request expect a bundle2 reply | # bundle2 request expect a bundle2 reply | ||||
| bundler = bundle2.bundle20(repo.ui) | bundler = bundle2.bundle20(repo.ui) | ||||
| manargs = [('message', pycompat.bytestr(exc))] | manargs = [('message', pycompat.bytestr(exc))] | ||||
| advargs = [] | advargs = [] | ||||
| if exc.hint is not None: | if exc.hint is not None: | ||||
| advargs.append(('hint', exc.hint)) | advargs.append(('hint', exc.hint)) | ||||
| bundler.addpart(bundle2.bundlepart('error:abort', | bundler.addpart(bundle2.bundlepart('error:abort', | ||||
| manargs, advargs)) | manargs, advargs)) | ||||
| chunks = bundler.getchunks() | chunks = bundler.getchunks() | ||||
| prefercompressed = False | prefercompressed = False | ||||
| return streamres(gen=chunks, prefer_uncompressed=not prefercompressed) | return wireprototypes.streamres( | ||||
| gen=chunks, prefer_uncompressed=not prefercompressed) | |||||
| @wireprotocommand('heads', permission='pull') | @wireprotocommand('heads', permission='pull') | ||||
| def heads(repo, proto): | def heads(repo, proto): | ||||
| h = repo.heads() | h = repo.heads() | ||||
| return bytesresponse(encodelist(h) + '\n') | return wireprototypes.bytesresponse(encodelist(h) + '\n') | ||||
| @wireprotocommand('hello', permission='pull') | @wireprotocommand('hello', permission='pull') | ||||
| 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. | ||||
| Currently, the only one defined is ``capabilities``, which consists of a | Currently, the only one defined is ``capabilities``, which consists of a | ||||
| line of space separated tokens describing server abilities: | line of space separated tokens describing server abilities: | ||||
| capabilities: <token0> <token1> <token2> | capabilities: <token0> <token1> <token2> | ||||
| """ | """ | ||||
| caps = capabilities(repo, proto).data | caps = capabilities(repo, proto).data | ||||
| return bytesresponse('capabilities: %s\n' % caps) | return wireprototypes.bytesresponse('capabilities: %s\n' % caps) | ||||
| @wireprotocommand('listkeys', 'namespace', permission='pull') | @wireprotocommand('listkeys', 'namespace', permission='pull') | ||||
| def listkeys(repo, proto, namespace): | def listkeys(repo, proto, namespace): | ||||
| d = sorted(repo.listkeys(encoding.tolocal(namespace)).items()) | d = sorted(repo.listkeys(encoding.tolocal(namespace)).items()) | ||||
| return bytesresponse(pushkeymod.encodekeys(d)) | return wireprototypes.bytesresponse(pushkeymod.encodekeys(d)) | ||||
| @wireprotocommand('lookup', 'key', permission='pull') | @wireprotocommand('lookup', 'key', permission='pull') | ||||
| def lookup(repo, proto, key): | def lookup(repo, proto, key): | ||||
| try: | try: | ||||
| k = encoding.tolocal(key) | k = encoding.tolocal(key) | ||||
| c = repo[k] | c = repo[k] | ||||
| r = c.hex() | r = c.hex() | ||||
| success = 1 | success = 1 | ||||
| except Exception as inst: | except Exception as inst: | ||||
| r = stringutil.forcebytestr(inst) | r = stringutil.forcebytestr(inst) | ||||
| success = 0 | success = 0 | ||||
| return bytesresponse('%d %s\n' % (success, r)) | return wireprototypes.bytesresponse('%d %s\n' % (success, r)) | ||||
| @wireprotocommand('known', 'nodes *', permission='pull') | @wireprotocommand('known', 'nodes *', permission='pull') | ||||
| 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(decodelist(nodes))) | ||||
| return bytesresponse(v) | return wireprototypes.bytesresponse(v) | ||||
| @wireprotocommand('pushkey', 'namespace key old new', permission='push') | @wireprotocommand('pushkey', 'namespace key old new', permission='push') | ||||
| def pushkey(repo, proto, namespace, key, old, new): | def pushkey(repo, proto, namespace, key, old, new): | ||||
| # compatibility with pre-1.8 clients which were accidentally | # compatibility with pre-1.8 clients which were accidentally | ||||
| # sending raw binary nodes rather than utf-8-encoded hex | # sending raw binary nodes rather than utf-8-encoded hex | ||||
| if len(new) == 20 and stringutil.escapestr(new) != new: | if len(new) == 20 and stringutil.escapestr(new) != new: | ||||
| # looks like it could be a binary node | # looks like it could be a binary node | ||||
| try: | try: | ||||
| new.decode('utf-8') | new.decode('utf-8') | ||||
| new = encoding.tolocal(new) # but cleanly decodes as UTF-8 | new = encoding.tolocal(new) # but cleanly decodes as UTF-8 | ||||
| except UnicodeDecodeError: | except UnicodeDecodeError: | ||||
| pass # binary, leave unmodified | pass # binary, leave unmodified | ||||
| else: | else: | ||||
| new = encoding.tolocal(new) # normal path | new = encoding.tolocal(new) # normal path | ||||
| with proto.mayberedirectstdio() as output: | with proto.mayberedirectstdio() as output: | ||||
| r = repo.pushkey(encoding.tolocal(namespace), encoding.tolocal(key), | r = repo.pushkey(encoding.tolocal(namespace), encoding.tolocal(key), | ||||
| encoding.tolocal(old), new) or False | encoding.tolocal(old), new) or False | ||||
| output = output.getvalue() if output else '' | output = output.getvalue() if output else '' | ||||
| return bytesresponse('%d\n%s' % (int(r), output)) | return wireprototypes.bytesresponse('%d\n%s' % (int(r), output)) | ||||
| @wireprotocommand('stream_out', permission='pull') | @wireprotocommand('stream_out', permission='pull') | ||||
| def stream(repo, proto): | def stream(repo, proto): | ||||
| '''If the server supports streaming clone, it advertises the "stream" | '''If the server supports streaming clone, it advertises the "stream" | ||||
| capability with a value representing the version and flags of the repo | capability with a value representing the version and flags of the repo | ||||
| 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 streamres_legacy(streamclone.generatev1wireproto(repo)) | return wireprototypes.streamreslegacy( | ||||
| streamclone.generatev1wireproto(repo)) | |||||
| @wireprotocommand('unbundle', 'heads', permission='push') | @wireprotocommand('unbundle', 'heads', permission='push') | ||||
| def unbundle(repo, proto, heads): | def unbundle(repo, proto, heads): | ||||
| their_heads = decodelist(heads) | their_heads = 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') | ||||
| # write bundle data to temporary file because it can be big | # write bundle data to temporary file because it can be big | ||||
| fd, tempname = tempfile.mkstemp(prefix='hg-unbundle-') | fd, tempname = tempfile.mkstemp(prefix='hg-unbundle-') | ||||
| fp = os.fdopen(fd, r'wb+') | fp = os.fdopen(fd, r'wb+') | ||||
| r = 0 | r = 0 | ||||
| try: | try: | ||||
| proto.forwardpayload(fp) | proto.forwardpayload(fp) | ||||
| fp.seek(0) | fp.seek(0) | ||||
| gen = exchange.readbundle(repo.ui, fp, None) | gen = exchange.readbundle(repo.ui, fp, None) | ||||
| if (isinstance(gen, changegroupmod.cg1unpacker) | if (isinstance(gen, changegroupmod.cg1unpacker) | ||||
| and not bundle1allowed(repo, 'push')): | and not bundle1allowed(repo, 'push')): | ||||
| if proto.name == 'http-v1': | if proto.name == 'http-v1': | ||||
| # need to special case http because stderr do not get to | # need to special case http because stderr do not get to | ||||
| # the http client on failed push so we need to abuse | # the http client on failed push so we need to abuse | ||||
| # some other error type to make sure the message get to | # some other error type to make sure the message get to | ||||
| # the user. | # the user. | ||||
| return ooberror(bundle2required) | return wireprototypes.ooberror(bundle2required) | ||||
| raise error.Abort(bundle2requiredmain, | raise error.Abort(bundle2requiredmain, | ||||
| hint=bundle2requiredhint) | hint=bundle2requiredhint) | ||||
| r = exchange.unbundle(repo, gen, their_heads, 'serve', | r = exchange.unbundle(repo, gen, their_heads, 'serve', | ||||
| proto.client()) | proto.client()) | ||||
| if util.safehasattr(r, 'addpart'): | if util.safehasattr(r, 'addpart'): | ||||
| # The return looks streamable, we are in the bundle2 case | # The return looks streamable, we are in the bundle2 case | ||||
| # and should return a stream. | # and should return a stream. | ||||
| return streamres_legacy(gen=r.getchunks()) | return wireprototypes.streamreslegacy(gen=r.getchunks()) | ||||
| return pushres(r, output.getvalue() if output else '') | return wireprototypes.pushres( | ||||
| r, output.getvalue() if output else '') | |||||
| finally: | finally: | ||||
| fp.close() | fp.close() | ||||
| os.unlink(tempname) | os.unlink(tempname) | ||||
| except (error.BundleValueError, error.Abort, error.PushRaced) as exc: | except (error.BundleValueError, error.Abort, error.PushRaced) as exc: | ||||
| # handle non-bundle2 case first | # handle non-bundle2 case first | ||||
| if not getattr(exc, 'duringunbundle2', False): | if not getattr(exc, 'duringunbundle2', False): | ||||
| try: | try: | ||||
| raise | raise | ||||
| except error.Abort: | except error.Abort: | ||||
| # The old code we moved used procutil.stderr directly. | # The old code we moved used procutil.stderr directly. | ||||
| # We did not change it to minimise code change. | # We did not change it to minimise code change. | ||||
| # This need to be moved to something proper. | # This need to be moved to something proper. | ||||
| # Feel free to do it. | # Feel free to do it. | ||||
| procutil.stderr.write("abort: %s\n" % exc) | procutil.stderr.write("abort: %s\n" % exc) | ||||
| if exc.hint is not None: | if exc.hint is not None: | ||||
| procutil.stderr.write("(%s)\n" % exc.hint) | procutil.stderr.write("(%s)\n" % exc.hint) | ||||
| procutil.stderr.flush() | procutil.stderr.flush() | ||||
| return pushres(0, output.getvalue() if output else '') | return wireprototypes.pushres( | ||||
| 0, output.getvalue() if output else '') | |||||
| except error.PushRaced: | except error.PushRaced: | ||||
| return pusherr(pycompat.bytestr(exc), | return wireprototypes.pusherr( | ||||
| pycompat.bytestr(exc), | |||||
| output.getvalue() if output else '') | output.getvalue() if output else '') | ||||
| bundler = bundle2.bundle20(repo.ui) | bundler = bundle2.bundle20(repo.ui) | ||||
| for out in getattr(exc, '_bundle2salvagedoutput', ()): | for out in getattr(exc, '_bundle2salvagedoutput', ()): | ||||
| bundler.addpart(out) | bundler.addpart(out) | ||||
| try: | try: | ||||
| try: | try: | ||||
| raise | raise | ||||
| except error.PushkeyFailed as exc: | except error.PushkeyFailed as exc: | ||||
| advargs = [] | advargs = [] | ||||
| if exc.hint is not None: | if exc.hint is not None: | ||||
| advargs.append(('hint', exc.hint)) | advargs.append(('hint', exc.hint)) | ||||
| bundler.addpart(bundle2.bundlepart('error:abort', | bundler.addpart(bundle2.bundlepart('error:abort', | ||||
| manargs, advargs)) | manargs, advargs)) | ||||
| except error.PushRaced as exc: | except error.PushRaced as exc: | ||||
| bundler.newpart('error:pushraced', | bundler.newpart('error:pushraced', | ||||
| [('message', stringutil.forcebytestr(exc))]) | [('message', stringutil.forcebytestr(exc))]) | ||||
| return streamres_legacy(gen=bundler.getchunks()) | return wireprototypes.streamreslegacy(gen=bundler.getchunks()) | ||||