/brz/remove-bazaar

    # Add chroot directly, because there is no handler registered for it.

        self.get(key).insert(0,

    def register_transport(self, key, help=None, default_port=None):

        self.register(key, [], help, default_port)

    def get_default_port(self, scheme):

        """Return the registered default port for this protocol scheme."""

        try:

            return self.get_info(scheme + '://')

        except LookupError:

            return None

 

 

transport_list_registry = TransportListRegistry()

 

 

def register_transport_proto(prefix, help=None, info=None, default_port=None):

    transport_list_registry.register_transport(prefix, help, default_port)

    def readv(self, relpath, offsets, adjust_for_latency=False,

        upper_limit=None):

        """Get parts of the file at the given relative path.

 

        :param relpath: The path to read data from.

        :param offsets: A list of (offset, size) tuples.

        :param adjust_for_latency: Adjust the requested offsets to accomdate

            transport latency. This may re-order the offsets, expand them to

            grab adjacent data when there is likely a high cost to requesting

            data relative to delivering it.

        :param upper_limit: When adjust_for_latency is True setting upper_limit

            allows the caller to tell the transport about the length of the

            file, so that requests are not issued for ranges beyond the end of

            the file. This matters because some servers and/or transports error

            in such a case rather than just satisfying the available ranges.

            upper_limit should always be provided when adjust_for_latency is

            True, and should be the size of the file in bytes.

        :return: A list or generator of (offset, data) tuples

        """

        if adjust_for_latency:

            # Design note: We may wish to have different algorithms for the

            # expansion of the offsets per-transport. E.g. for local disk to

            # use page-aligned expansion. If that is the case consider the following structure:

            #  - a test that transport.readv uses self._offset_expander or some similar attribute, to do the expansion

            #  - a test for each transport that it has some known-good offset expander

            #  - unit tests for each offset expander

            #  - a set of tests for the offset expander interface, giving

            #    baseline behaviour (which the current transport

            #    adjust_for_latency tests could be repurposed to).

            offsets = self._sort_expand_and_combine(offsets, upper_limit)

        return self._readv(relpath, offsets)

 

    def _readv(self, relpath, offsets):

        """Get parts of the file at the given relative path.

 

        :param relpath: The path to read.

        :param offsets: A list of (offset, size) tuples.

    def _sort_expand_and_combine(self, offsets, upper_limit):

        """Helper for readv.

 

        :param offsets: A readv vector - (offset, length) tuples.

        :param upper_limit: The highest byte offset that may be requested.

        :return: A readv vector that will read all the regions requested by

            offsets, in start-to-end order, with no duplicated regions,

            expanded by the transports recommended page size.

        """

        offsets = sorted(offsets)

        # short circuit empty requests

        if len(offsets) == 0:

            def empty_yielder():

                # Quick thunk to stop this function becoming a generator

                # itself, rather we return a generator that has nothing to

                # yield.

                if False:

                    yield None

            return empty_yielder()

        # expand by page size at either end

        maximum_expansion = self.recommended_page_size()

        new_offsets = []

        for offset, length in offsets:

            expansion = maximum_expansion - length

            if expansion < 0:

                # we're asking for more than the minimum read anyway.

                expansion = 0

            reduction = expansion / 2

            new_offset = offset - reduction

            new_length = length + expansion

            if new_offset < 0:

                # don't ask for anything < 0

                new_offset = 0

            if (upper_limit is not None and

                new_offset + new_length > upper_limit):

                new_length = upper_limit - new_offset

            new_offsets.append((new_offset, new_length))

        # combine the expanded offsets

        offsets = []

        current_offset, current_length = new_offsets[0]

        current_finish = current_length + current_offset

        for offset, length in new_offsets[1:]:

            finish = offset + length

            if offset > current_finish:

                # there is a gap, output the current accumulator and start

                # a new one for the region we're examining.

                offsets.append((current_offset, current_length))

                current_offset = offset

                current_length = length

                current_finish = finish

                continue

            if finish > current_finish:

                # extend the current accumulator to the end of the region

                # we're examining.

                current_finish = finish

                current_length = finish - current_offset

        offsets.append((current_offset, current_length))

        return offsets

 

        if port is None:

            # The port isn't explicitly specified, so return the default (if

            # there is one).

            port = transport_list_registry.get_default_port(scheme)

        if (port is not None and 

            port != transport_list_registry.get_default_port(scheme)):

            # Include the port in the netloc (unless it's the same as the

            # default, in which case we omit it as it is redundant).

# Note that sftp:// has no default_port, because the user's ~/.ssh/config

# can set it to arbitrary values based on hostname.

            default_port=80)

            default_port=443)

            default_port=80)

            default_port=443)

            help="Read-only access of branches exported on the web.",

            default_port=80)

            help="Read-only access of branches exported on the web using SSL.",

            default_port=443)

            help="Access using passive FTP.",

            default_port=21)

            help="Access using active FTP.",

            default_port=21)

 

# chroots cannot be implicitly accessed, they must be explicitly created:

register_transport_proto('trace+')

register_lazy_transport('trace+', 'bzrlib.transport.trace', 'TransportTraceDecorator')

 

            help="Fast access using the Bazaar smart server.",

            default_port=4155)

            default_port=80)

register_lazy_transport('bzr+http://',

                        'bzrlib.transport.remote',

                        'RemoteHTTPTransport')

register_transport_proto('bzr+https://',

#                help="Fast access using the Bazaar smart server over HTTPS."

register_lazy_transport('bzr+https://',

# Note that bzr+ssh:// has no default_port, because the user's ~/.ssh/config

# can set it to arbitrary values based on hostname.