/brz/remove-bazaar

client and server.

"""

 

import collections

import struct

import sys

import time

 

    debug,

    errors,

    osutils,

    )

 

 

# Protocol version strings.  These are sent as prefixes of bzr requests and

# responses to identify the protocol version being used. (There are no version

# one strings because that version doesn't send any).

 

RESPONSE_VERSION_THREE = REQUEST_VERSION_THREE = MESSAGE_VERSION_THREE

 

 

 

 

def _decode_tuple(req_line):

        return None

        raise errors.SmartProtocolError("request %r not terminated" % req_line)

 

 

def _encode_tuple(args):

    """Encode the tuple args to a bytestream."""

 

 

class Requester(object):

    # support multiple chunks?

    def _encode_bulk_data(self, body):

        """Encode body as a bulk data chunk."""

 

    def _serialise_offsets(self, offsets):

        """Serialise a readv offset list."""

        txt = []

        for start, length in offsets:

 

 

class SmartServerRequestProtocolOne(SmartProtocolBase):

        self._backing_transport = backing_transport

        self._root_client_path = root_client_path

        self._jail_root = jail_root

        self._finished = False

        self._has_dispatched = False

        self.request = None

        self._body_decoder = None

        self._write_func = write_func

 

        """Take bytes, and advance the internal state machine appropriately.

 

        """

        if not self._has_dispatched:

                # no command line yet

                return

            self._has_dispatched = True

            try:

                req_args = _decode_tuple(first_line)

                self.request = request.SmartServerRequestHandler(

                    self._backing_transport, commands=request.request_handlers,

                if self.request.finished_reading:

                    # trivial request

                    self.unused_data = self.in_buffer

                    self._send_response(self.request.response)

            except KeyboardInterrupt:

                raise

                protocol_error = errors.SmartProtocolError(

                    "bad request %r" % (err.verb,))

                failure = request.FailedSmartServerResponse(

                self._send_response(failure)

                return

                # everything else: pass to client, flush, and quit

                log_exception_quietly()

                self._send_response(request.FailedSmartServerResponse(

                return

 

        if self._has_dispatched:

                # nothing to do.XXX: this routine should be a single state

                # machine too.

                self.unused_data += self.in_buffer

                return

            if self._body_decoder is None:

                self._body_decoder = LengthPrefixedBodyDecoder()

            if self.request.response is not None:

                self._send_response(self.request.response)

                self.unused_data = self.in_buffer

            else:

                if self.request.finished_reading:

                    raise AssertionError(

    def _write_success_or_failure_prefix(self, response):

        """Write the protocol specific success/failure prefix."""

        if response.is_successful():

        else:

 

    def _write_protocol_version(self):

        r"""Write any prefixes this protocol requires.

        self._write_success_or_failure_prefix(response)

        self._write_func(_encode_tuple(response.args))

        if response.body is not None:

            if not (response.body_stream is None):

                raise AssertionError(

                    'body_stream and body cannot both be set')

        elif response.body_stream is not None:

            _send_stream(response.body_stream, self._write_func)

 

 

def _send_stream(stream, write_func):

    _send_chunks(stream, write_func)

 

 

