mercurial: comparison mercurial/wireprotov2peer.py

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 ``target`` should come from the capabilities data structure emitted by
 the server.
 """
 if target.get(b'protocol') not in SUPPORTED_REDIRECT_PROTOCOLS:
 ui.note(
-_('(remote redirect target %s uses unsupported protocol: %s)\n')
+_(b'(remote redirect target %s uses unsupported protocol: %s)\n')
 % (target[b'name'], target.get(b'protocol', b''))
 )
 return False
 if target.get(b'snirequired') and not sslutil.hassni:
 ui.note(
-_('(redirect target %s requires SNI, which is unsupported)\n')
+_(b'(redirect target %s requires SNI, which is unsupported)\n')
 % target[b'name']
 )
 return False
 if b'tlsversions' in target:
 supported.add(v[3:])
 if not tlsversions & supported:
 ui.note(
 _(
-'(remote redirect target %s requires unsupported TLS '
+b'(remote redirect target %s requires unsupported TLS '
-'versions: %s)\n'
+b'versions: %s)\n'
 )
 % (target[b'name'], b', '.join(sorted(tlsversions)))
 )
 return False
-ui.note(_('(remote redirect target %s is compatible)\n') % target[b'name'])
+ui.note(_(b'(remote redirect target %s is compatible)\n') % target[b'name'])
 return True
 def supportedredirects(ui, apidescriptor):
 # content redirect is the only object in the stream. Fail
 # if we see a misbehaving server.
 if self._redirect:
 raise error.Abort(
 _(
-'received unexpected response data '
+b'received unexpected response data '
-'after content redirect; the remote is '
+b'after content redirect; the remote is '
-'buggy'
+b'buggy'
 )
 )
 self._pendingevents.append(o)
 serverdercerts=l.get(b'serverdercerts'),
 servercadercerts=l.get(b'servercadercerts'),
 )
 return
-atoms = [{'msg': o[b'error'][b'message']}]
+atoms = [{b'msg': o[b'error'][b'message']}]
 if b'args' in o[b'error']:
-atoms[0]['args'] = o[b'error'][b'args']
+atoms[0][b'args'] = o[b'error'][b'args']
 raise error.RepoError(formatrichmessage(atoms))
 def objects(self):
 """Obtained decoded objects from this response.
 """
 request, action, meta = self._reactor.callcommand(
 command, args, redirect=redirect
 )
-if action != 'noop':
+if action != b'noop':
-raise error.ProgrammingError('%s not yet supported' % action)
+raise error.ProgrammingError(b'%s not yet supported' % action)
 rid = request.requestid
 self._requests[rid] = request
 self._futures[rid] = f
 # TODO we need some kind of lifetime on response instances otherwise
 Returns an iterable of frames that should be sent over the wire.
 """
 action, meta = self._reactor.flushcommands()
