comparison mercurial/wireprotoframing.py @ 37062:fe4c944f95bb

wireproto: use named arguments when passing around frame data

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

Differential Revision: https://phab.mercurial-scm.org/D2900

37061:884a0c1604ad

    requestid = attr.ib()
    typeid = attr.ib()
    flags = attr.ib()
    payload = attr.ib()

def makeframe(requestid, frametype, frameflags, payload):
    """Assemble a frame into a byte array."""
    # TODO assert size of payload.
    frame = bytearray(FRAME_HEADER_SIZE + len(payload))

    # 24 bits length

    # 4 bits flags

    l = struct.pack(r'<I', len(payload))
    frame[0:3] = l[0:3]
    struct.pack_into(r'<H', frame, 3, requestid)
    frame[5] = (frametype << 4) | frameflags
    frame[6:] = payload

    return frame

def makeframefromhumanstring(s):

        else:
            finalflags |= int(flag)

    payload = util.unescapestr(payload)

    return makeframe(requestid, frametype, finalflags, payload)

def parseheader(data):
    """Parse a unified framing protocol frame header from a buffer.

    The header is expected to be in the buffer at offset 0 and the

        flags |= FLAG_COMMAND_NAME_HAVE_DATA

    if not flags:
        flags |= FLAG_COMMAND_NAME_EOS

    yield makeframe(requestid, FRAME_TYPE_COMMAND_NAME, flags, cmd)

    for i, k in enumerate(sorted(args)):
        v = args[k]
        last = i == len(args) - 1

        payload[offset:offset + len(k)] = k
        offset += len(k)
        payload[offset:offset + len(v)] = v

        flags = FLAG_COMMAND_ARGUMENT_EOA if last else 0
        yield makeframe(requestid, FRAME_TYPE_COMMAND_ARGUMENT, flags, payload)

    if datafh:
        while True:
            data = datafh.read(DEFAULT_MAX_FRAME_SIZE)

            else:
                flags = FLAG_COMMAND_DATA_EOS
                assert datafh.read(1) == b''
                done = True

            yield makeframe(requestid, FRAME_TYPE_COMMAND_DATA, flags, data)

            if done:
                break

def createbytesresponseframesfrombytes(requestid, data,

    Returns a generator of bytearrays.
    """

    # Simple case of a single frame.
    if len(data) <= maxframesize:
        yield makeframe(requestid, FRAME_TYPE_BYTES_RESPONSE,
                        FLAG_BYTES_RESPONSE_EOS, data)
        return

    offset = 0
    while True:
        chunk = data[offset:offset + maxframesize]

        if done:
            flags = FLAG_BYTES_RESPONSE_EOS
        else:
            flags = FLAG_BYTES_RESPONSE_CONTINUATION

        yield makeframe(requestid, FRAME_TYPE_BYTES_RESPONSE, flags, chunk)

        if done:
            break

def createerrorframe(requestid, msg, protocol=False, application=False):

    if protocol:
        flags |= FLAG_ERROR_RESPONSE_PROTOCOL
    if application:
        flags |= FLAG_ERROR_RESPONSE_APPLICATION

    yield makeframe(requestid, FRAME_TYPE_ERROR_RESPONSE, flags, msg)

def createtextoutputframe(requestid, atoms):
    """Create a text output frame to render text to people.

    ``atoms`` is a 3-tuple of (formatting string, args, labels).

        bytesleft -= len(atom)

    if bytesleft < 0:
        raise ValueError('cannot encode data in a single frame')

    yield makeframe(requestid, FRAME_TYPE_TEXT_OUTPUT, 0, b''.join(atomchunks))

class serverreactor(object):
    """Holds state of a server handling frame-based protocol requests.

    This class is the "brain" of the unified frame-based protocol server

37062:fe4c944f95bb

    requestid = attr.ib()
    typeid = attr.ib()
    flags = attr.ib()
    payload = attr.ib()

def makeframe(requestid, typeid, flags, payload):
    """Assemble a frame into a byte array."""
    # TODO assert size of payload.
    frame = bytearray(FRAME_HEADER_SIZE + len(payload))

    # 24 bits length

    # 4 bits flags

    l = struct.pack(r'<I', len(payload))
    frame[0:3] = l[0:3]
    struct.pack_into(r'<H', frame, 3, requestid)
    frame[5] = (typeid << 4) | flags
    frame[6:] = payload

    return frame

def makeframefromhumanstring(s):

        else:
            finalflags |= int(flag)

    payload = util.unescapestr(payload)

    return makeframe(requestid=requestid, typeid=frametype,
                     flags=finalflags, payload=payload)

def parseheader(data):
    """Parse a unified framing protocol frame header from a buffer.

    The header is expected to be in the buffer at offset 0 and the

        flags |= FLAG_COMMAND_NAME_HAVE_DATA

    if not flags:
        flags |= FLAG_COMMAND_NAME_EOS

    yield makeframe(requestid=requestid, typeid=FRAME_TYPE_COMMAND_NAME,
                    flags=flags, payload=cmd)

    for i, k in enumerate(sorted(args)):
        v = args[k]
        last = i == len(args) - 1

        payload[offset:offset + len(k)] = k
        offset += len(k)
        payload[offset:offset + len(v)] = v

        flags = FLAG_COMMAND_ARGUMENT_EOA if last else 0
        yield makeframe(requestid=requestid,
                        typeid=FRAME_TYPE_COMMAND_ARGUMENT,
                        flags=flags,
                        payload=payload)

    if datafh:
        while True:
            data = datafh.read(DEFAULT_MAX_FRAME_SIZE)

            else:
                flags = FLAG_COMMAND_DATA_EOS
                assert datafh.read(1) == b''
                done = True

            yield makeframe(requestid=requestid,
                            typeid=FRAME_TYPE_COMMAND_DATA,
                            flags=flags,
                            payload=data)

            if done:
                break

def createbytesresponseframesfrombytes(requestid, data,

    Returns a generator of bytearrays.
    """

    # Simple case of a single frame.
    if len(data) <= maxframesize:
        yield makeframe(requestid=requestid,
                        typeid=FRAME_TYPE_BYTES_RESPONSE,
                        flags=FLAG_BYTES_RESPONSE_EOS,
                        payload=data)
        return

    offset = 0
    while True:
        chunk = data[offset:offset + maxframesize]

        if done:
            flags = FLAG_BYTES_RESPONSE_EOS
        else:
            flags = FLAG_BYTES_RESPONSE_CONTINUATION

        yield makeframe(requestid=requestid,
                        typeid=FRAME_TYPE_BYTES_RESPONSE,
                        flags=flags,
                        payload=chunk)

        if done:
            break

def createerrorframe(requestid, msg, protocol=False, application=False):

    if protocol:
        flags |= FLAG_ERROR_RESPONSE_PROTOCOL
    if application:
        flags |= FLAG_ERROR_RESPONSE_APPLICATION

    yield makeframe(requestid=requestid,
                    typeid=FRAME_TYPE_ERROR_RESPONSE,
                    flags=flags,
                    payload=msg)

def createtextoutputframe(requestid, atoms):
    """Create a text output frame to render text to people.

    ``atoms`` is a 3-tuple of (formatting string, args, labels).

        bytesleft -= len(atom)

    if bytesleft < 0:
        raise ValueError('cannot encode data in a single frame')

    yield makeframe(requestid=requestid,
                    typeid=FRAME_TYPE_TEXT_OUTPUT,
                    flags=0,
                    payload=b''.join(atomchunks))

class serverreactor(object):
    """Holds state of a server handling frame-based protocol requests.

    This class is the "brain" of the unified frame-based protocol server