mercurial-scm/hg: comparison mercurial/wireprotoframing.py

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 namemap = {v: k for k, v in mapping.iteritems()}
 flags = []
 val = 1
 while value >= val:
 if value & val:
-flags.append(namemap.get(val, '<unknown 0x%02x>' % val))
+flags.append(namemap.get(val, b'<unknown 0x%02x>' % val))
 val <<= 1
 return b'|'.join(flags)
 flags = attr.ib()
 payload = attr.ib()
 @encoding.strmethod
 def __repr__(self):
-typename = '<unknown 0x%02x>' % self.typeid
+typename = b'<unknown 0x%02x>' % self.typeid
 for name, value in FRAME_TYPES.iteritems():
 if value == self.typeid:
 typename = name
 break
 return (
-'frame(size=%d; request=%d; stream=%d; streamflags=%s; '
+b'frame(size=%d; request=%d; stream=%d; streamflags=%s; '
-'type=%s; flags=%s)'
+b'type=%s; flags=%s)'
 % (
 len(self.payload),
 self.requestid,
 self.streamid,
 humanflags(STREAM_FLAGS, self.streamflags),
 if readcount == 0:
 return None
 if readcount != FRAME_HEADER_SIZE:
 raise error.Abort(
-_('received incomplete frame: got %d bytes: %s')
+_(b'received incomplete frame: got %d bytes: %s')
 % (readcount, header)
 )
 h = parseheader(header)
 payload = fh.read(h.length)
 if len(payload) != h.length:
 raise error.Abort(
-_('frame length error: expected %d; got %d')
+_(b'frame length error: expected %d; got %d')
 % (h.length, len(payload))
 )
 return frame(
 h.requestid, h.streamid, h.streamflags, h.typeid, h.flags, payload
 for (formatting, args, labels) in atoms:
 # TODO look for localstr, other types here?
 if not isinstance(formatting, bytes):
-raise ValueError('must use bytes formatting strings')
+raise ValueError(b'must use bytes formatting strings')
 for arg in args:
 if not isinstance(arg, bytes):
-raise ValueError('must use bytes for arguments')
+raise ValueError(b'must use bytes for arguments')
 for label in labels:
 if not isinstance(label, bytes):
-raise ValueError('must use bytes for labels')
+raise ValueError(b'must use bytes for labels')
 # Formatting string must be ASCII.
 formatting = formatting.decode(r'ascii', r'replace').encode(r'ascii')
 # Arguments must be UTF-8.
 atomdicts.append(atom)
 payload = b''.join(cborutil.streamencode(atomdicts))
 if len(payload) > maxframesize:
-raise ValueError('cannot encode data in a single frame')
+raise ValueError(b'cannot encode data in a single frame')
 yield stream.makeframe(
 requestid=requestid,
 typeid=FRAME_TYPE_TEXT_OUTPUT,
 flags=0,
 """Decoder for the "identity" stream encoding profile."""
 def __init__(self, ui, extraobjs):
 if extraobjs:
 raise error.Abort(
-_('identity decoder received unexpected ' 'additional values')
+_(b'identity decoder received unexpected ' b'additional values')
 )
 def decode(self, data):
 return data
 def __init__(self, ui, extraobjs):
 import zlib
 if extraobjs:
 raise error.Abort(
-_('zlib decoder received unexpected ' 'additional values')
+_(b'zlib decoder received unexpected ' b'additional values')
 )
 self._decompressor = zlib.decompressobj()
 def decode(self, data):
 class zstd8mbdecoder(zstdbasedecoder):
 def __init__(self, ui, extraobjs):
 if extraobjs:
 raise error.Abort(
-_('zstd8mb decoder received unexpected ' 'additional values')
+_(b'zstd8mb decoder received unexpected ' b'additional values')
 )
 super(zstd8mbdecoder, self).__init__(maxwindowsize=8 * 1048576)
 Receives the stream profile name and any additional CBOR objects
 decoded from the stream encoding settings frame payloads.
 """
 if name not in STREAM_ENCODERS:
-raise error.Abort(_('unknown stream decoder: %s') % name)
+raise error.Abort(_(b'unknown stream decoder: %s') % name)
 self._decoder = STREAM_ENCODERS[name][1](ui, extraobjs)
 def decode(self, data):
 # Default is identity decoder. We don't bother instantiating one
 """Set the encoder for this stream.
 Receives the stream profile name.
 """
 if name not in STREAM_ENCODERS:
-raise error.Abort(_('unknown stream encoder: %s') % name)
+raise error.Abort(_(b'unknown stream encoder: %s') % name)
 self._encoder = STREAM_ENCODERS[name][0](ui)
 self._encodername = name
 def encode(self, data):
 def ensureserverstream(stream):
 if stream.streamid % 2:
 raise error.ProgrammingError(
-'server should only write to even '
+b'server should only write to even '
-'numbered streams; %d is not even' % stream.streamid
+b'numbered streams; %d is not even' % stream.streamid
 )
 DEFAULT_PROTOCOL_SETTINGS = {
-'contentencodings': [b'identity'],
+b'contentencodings': [b'identity'],
 }
 class serverreactor(object):
 """Holds state of a server handling frame-based protocol requests.
 send those frames. This is useful for half-duplex transports where the
 sender cannot receive until all data has been transmitted.
 """
 self._ui = ui
 self._deferoutput = deferoutput
-self._state = 'initial'
+self._state = b'initial'
 self._nextoutgoingstreamid = 2
 self._bufferedframegens = []
 # stream id -> stream instance for all active streams from the client.
 self._incomingstreams = {}
 self._outgoingstreams = {}
 Returns a dict with an ``action`` key that details what action,
 if any, the consumer should take next.
 """
 if not frame.streamid % 2:
-self._state = 'errored'
+self._state = b'errored'
 return self._makeerrorresult(
-_('received frame with even numbered stream ID: %d')
+_(b'received frame with even numbered stream ID: %d')
 % frame.streamid
 )
 if frame.streamid not in self._incomingstreams:
 if not frame.streamflags & STREAM_FLAG_BEGIN_STREAM:
-self._state = 'errored'
+self._state = b'errored'
 return self._makeerrorresult(
 _(
-'received frame on unknown inactive stream without '
+b'received frame on unknown inactive stream without '
-'beginning of stream flag set'
+b'beginning of stream flag set'
 )
 )
 self._incomingstreams[frame.streamid] = inputstream(frame.streamid)
 if frame.streamflags & STREAM_FLAG_ENCODING_APPLIED:
 # TODO handle decoding frames
-self._state = 'errored'
+self._state = b'errored'
 raise error.ProgrammingError(
-'support for decoding stream payloads ' 'not yet implemented'
+b'support for decoding stream payloads ' b'not yet implemented'
 )
 if frame.streamflags & STREAM_FLAG_END_STREAM:
 del self._incomingstreams[frame.streamid]
 handlers = {
-'initial': self._onframeinitial,
+b'initial': self._onframeinitial,
-'protocol-settings-receiving': self._onframeprotocolsettings,
+b'protocol-settings-receiving': self._onframeprotocolsettings,
-'idle': self._onframeidle,
+b'idle': self._onframeidle,
-'command-receiving': self._onframecommandreceiving,
+b'command-receiving': self._onframecommandreceiving,
-'errored': self._onframeerrored,
+b'errored': self._onframeerrored,
 }
 meth = handlers.get(self._state)
 if not meth:
-raise error.ProgrammingError('unhandled state: %s' % self._state)
+raise error.ProgrammingError(b'unhandled state: %s' % self._state)
 return meth(frame)
 def oncommandresponsereadyobjects(self, stream, requestid, objs):
 """Signal that objects are ready to be sent to the client.
 except Exception as e:
 for frame in createerrorframe(
 stream,
 requestid,
-'%s' % stringutil.forcebytestr(e),
+b'%s' % stringutil.forcebytestr(e),
-errtype='server',
+errtype=b'server',
 ):
 yield frame
 break
 # Alternate location responses can only be the first and
 # only object in the output stream.
 if isinstance(o, wireprototypes.alternatelocationresponse):
 if emitted:
 raise error.ProgrammingError(
-'alternatelocationresponse seen after initial '
+b'alternatelocationresponse seen after initial '
-'output object'
+b'output object'
 )
 frame = stream.makestreamsettingsframe(requestid)
 if frame:
 yield frame
 emitted = True
 continue
 if alternatelocationsent:
 raise error.ProgrammingError(
-'object follows alternatelocationresponse'
+b'object follows alternatelocationresponse'
 )
 if not emitted:
 # Frame is optional.
 frame = stream.makestreamsettingsframe(requestid)
 for frame in emitter.send(chunk):
 yield frame
 except Exception as e:
 for frame in createerrorframe(
-stream, requestid, '%s' % e, errtype='server'
+stream, requestid, b'%s' % e, errtype=b'server'
 ):
 yield frame
 break
 completed.
 """
 # TODO should we do anything about in-flight commands?
 if not self._deferoutput or not self._bufferedframegens:
-return 'noop', {}
+return b'noop', {}
 # If we buffered all our responses, emit those.
 def makegen():
 for gen in self._bufferedframegens:
 for frame in gen:
 yield frame
-return 'sendframes', {'framegen': makegen(),}
+return b'sendframes', {b'framegen': makegen(),}
 def _handlesendframes(self, framegen):
 if self._deferoutput:
 self._bufferedframegens.append(framegen)
-return 'noop', {}
+return b'noop', {}
 else:
-return 'sendframes', {'framegen': framegen,}
+return b'sendframes', {b'framegen': framegen,}
 def onservererror(self, stream, requestid, msg):
 ensureserverstream(stream)
 def sendframes():
 for frame in createerrorframe(
-stream, requestid, msg, errtype='server'
+stream, requestid, msg, errtype=b'server'
 ):
 yield frame
 self._activecommands.remove(requestid)
 self._outgoingstreams[streamid] = s
 # Always use the *server's* preferred encoder over the client's,
 # as servers have more to lose from sub-optimal encoders being used.
 for name in STREAM_ENCODERS_ORDER:
-if name in self._sendersettings['contentencodings']:
+if name in self._sendersettings[b'contentencodings']:
 s.setencoder(self._ui, name)
 break
 return s
 def _makeerrorresult(self, msg):
-return 'error', {'message': msg,}
+return b'error', {b'message': msg,}
 def _makeruncommandresult(self, requestid):
 entry = self._receivingcommands[requestid]
-if not entry['requestdone']:
+if not entry[b'requestdone']:
-self._state = 'errored'
+self._state = b'errored'
 raise error.ProgrammingError(
-'should not be called without ' 'requestdone set'
+b'should not be called without ' b'requestdone set'
 )
 del self._receivingcommands[requestid]
 if self._receivingcommands:
-self._state = 'command-receiving'
+self._state = b'command-receiving'
 else:
-self._state = 'idle'
+self._state = b'idle'
 # Decode the payloads as CBOR.
-entry['payload'].seek(0)
+entry[b'payload'].seek(0)
-request = cborutil.decodeall(entry['payload'].getvalue())[0]
+request = cborutil.decodeall(entry[b'payload'].getvalue())[0]
 if b'name' not in request:
-self._state = 'errored'
+self._state = b'errored'
 return self._makeerrorresult(
-_('command request missing "name" field')
+_(b'command request missing "name" field')
 )
 if b'args' not in request:
 request[b'args'] = {}
 assert requestid not in self._activecommands
 self._activecommands.add(requestid)
 return (
-'runcommand',
+b'runcommand',
 {
-'requestid': requestid,
+b'requestid': requestid,
-'command': request[b'name'],
+b'command': request[b'name'],
-'args': request[b'args'],
+b'args': request[b'args'],
-'redirect': request.get(b'redirect'),
+b'redirect': request.get(b'redirect'),
-'data': entry['data'].getvalue() if entry['data'] else None,
+b'data': entry[b'data'].getvalue() if entry[b'data'] else None,
 },
 )
 def _makewantframeresult(self):
-return 'wantframe', {'state': self._state,}
+return b'wantframe', {b'state': self._state,}
 def _validatecommandrequestframe(self, frame):
 new = frame.flags & FLAG_COMMAND_REQUEST_NEW
 continuation = frame.flags & FLAG_COMMAND_REQUEST_CONTINUATION
 if new and continuation:
-self._state = 'errored'
+self._state = b'errored'
 return self._makeerrorresult(
 _(
-'received command request frame with both new and '
+b'received command request frame with both new and '
-'continuation flags set'
+b'continuation flags set'
 )
 )
 if not new and not continuation:
-self._state = 'errored'
+self._state = b'errored'
 return self._makeerrorresult(
 _(
-'received command request frame with neither new nor '
+b'received command request frame with neither new nor '
-'continuation flags set'
+b'continuation flags set'
 )
 )
 def _onframeinitial(self, frame):
 # Called when we receive a frame when in the "initial" state.
 if frame.typeid == FRAME_TYPE_SENDER_PROTOCOL_SETTINGS:
-self._state = 'protocol-settings-receiving'
+self._state = b'protocol-settings-receiving'
 self._protocolsettingsdecoder = cborutil.bufferingdecoder()
 return self._onframeprotocolsettings(frame)
 elif frame.typeid == FRAME_TYPE_COMMAND_REQUEST:
-self._state = 'idle'
+self._state = b'idle'
 return self._onframeidle(frame)
 else:
-self._state = 'errored'
+self._state = b'errored'
 return self._makeerrorresult(
 _(
-'expected sender protocol settings or command request '
+b'expected sender protocol settings or command request '
-'frame; got %d'
+b'frame; got %d'
 )
 % frame.typeid
 )
 def _onframeprotocolsettings(self, frame):
-assert self._state == 'protocol-settings-receiving'
+assert self._state == b'protocol-settings-receiving'
 assert self._protocolsettingsdecoder is not None
 if frame.typeid != FRAME_TYPE_SENDER_PROTOCOL_SETTINGS:
-self._state = 'errored'
+self._state = b'errored'
 return self._makeerrorresult(
-_('expected sender protocol settings frame; got %d')
+_(b'expected sender protocol settings frame; got %d')
 % frame.typeid
 )
 more = frame.flags & FLAG_SENDER_PROTOCOL_SETTINGS_CONTINUATION
 eos = frame.flags & FLAG_SENDER_PROTOCOL_SETTINGS_EOS
 if more and eos:
-self._state = 'errored'
+self._state = b'errored'
 return self._makeerrorresult(
 _(
-'sender protocol settings frame cannot have both '
+b'sender protocol settings frame cannot have both '
-'continuation and end of stream flags set'
+b'continuation and end of stream flags set'
 )
 )
 if not more and not eos:
-self._state = 'errored'
+self._state = b'errored'
 return self._makeerrorresult(
 _(
-'sender protocol settings frame must have continuation or '
+b'sender protocol settings frame must have continuation or '
-'end of stream flag set'
+b'end of stream flag set'
 )
 )
 # TODO establish limits for maximum amount of data that can be
 # buffered.
 try:
 self._protocolsettingsdecoder.decode(frame.payload)
 except Exception as e:
-self._state = 'errored'
+self._state = b'errored'
 return self._makeerrorresult(
-_('error decoding CBOR from sender protocol settings frame: %s')
+_(
+b'error decoding CBOR from sender protocol settings frame: %s'
+)
 % stringutil.forcebytestr(e)
 )
 if more:
 return self._makewantframeresult()
 decoded = self._protocolsettingsdecoder.getavailable()
 self._protocolsettingsdecoder = None
 if not decoded:
-self._state = 'errored'
+self._state = b'errored'
 return self._makeerrorresult(
-_('sender protocol settings frame did not contain CBOR data')
+_(b'sender protocol settings frame did not contain CBOR data')
 )
 elif len(decoded) > 1:
-self._state = 'errored'
+self._state = b'errored'
 return self._makeerrorresult(
 _(
-'sender protocol settings frame contained multiple CBOR '
+b'sender protocol settings frame contained multiple CBOR '
-'values'
+b'values'
 )
 )
 d = decoded[0]
 if b'contentencodings' in d:
-self._sendersettings['contentencodings'] = d[b'contentencodings']
+self._sendersettings[b'contentencodings'] = d[b'contentencodings']
-self._state = 'idle'
+self._state = b'idle'
 return self._makewantframeresult()
 def _onframeidle(self, frame):
 # The only frame type that should be received in this state is a
 # command request.
 if frame.typeid != FRAME_TYPE_COMMAND_REQUEST:
-self._state = 'errored'
+self._state = b'errored'
 return self._makeerrorresult(
-_('expected command request frame; got %d') % frame.typeid
+_(b'expected command request frame; got %d') % frame.typeid
 )
 res = self._validatecommandrequestframe(frame)
 if res:
 return res
 if frame.requestid in self._receivingcommands:
-self._state = 'errored'
+self._state = b'errored'
 return self._makeerrorresult(
-_('request with ID %d already received') % frame.requestid
+_(b'request with ID %d already received') % frame.requestid
 )
 if frame.requestid in self._activecommands:
-self._state = 'errored'
+self._state = b'errored'
 return self._makeerrorresult(
-_('request with ID %d is already active') % frame.requestid
+_(b'request with ID %d is already active') % frame.requestid
 )
 new = frame.flags & FLAG_COMMAND_REQUEST_NEW
 moreframes = frame.flags & FLAG_COMMAND_REQUEST_MORE_FRAMES
 expectingdata = frame.flags & FLAG_COMMAND_REQUEST_EXPECT_DATA
 if not new:
-self._state = 'errored'
+self._state = b'errored'
 return self._makeerrorresult(
-_('received command request frame without new flag set')
+_(b'received command request frame without new flag set')
 )
 payload = util.bytesio()
 payload.write(frame.payload)
 self._receivingcommands[frame.requestid] = {
-'payload': payload,
+b'payload': payload,
-'data': None,
+b'data': None,
-'requestdone': not moreframes,
+b'requestdone': not moreframes,
-'expectingdata': bool(expectingdata),
+b'expectingdata': bool(expectingdata),
 }
 # This is the final frame for this request. Dispatch it.
 if not moreframes and not expectingdata:
 return self._makeruncommandresult(frame.requestid)
 assert moreframes or expectingdata
-self._state = 'command-receiving'
+self._state = b'command-receiving'
 return self._makewantframeresult()
 def _onframecommandreceiving(self, frame):
 if frame.typeid == FRAME_TYPE_COMMAND_REQUEST:
 # Process new command requests as such.
 return res
 # All other frames should be related to a command that is currently
 # receiving but is not active.
 if frame.requestid in self._activecommands:
-self._state = 'errored'
+self._state = b'errored'
 return self._makeerrorresult(
-_('received frame for request that is still active: %d')
+_(b'received frame for request that is still active: %d')
 % frame.requestid
 )
 if frame.requestid not in self._receivingcommands:
-self._state = 'errored'
+self._state = b'errored'
 return self._makeerrorresult(
-_('received frame for request that is not receiving: %d')
+_(b'received frame for request that is not receiving: %d')
 % frame.requestid
 )
 entry = self._receivingcommands[frame.requestid]
 if frame.typeid == FRAME_TYPE_COMMAND_REQUEST:
 moreframes = frame.flags & FLAG_COMMAND_REQUEST_MORE_FRAMES
 expectingdata = bool(frame.flags & FLAG_COMMAND_REQUEST_EXPECT_DATA)
-if entry['requestdone']:
+if entry[b'requestdone']:
-self._state = 'errored'
+self._state = b'errored'
 return self._makeerrorresult(
 _(
-'received command request frame when request frames '
+b'received command request frame when request frames '
-'were supposedly done'
+b'were supposedly done'
 )
 )
-if expectingdata != entry['expectingdata']:
+if expectingdata != entry[b'expectingdata']:
-self._state = 'errored'
+self._state = b'errored'
 return self._makeerrorresult(
-_('mismatch between expect data flag and previous frame')
+_(b'mismatch between expect data flag and previous frame')
 )
-entry['payload'].write(frame.payload)
+entry[b'payload'].write(frame.payload)
 if not moreframes:
-entry['requestdone'] = True
+entry[b'requestdone'] = True
 if not moreframes and not expectingdata:
 return self._makeruncommandresult(frame.requestid)
 return self._makewantframeresult()
 elif frame.typeid == FRAME_TYPE_COMMAND_DATA:
-if not entry['expectingdata']:
+if not entry[b'expectingdata']:
-self._state = 'errored'
+self._state = b'errored'
 return self._makeerrorresult(
 _(
-'received command data frame for request that is not '
+b'received command data frame for request that is not '
-'expecting data: %d'
+b'expecting data: %d'
 )
 % frame.requestid
 )
-if entry['data'] is None:
+if entry[b'data'] is None:
-entry['data'] = util.bytesio()
+entry[b'data'] = util.bytesio()
 return self._handlecommanddataframe(frame, entry)
 else:
-self._state = 'errored'
+self._state = b'errored'
 return self._makeerrorresult(
-_('received unexpected frame type: %d') % frame.typeid
+_(b'received unexpected frame type: %d') % frame.typeid
 )
 def _handlecommanddataframe(self, frame, entry):
 assert frame.typeid == FRAME_TYPE_COMMAND_DATA
 # TODO support streaming data instead of buffering it.
-entry['data'].write(frame.payload)
+entry[b'data'].write(frame.payload)
 if frame.flags & FLAG_COMMAND_DATA_CONTINUATION:
 return self._makewantframeresult()
 elif frame.flags & FLAG_COMMAND_DATA_EOS:
-entry['data'].seek(0)
+entry[b'data'].seek(0)
 return self._makeruncommandresult(frame.requestid)
 else:
-self._state = 'errored'
+self._state = b'errored'
 return self._makeerrorresult(
-_('command data frame without ' 'flags')
+_(b'command data frame without ' b'flags')
 )
 def _onframeerrored(self, frame):
-return self._makeerrorresult(_('server already errored'))
+return self._makeerrorresult(_(b'server already errored'))
 class commandrequest(object):
 """Represents a request to run a command."""
 self.requestid = requestid
 self.name = name
 self.args = args
 self.datafh = datafh
 self.redirect = redirect
-self.state = 'pending'
+self.state = b'pending'
 class clientreactor(object):
 """Holds state of a client issuing frame-based protocol requests.
 and an optional file object containing the raw data for the command.
 Returns a 3-tuple of (request, action, action data).
 """
 if not self._canissuecommands:
-raise error.ProgrammingError('cannot issue new commands')
+raise error.ProgrammingError(b'cannot issue new commands')
 requestid = self._nextrequestid
 self._nextrequestid += 2
 request = commandrequest(
 requestid, name, args, datafh=datafh, redirect=redirect
 )
 if self._buffersends:
 self._pendingrequests.append(request)
-return request, 'noop', {}
+return request, b'noop', {}
 else:
 if not self._cansend:
 raise error.ProgrammingError(
-'sends cannot be performed on ' 'this instance'
+b'sends cannot be performed on ' b'this instance'
 )
 if not self._hasmultiplesend:
 self._cansend = False
 self._canissuecommands = False
 return (
 request,
-'sendframes',
+b'sendframes',
-{'framegen': self._makecommandframes(request),},
+{b'framegen': self._makecommandframes(request),},
 )
 def flushcommands(self):
 """Request that all queued commands be sent.
 If instances aren't configured for multiple sends, no new command
 requests are allowed after this is called.
 """
 if not self._pendingrequests:
-return 'noop', {}
+return b'noop', {}
 if not self._cansend:
 raise error.ProgrammingError(
-'sends cannot be performed on this ' 'instance'
+b'sends cannot be performed on this ' b'instance'
 )
 # If the instance only allows sending once, mark that we have fired
 # our one shot.
 if not self._hasmultiplesend:
 while self._pendingrequests:
 request = self._pendingrequests.popleft()
 for frame in self._makecommandframes(request):
 yield frame
-return 'sendframes', {'framegen': makeframes(),}
+return b'sendframes', {b'framegen': makeframes(),}
 def _makecommandframes(self, request):
 """Emit frames to issue a command request.
 As a side-effect, update request accounting to reflect its changed
 state.
 """
 self._activerequests[request.requestid] = request
-request.state = 'sending'
+request.state = b'sending'
 if not self._protocolsettingssent and self._clientcontentencoders:
 self._protocolsettingssent = True
 payload = b''.join(
 )
 for frame in res:
 yield frame
-request.state = 'sent'
+request.state = b'sent'
 def onframerecv(self, frame):
 """Process a frame that has been received off the wire.
 Returns a 2-tuple of (action, meta) describing further action the
 caller needs to take as a result of receiving this frame.
 """
 if frame.streamid % 2:
 return (
-'error',
+b'error',
 {
-'message': (
+b'message': (
-_('received frame with odd numbered stream ID: %d')
+_(b'received frame with odd numbered stream ID: %d')
 % frame.streamid
 ),
 },
 )
 if frame.streamid not in self._incomingstreams:
 if not frame.streamflags & STREAM_FLAG_BEGIN_STREAM:
 return (
-'error',
+b'error',
 {
-'message': _(
+b'message': _(
-'received frame on unknown stream '
+b'received frame on unknown stream '
-'without beginning of stream flag set'
+b'without beginning of stream flag set'
 ),
 },
 )
 self._incomingstreams[frame.streamid] = inputstream(frame.streamid)
 if frame.typeid == FRAME_TYPE_STREAM_SETTINGS:
 return self._onstreamsettingsframe(frame)
 if frame.requestid not in self._activerequests:
 return (
-'error',
+b'error',
 {
-'message': (
+b'message': (
-_('received frame for inactive request ID: %d')
+_(b'received frame for inactive request ID: %d')
 % frame.requestid
 ),
 },
 )
 request = self._activerequests[frame.requestid]
-request.state = 'receiving'
+request.state = b'receiving'
 handlers = {
 FRAME_TYPE_COMMAND_RESPONSE: self._oncommandresponseframe,
 FRAME_TYPE_ERROR_RESPONSE: self._onerrorresponseframe,
 }
 meth = handlers.get(frame.typeid)
 if not meth:
 raise error.ProgrammingError(
-'unhandled frame type: %d' % frame.typeid
+b'unhandled frame type: %d' % frame.typeid
 )
 return meth(request, frame)
 def _onstreamsettingsframe(self, frame):
 more = frame.flags & FLAG_STREAM_ENCODING_SETTINGS_CONTINUATION
 eos = frame.flags & FLAG_STREAM_ENCODING_SETTINGS_EOS
 if more and eos:
 return (
-'error',
+b'error',
 {
-'message': (
+b'message': (
 _(
-'stream encoding settings frame cannot have both '
+b'stream encoding settings frame cannot have both '
-'continuation and end of stream flags set'
+b'continuation and end of stream flags set'
 )
 ),
 },
 )
 if not more and not eos:
 return (
-'error',
+b'error',
 {
-'message': _(
+b'message': _(
-'stream encoding settings frame must have '
+b'stream encoding settings frame must have '
-'continuation or end of stream flag set'
+b'continuation or end of stream flag set'
 ),
 },
 )
 if frame.streamid not in self._streamsettingsdecoders:
 try:
 decoder.decode(frame.payload)
 except Exception as e:
 return (
-'error',
+b'error',
 {
-'message': (
+b'message': (
 _(
-'error decoding CBOR from stream encoding '
+b'error decoding CBOR from stream encoding '
-'settings frame: %s'
+b'settings frame: %s'
 )
 % stringutil.forcebytestr(e)
 ),
 },
 )
 if more:
-return 'noop', {}
+return b'noop', {}
 assert eos
 decoded = decoder.getavailable()
 del self._streamsettingsdecoders[frame.streamid]
 if not decoded:
 return (
-'error',
+b'error',
 {
-'message': _(
+b'message': _(
-'stream encoding settings frame did not contain '
+b'stream encoding settings frame did not contain '
-'CBOR data'
+b'CBOR data'
 ),
 },
 )
 try:
 self._incomingstreams[frame.streamid].setdecoder(
 self._ui, decoded[0], decoded[1:]
 )
 except Exception as e:
 return (
-'error',
+b'error',
 {
-'message': (
+b'message': (
-_('error setting stream decoder: %s')
+_(b'error setting stream decoder: %s')
 % stringutil.forcebytestr(e)
 ),
 },
 )
-return 'noop', {}
+return b'noop', {}
 def _oncommandresponseframe(self, request, frame):
 if frame.flags & FLAG_COMMAND_RESPONSE_EOS:
-request.state = 'received'
+request.state = b'received'
 del self._activerequests[request.requestid]
 return (
-'responsedata',
+b'responsedata',
 {
-'request': request,
+b'request': request,
-'expectmore': frame.flags & FLAG_COMMAND_RESPONSE_CONTINUATION,
+b'expectmore': frame.flags & FLAG_COMMAND_RESPONSE_CONTINUATION,
-'eos': frame.flags & FLAG_COMMAND_RESPONSE_EOS,
+b'eos': frame.flags & FLAG_COMMAND_RESPONSE_EOS,
-'data': frame.payload,
+b'data': frame.payload,
 },
 )
 def _onerrorresponseframe(self, request, frame):
-request.state = 'errored'
+request.state = b'errored'
 del self._activerequests[request.requestid]
 # The payload should be a CBOR map.
 m = cborutil.decodeall(frame.payload)[0]
 return (
-'error',
+b'error',
-{'request': request, 'type': m['type'], 'message': m['message'],},
+{
+b'request': request,
+b'type': m[b'type'],
+b'message': m[b'message'],
+},
 )

changeset 43077	687b865b95ad
parent 43076	2372284d9457
child 43089	c59eb1560c44