-if action != 'sendframes':
+if action != b'sendframes':
-raise error.ProgrammingError('%s not yet supported' % action)
+raise error.ProgrammingError(b'%s not yet supported' % action)
-return meta['framegen']
+return meta[b'framegen']
 def readdata(self, framefh):
 """Attempt to read data and do work.
 Returns None if no data was read. Presumably this means we're
 frame = wireprotoframing.readframe(framefh)
 if frame is None:
 # TODO tell reactor?
 self._frameseof = True
 else:
-self._ui.debug('received %r\n' % frame)
+self._ui.debug(b'received %r\n' % frame)
 self._processframe(frame)
 # Also try to read the first redirect.
 if self._redirects:
 if not self._processredirect(*self._redirects[0]):
 def _processframe(self, frame):
 """Process a single read frame."""
 action, meta = self._reactor.onframerecv(frame)
-if action == 'error':
+if action == b'error':
-e = error.RepoError(meta['message'])
+e = error.RepoError(meta[b'message'])
 if frame.requestid in self._responses:
 self._responses[frame.requestid]._oninputcomplete()
 if frame.requestid in self._futures:
 del self._futures[frame.requestid]
 else:
 raise e
 return
-elif action == 'noop':
+elif action == b'noop':
 return
-elif action == 'responsedata':
+elif action == b'responsedata':
 # Handled below.
 pass
 else:
-raise error.ProgrammingError('action not handled: %s' % action)
+raise error.ProgrammingError(b'action not handled: %s' % action)
 if frame.requestid not in self._requests:
 raise error.ProgrammingError(
-'received frame for unknown request; this is either a bug in '
+b'received frame for unknown request; this is either a bug in '
-'the clientreactor not screening for this or this instance was '
+b'the clientreactor not screening for this or this instance was '
-'never told about this request: %r' % frame
+b'never told about this request: %r' % frame
 )
 response = self._responses[frame.requestid]
-if action == 'responsedata':
+if action == b'responsedata':
 # Any failures processing this frame should bubble up to the
 # future tracking the request.
 try:
 self._processresponsedata(frame, meta, response)
 except BaseException as e:
 response._oninputcomplete()
 else:
 response._onerror(e)
 else:
 raise error.ProgrammingError(
-'unhandled action from clientreactor: %s' % action
+b'unhandled action from clientreactor: %s' % action
 )
 def _processresponsedata(self, frame, meta, response):
 # This can raise. The caller can handle it.
-response._onresponsedata(meta['data'])
+response._onresponsedata(meta[b'data'])
 # We need to be careful about resolving futures prematurely. If a
 # response is a redirect response, resolving the future before the
 # redirect is processed would result in the consumer seeing an
 # empty stream of objects, since they'd be consuming our
 #
 # Our strategy is to not resolve/finish the request until either
 # EOS occurs or until the initial response object is fully received.
 # Always react to eos.
-if meta['eos']:
+if meta[b'eos']:
 response._oninputcomplete()
 del self._requests[frame.requestid]
 # Not EOS but we haven't decoded the initial response object yet.
 # Return and wait for more data.
 self._futures[frame.requestid].set_result(decoded)
 del self._futures[frame.requestid]
 def _followredirect(self, requestid, redirect):
 """Called to initiate redirect following for a request."""
-self._ui.note(_('(following redirect to %s)\n') % redirect.url)
+self._ui.note(_(b'(following redirect to %s)\n') % redirect.url)
 # TODO handle framed responses.
 if redirect.mediatype != b'application/mercurial-cbor':
 raise error.Abort(
-_('cannot handle redirects for the %s media type')
+_(b'cannot handle redirects for the %s media type')
 % redirect.mediatype
 )
 if redirect.fullhashes:
 self._ui.warn(
 _(
-'(support for validating hashes on content '
+b'(support for validating hashes on content '
-'redirects not supported)\n'
+b'redirects not supported)\n'
 )
 )
 if redirect.serverdercerts or redirect.servercadercerts:
 self._ui.warn(
 _(
-'(support for pinning server certificates on '
+b'(support for pinning server certificates on '
-'content redirects not supported)\n'
+b'content redirects not supported)\n'
 )
 )
 headers = {
 r'Accept': redirect.mediatype,
 try:
 res = self._opener.open(req)
 except util.urlerr.httperror as e:
 if e.code == 401:
-raise error.Abort(_('authorization failed'))
+raise error.Abort(_(b'authorization failed'))
 raise
 except util.httplib.HTTPException as e:
-self._ui.debug('http error requesting %s\n' % req.get_full_url())
+self._ui.debug(b'http error requesting %s\n' % req.get_full_url())
 self._ui.traceback()
 raise IOError(None, e)
 urlmod.wrapresponse(res)
 def decodepushkey(objs):
 return next(objs)
 COMMAND_DECODERS = {
-'branchmap': decodebranchmap,
+b'branchmap': decodebranchmap,
-'heads': decodeheads,
+b'heads': decodeheads,
-'known': decodeknown,
+b'known': decodeknown,
-'listkeys': decodelistkeys,
+b'listkeys': decodelistkeys,
-'lookup': decodelookup,
+b'lookup': decodelookup,
-'pushkey': decodepushkey,
+b'pushkey': decodepushkey,
 }

changeset 43077	687b865b95ad
parent 43076	2372284d9457
child 43506	9f70512ae2cf