mercurial/wireprotoframing.py

39445:cdb56f295b03

import struct

from .i18n import _
from .thirdparty import (
    attr,
    cbor,
)
from . import (
    encoding,
    error,
    util,
)
from .utils import (
    stringutil,
)

FRAME_HEADER_SIZE = 8
DEFAULT_MAX_FRAME_SIZE = 32768

            finalflags |= validflags[flag]
        else:
            finalflags |= int(flag)

    if payload.startswith(b'cbor:'):
        payload = cbor.dumps(stringutil.evalpythonliteral(payload[5:]),
                             canonical=True)

    else:
        payload = stringutil.unescapestr(payload)

    return makeframe(requestid=requestid, streamid=streamid,

    """
    data = {b'name': cmd}
    if args:
        data[b'args'] = args

    data = cbor.dumps(data, canonical=True)

    offset = 0

    while True:
        flags = 0

    """Create a raw frame to send a bytes response from static bytes input.

    Returns a generator of bytearrays.
    """
    # Automatically send the overall CBOR response map.
    overall = cbor.dumps({b'status': b'ok'}, canonical=True)
    if len(overall) > maxframesize:
        raise error.ProgrammingError('not yet implemented')

    # Simple case where we can fit the full response in a single frame.
    if len(overall) + len(data) <= maxframesize:

        if done:
            break

def createbytesresponseframesfromgen(stream, requestid, gen,
                                     maxframesize=DEFAULT_MAX_FRAME_SIZE):
    overall = cbor.dumps({b'status': b'ok'}, canonical=True)

    yield stream.makeframe(requestid=requestid,
                           typeid=FRAME_TYPE_COMMAND_RESPONSE,
                           flags=FLAG_COMMAND_RESPONSE_CONTINUATION,
                           payload=overall)

    }

    if args:
        m[b'error'][b'args'] = args

    overall = cbor.dumps(m, canonical=True)

    yield stream.makeframe(requestid=requestid,
                           typeid=FRAME_TYPE_COMMAND_RESPONSE,
                           flags=FLAG_COMMAND_RESPONSE_EOS,
                           payload=overall)

def createerrorframe(stream, requestid, msg, errtype):
    # TODO properly handle frame size limits.
    assert len(msg) <= DEFAULT_MAX_FRAME_SIZE

    payload = cbor.dumps({
        b'type': errtype,
        b'message': [{b'msg': msg}],
    }, canonical=True)

    yield stream.makeframe(requestid=requestid,
                           typeid=FRAME_TYPE_ERROR_RESPONSE,
                           flags=0,
                           payload=payload)

        if labels:
            atom[b'labels'] = labels

        atomdicts.append(atom)

    payload = cbor.dumps(atomdicts, canonical=True)

    if len(payload) > maxframesize:
        raise ValueError('cannot encode data in a single frame')

    yield stream.makeframe(requestid=requestid,

        else:
            self._state = 'idle'

        # Decode the payloads as CBOR.
        entry['payload'].seek(0)
        request = cbor.load(entry['payload'])

        if b'name' not in request:
            self._state = 'errored'
            return self._makeerrorresult(
                _('command request missing "name" field'))

    def _onerrorresponseframe(self, request, frame):
        request.state = 'errored'
        del self._activerequests[request.requestid]

        # The payload should be a CBOR map.
        m = cbor.loads(frame.payload)

        return 'error', {
            'request': request,
            'type': m['type'],
            'message': m['message'],

39446:36f487a332ad

import struct

from .i18n import _
from .thirdparty import (
    attr,
)
from . import (
    encoding,
    error,
    util,
)
from .utils import (
    cborutil,
    stringutil,
)

FRAME_HEADER_SIZE = 8
DEFAULT_MAX_FRAME_SIZE = 32768

            finalflags |= validflags[flag]
        else:
            finalflags |= int(flag)

    if payload.startswith(b'cbor:'):
        payload = b''.join(cborutil.streamencode(
            stringutil.evalpythonliteral(payload[5:])))

    else:
        payload = stringutil.unescapestr(payload)

    return makeframe(requestid=requestid, streamid=streamid,

    """
    data = {b'name': cmd}
    if args:
        data[b'args'] = args

    data = b''.join(cborutil.streamencode(data))

    offset = 0

    while True:
        flags = 0

    """Create a raw frame to send a bytes response from static bytes input.

    Returns a generator of bytearrays.
    """
    # Automatically send the overall CBOR response map.
    overall = b''.join(cborutil.streamencode({b'status': b'ok'}))
    if len(overall) > maxframesize:
        raise error.ProgrammingError('not yet implemented')

    # Simple case where we can fit the full response in a single frame.
    if len(overall) + len(data) <= maxframesize:

        if done:
            break

def createbytesresponseframesfromgen(stream, requestid, gen,
                                     maxframesize=DEFAULT_MAX_FRAME_SIZE):
    overall = b''.join(cborutil.streamencode({b'status': b'ok'}))

    yield stream.makeframe(requestid=requestid,
                           typeid=FRAME_TYPE_COMMAND_RESPONSE,
                           flags=FLAG_COMMAND_RESPONSE_CONTINUATION,
                           payload=overall)

    }

    if args:
        m[b'error'][b'args'] = args

    overall = b''.join(cborutil.streamencode(m))

    yield stream.makeframe(requestid=requestid,
                           typeid=FRAME_TYPE_COMMAND_RESPONSE,
                           flags=FLAG_COMMAND_RESPONSE_EOS,
                           payload=overall)

def createerrorframe(stream, requestid, msg, errtype):
    # TODO properly handle frame size limits.
    assert len(msg) <= DEFAULT_MAX_FRAME_SIZE

    payload = b''.join(cborutil.streamencode({
        b'type': errtype,
        b'message': [{b'msg': msg}],
    }))

    yield stream.makeframe(requestid=requestid,
                           typeid=FRAME_TYPE_ERROR_RESPONSE,
                           flags=0,
                           payload=payload)

        if labels:
            atom[b'labels'] = labels

        atomdicts.append(atom)

    payload = b''.join(cborutil.streamencode(atomdicts))

    if len(payload) > maxframesize:
        raise ValueError('cannot encode data in a single frame')

    yield stream.makeframe(requestid=requestid,

        else:
            self._state = 'idle'

        # Decode the payloads as CBOR.
        entry['payload'].seek(0)
        request = cborutil.decodeall(entry['payload'].getvalue())[0]

        if b'name' not in request:
            self._state = 'errored'
            return self._makeerrorresult(
                _('command request missing "name" field'))

    def _onerrorresponseframe(self, request, frame):
        request.state = 'errored'
        del self._activerequests[request.requestid]

        # The payload should be a CBOR map.
        m = cborutil.decodeall(frame.payload)[0]

        return 'error', {
            'request': request,
            'type': m['type'],
            'message': m['message'],