def _send_chunks(stream, write_func):

    for chunk in stream:

        elif isinstance(chunk, request.FailedSmartServerResponse):

            _send_chunks(chunk.args, write_func)

            return

        else:

        self.finished_reading = False

        self._in_buffer_list = []

        self._in_buffer_len = 0

        self.bytes_left = None

        self._number_needed_bytes = None

 

    def _get_in_buffer(self):

        if len(self._in_buffer_list) == 1:

            return self._in_buffer_list[0]

        if len(in_buffer) != self._in_buffer_len:

            raise AssertionError(

                "Length of buffer did not match expected value: %s != %s"

                #     _NeedMoreBytes).

                current_state = self.state_accept

                self.state_accept()

            self._number_needed_bytes = e.count

 

 

 

    def _extract_line(self):

        in_buf = self._get_in_buffer()

        if pos == -1:

            # We haven't read a complete line yet, so request more bytes before

            # we continue.

 

    def _state_accept_expecting_header(self):

        prefix = self._extract_line()

            self.state_accept = self._state_accept_expecting_length

        else:

            raise errors.SmartProtocolError(

 

    def _state_accept_expecting_length(self):

        prefix = self._extract_line()

            self.error = True

            self.error_in_progress = []

            self._state_accept_expecting_length()

            return

            # We've read the end-of-body marker.

            # Any further bytes are unused data, including the bytes left in

            # the _in_buffer.

            return

        else:

            self.bytes_left = int(prefix, 16)

            self.state_accept = self._state_accept_reading_chunk

 

    def _state_accept_reading_chunk(self):

        _StatefulDecoder.__init__(self)

        self.state_accept = self._state_accept_expecting_length

        self.state_read = self._state_read_no_data

 

    def next_read_size(self):

        if self.bytes_left is not None:

 

    def _state_accept_expecting_length(self):

        in_buf = self._get_in_buffer()

        if pos == -1:

            return

        self.bytes_left = int(in_buf[:pos])

        self._set_in_buffer(None)

        # TODO: what if the trailer does not match "done\n"?  Should this raise

        # a ProtocolViolation exception?

            self.state_accept = self._state_accept_reading_unused

            self.finished_reading = True

 

        self._set_in_buffer(None)

 

    def _state_read_no_data(self):

 

    def _state_read_body_buffer(self):

        result = self._body

        return result

 

 

        """Make a remote call with a readv array.

 

        The body is encoded with one line per readv offset pair. The numbers in

        """

        if 'hpss' in debug.debug_flags:

            mutter('hpss call w/readv: %s', repr(args)[1:-1])

        # returned in response to existing version 1 smart requests.  Responses

        # starting with these codes are always "failed" responses.

        v1_error_codes = [

            ]

        if result_tuple[0] in v1_error_codes:

            self._request.finished_reading()

        :param verb: The verb used in that call.

        :raises: UnexpectedSmartServerResponse

        """

            # The response will have no body, so we've finished reading.

            self._request.finished_reading()

            raise errors.UnknownSmartMethod(self._last_verb)

 

        while not _body_decoder.finished_reading:

            bytes = self._request.read_bytes(_body_decoder.next_read_size())

                # end of file encountered reading from server

                raise errors.ConnectionReset(

                    "Connection lost while reading response body.")

            _body_decoder.accept_bytes(bytes)

        self._request.finished_reading()

        # XXX: TODO check the trailer result.

        if 'hpss' in debug.debug_flags:

            mutter('              %d body bytes read',

 

    def query_version(self):

        """Return protocol version number of the server."""

        resp = self.read_response_tuple()

            return 1

            return 2

        else:

            raise errors.SmartProtocolError("bad response %r" % (resp,))

        response_status = self._request.read_line()

        result = SmartClientRequestProtocolOne._read_response_tuple(self)

        self._response_is_unknown_method(result)

            self.response_status = True

            if not expect_body:

                self._request.finished_reading()

            return result

            self.response_status = False

            self._request.finished_reading()

            raise errors.ErrorFromSmartServer(result)

        _body_decoder = ChunkedBodyDecoder()

        while not _body_decoder.finished_reading:

            bytes = self._request.read_bytes(_body_decoder.next_read_size())

                # end of file encountered reading from server

                raise errors.ConnectionReset(

                    "Connection lost while reading streamed body.")

            _body_decoder.accept_bytes(bytes)

            for body_bytes in iter(_body_decoder.read_next_chunk, None):

                    mutter('              %d byte chunk read',

                           len(body_bytes))

                yield body_bytes

            _StatefulDecoder.accept_bytes(self, bytes)

        except KeyboardInterrupt:

            raise

            # We do *not* set self.decoding_failed here.  The message handler

            # has raised an error, but the decoder is still able to parse bytes

            # and determine when this message ends.

            # exception has interrupted the loop that runs the state machine.

            # So we call accept_bytes again to restart it.

            self.accept_bytes('')

            # The decoder itself has raised an exception.  We cannot continue

            # decoding.

            self.decoding_failed = True

            # The buffer is empty

            raise _NeedMoreBytes(1)

        in_buf = self._get_in_buffer()

        self._set_in_buffer(in_buf[1:])

        return one_byte

 

 

    def _state_accept_expecting_headers(self):

        decoded = self._extract_prefixed_bencoded_data()

            raise errors.SmartProtocolError(

                'Header object %r is not a dict' % (decoded,))

        self.state_accept = self._state_accept_expecting_message_part

 

    def _state_accept_expecting_message_part(self):

        message_part_kind = self._extract_single_byte()

            self.state_accept = self._state_accept_expecting_one_byte

            self.state_accept = self._state_accept_expecting_structure

            self.state_accept = self._state_accept_expecting_bytes

            self.done()

        else:

            raise errors.SmartProtocolError(

        self._real_write_func = write_func

 

    def _write_func(self, bytes):

        # TODO: Another possibility would be to turn this into an async model.

        #       Where we let another thread know that we have some bytes if

        #       they want it, but we don't actually block for it

 

    def flush(self):

        if self._buf:

            del self._buf[:]

            self._buf_len = 0

 

        """Serialise a readv offset list."""

        txt = []

        for start, length in offsets:

 

    def _write_protocol_version(self):

        self._write_func(MESSAGE_VERSION_THREE)

        self._write_prefixed_bencode(headers)

 

    def _write_structure(self, args):

        utf8_args = []

        for arg in args:

                utf8_args.append(arg.encode('utf8'))

            else:

                utf8_args.append(arg)

        self._write_prefixed_bencode(utf8_args)

 

    def _write_end(self):

        self.flush()

 

    def _write_prefixed_body(self, bytes):

        self._write_func(struct.pack('!L', len(bytes)))

        self._write_func(bytes)

 

    def _write_chunked_body_start(self):

 

    def _write_error_status(self):

 

    def _write_success_status(self):

 

 

class ProtocolThreeResponder(_ProtocolThreeEncoder):

    def __init__(self, write_func):

        _ProtocolThreeEncoder.__init__(self, write_func)

        self.response_sent = False

        if 'hpss' in debug.debug_flags:

            self._response_start_time = None

 

    def _trace(self, action, message, extra_bytes=None, include_time=False):

                % (exception,))

        if isinstance(exception, errors.UnknownSmartMethod):

            failure = request.FailedSmartServerResponse(