( )⚙ D2900 wireproto: use named arguments when passing around frame data

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2900

wireproto: use named arguments when passing around frame data
ClosedPublic

Authored by indygreg on Mar 19 2018, 5:41 PM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHGfe4c944f95bb: wireproto: use named arguments when passing around frame data
Summary

Named arguments is easier to reason about compared to positional
arguments. Especially when you have many positional arguments.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

indygreg created this revision.Mar 19 2018, 5:41 PM
durin42 accepted this revision.Mar 21 2018, 9:33 PM
This revision is now accepted and ready to land.Mar 21 2018, 9:33 PM
Closed by commit rHGfe4c944f95bb: wireproto: use named arguments when passing around frame data (authored by indygreg). · Explain WhyMar 21 2018, 9:41 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/wireprotoframing.py (41 lines)

Diff 7132

mercurial/wireprotoframing.py

class frame(object): class frame(object):
"""Represents a parsed frame.""" """Represents a parsed frame."""
requestid = attr.ib() requestid = attr.ib()
typeid = attr.ib() typeid = attr.ib()
flags = attr.ib() flags = attr.ib()
payload = attr.ib() payload = attr.ib()
def makeframe(requestid, frametype, frameflags, payload): def makeframe(requestid, typeid, flags, payload):
"""Assemble a frame into a byte array.""" """Assemble a frame into a byte array."""
# TODO assert size of payload. # TODO assert size of payload.
frame = bytearray(FRAME_HEADER_SIZE + len(payload)) frame = bytearray(FRAME_HEADER_SIZE + len(payload))
# 24 bits length # 24 bits length
# 16 bits request id # 16 bits request id
# 4 bits type # 4 bits type
# 4 bits flags # 4 bits flags
l = struct.pack(r'<I', len(payload)) l = struct.pack(r'<I', len(payload))
frame[0:3] = l[0:3] frame[0:3] = l[0:3]
struct.pack_into(r'<H', frame, 3, requestid) struct.pack_into(r'<H', frame, 3, requestid)
frame[5] = (frametype << 4) | frameflags frame[5] = (typeid << 4) | flags
frame[6:] = payload frame[6:] = payload
return frame return frame
def makeframefromhumanstring(s): def makeframefromhumanstring(s):
"""Create a frame from a human readable string """Create a frame from a human readable string
Strings have the form: Strings have the form:
for flag in frameflags.split(b'|'): for flag in frameflags.split(b'|'):
if flag in validflags: if flag in validflags:
finalflags |= validflags[flag] finalflags |= validflags[flag]
else: else:
finalflags |= int(flag) finalflags |= int(flag)
payload = util.unescapestr(payload) payload = util.unescapestr(payload)
return makeframe(requestid, frametype, finalflags, payload) return makeframe(requestid=requestid, typeid=frametype,
flags=finalflags, payload=payload)
def parseheader(data): def parseheader(data):
"""Parse a unified framing protocol frame header from a buffer. """Parse a unified framing protocol frame header from a buffer.
The header is expected to be in the buffer at offset 0 and the The header is expected to be in the buffer at offset 0 and the
buffer is expected to be large enough to hold a full header. buffer is expected to be large enough to hold a full header.
""" """
# 24 bits payload length (little endian) # 24 bits payload length (little endian)
if args: if args:
flags |= FLAG_COMMAND_NAME_HAVE_ARGS flags |= FLAG_COMMAND_NAME_HAVE_ARGS
if datafh: if datafh:
flags |= FLAG_COMMAND_NAME_HAVE_DATA flags |= FLAG_COMMAND_NAME_HAVE_DATA
if not flags: if not flags:
flags |= FLAG_COMMAND_NAME_EOS flags |= FLAG_COMMAND_NAME_EOS
yield makeframe(requestid, FRAME_TYPE_COMMAND_NAME, flags, cmd) yield makeframe(requestid=requestid, typeid=FRAME_TYPE_COMMAND_NAME,
flags=flags, payload=cmd)
for i, k in enumerate(sorted(args)): for i, k in enumerate(sorted(args)):
v = args[k] v = args[k]
last = i == len(args) - 1 last = i == len(args) - 1
# TODO handle splitting of argument values across frames. # TODO handle splitting of argument values across frames.
payload = bytearray(ARGUMENT_FRAME_HEADER.size + len(k) + len(v)) payload = bytearray(ARGUMENT_FRAME_HEADER.size + len(k) + len(v))
offset = 0 offset = 0
ARGUMENT_FRAME_HEADER.pack_into(payload, offset, len(k), len(v)) ARGUMENT_FRAME_HEADER.pack_into(payload, offset, len(k), len(v))
offset += ARGUMENT_FRAME_HEADER.size offset += ARGUMENT_FRAME_HEADER.size
payload[offset:offset + len(k)] = k payload[offset:offset + len(k)] = k
offset += len(k) offset += len(k)
payload[offset:offset + len(v)] = v payload[offset:offset + len(v)] = v
flags = FLAG_COMMAND_ARGUMENT_EOA if last else 0 flags = FLAG_COMMAND_ARGUMENT_EOA if last else 0
yield makeframe(requestid, FRAME_TYPE_COMMAND_ARGUMENT, flags, payload) yield makeframe(requestid=requestid,
typeid=FRAME_TYPE_COMMAND_ARGUMENT,
flags=flags,
payload=payload)
if datafh: if datafh:
while True: while True:
data = datafh.read(DEFAULT_MAX_FRAME_SIZE) data = datafh.read(DEFAULT_MAX_FRAME_SIZE)
done = False done = False
if len(data) == DEFAULT_MAX_FRAME_SIZE: if len(data) == DEFAULT_MAX_FRAME_SIZE:
flags = FLAG_COMMAND_DATA_CONTINUATION flags = FLAG_COMMAND_DATA_CONTINUATION
else: else:
flags = FLAG_COMMAND_DATA_EOS flags = FLAG_COMMAND_DATA_EOS
assert datafh.read(1) == b'' assert datafh.read(1) == b''
done = True done = True
yield makeframe(requestid, FRAME_TYPE_COMMAND_DATA, flags, data) yield makeframe(requestid=requestid,
typeid=FRAME_TYPE_COMMAND_DATA,
flags=flags,
payload=data)
if done: if done:
break break
def createbytesresponseframesfrombytes(requestid, data, def createbytesresponseframesfrombytes(requestid, data,
maxframesize=DEFAULT_MAX_FRAME_SIZE): maxframesize=DEFAULT_MAX_FRAME_SIZE):
"""Create a raw frame to send a bytes response from static bytes input. """Create a raw frame to send a bytes response from static bytes input.
Returns a generator of bytearrays. Returns a generator of bytearrays.
""" """
# Simple case of a single frame. # Simple case of a single frame.
if len(data) <= maxframesize: if len(data) <= maxframesize:
yield makeframe(requestid, FRAME_TYPE_BYTES_RESPONSE, yield makeframe(requestid=requestid,
FLAG_BYTES_RESPONSE_EOS, data) typeid=FRAME_TYPE_BYTES_RESPONSE,
flags=FLAG_BYTES_RESPONSE_EOS,
payload=data)
return return
offset = 0 offset = 0
while True: while True:
chunk = data[offset:offset + maxframesize] chunk = data[offset:offset + maxframesize]
offset += len(chunk) offset += len(chunk)
done = offset == len(data) done = offset == len(data)
if done: if done:
flags = FLAG_BYTES_RESPONSE_EOS flags = FLAG_BYTES_RESPONSE_EOS
else: else:
flags = FLAG_BYTES_RESPONSE_CONTINUATION flags = FLAG_BYTES_RESPONSE_CONTINUATION
yield makeframe(requestid, FRAME_TYPE_BYTES_RESPONSE, flags, chunk) yield makeframe(requestid=requestid,
typeid=FRAME_TYPE_BYTES_RESPONSE,
flags=flags,
payload=chunk)
if done: if done:
break break
def createerrorframe(requestid, msg, protocol=False, application=False): def createerrorframe(requestid, msg, protocol=False, application=False):
# TODO properly handle frame size limits. # TODO properly handle frame size limits.
assert len(msg) <= DEFAULT_MAX_FRAME_SIZE assert len(msg) <= DEFAULT_MAX_FRAME_SIZE
flags = 0 flags = 0
if protocol: if protocol:
flags |= FLAG_ERROR_RESPONSE_PROTOCOL flags |= FLAG_ERROR_RESPONSE_PROTOCOL
if application: if application:
flags |= FLAG_ERROR_RESPONSE_APPLICATION flags |= FLAG_ERROR_RESPONSE_APPLICATION
yield makeframe(requestid, FRAME_TYPE_ERROR_RESPONSE, flags, msg) yield makeframe(requestid=requestid,
typeid=FRAME_TYPE_ERROR_RESPONSE,
flags=flags,
payload=msg)
def createtextoutputframe(requestid, atoms): def createtextoutputframe(requestid, atoms):
"""Create a text output frame to render text to people. """Create a text output frame to render text to people.
``atoms`` is a 3-tuple of (formatting string, args, labels). ``atoms`` is a 3-tuple of (formatting string, args, labels).
The formatting string contains ``%s`` tokens to be replaced by the The formatting string contains ``%s`` tokens to be replaced by the
corresponding indexed entry in ``args``. ``labels`` is an iterable of corresponding indexed entry in ``args``. ``labels`` is an iterable of
atom = b''.join(chunks) atom = b''.join(chunks)
atomchunks.append(atom) atomchunks.append(atom)
bytesleft -= len(atom) bytesleft -= len(atom)
if bytesleft < 0: if bytesleft < 0:
raise ValueError('cannot encode data in a single frame') raise ValueError('cannot encode data in a single frame')
yield makeframe(requestid, FRAME_TYPE_TEXT_OUTPUT, 0, b''.join(atomchunks)) yield makeframe(requestid=requestid,
typeid=FRAME_TYPE_TEXT_OUTPUT,
flags=0,
payload=b''.join(atomchunks))
class serverreactor(object): class serverreactor(object):
"""Holds state of a server handling frame-based protocol requests. """Holds state of a server handling frame-based protocol requests.
This class is the "brain" of the unified frame-based protocol server This class is the "brain" of the unified frame-based protocol server
component. While the protocol is stateless from the perspective of component. While the protocol is stateless from the perspective of
requests/commands, something needs to track which frames have been requests/commands, something needs to track which frames have been
received, what frames to expect, etc. This class is that thing. received, what frames to expect, etc. This class is that thing.