/brz/remove-bazaar

# Copyright (C) 2005-2012, 2016 Canonical Ltd

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

"""Transport is an abstraction layer to handle file access.

The abstraction is to allow access from the local filesystem, as well

as remote (such as http or sftp).

Transports are constructed from a string, being a URL or (as a degenerate

case) a local filesystem path.  This is typically the top directory of

a bzrdir, repository, or similar object we are interested in working with.

The Transport returned has methods to read, write and manipulate files within

it.

"""

from __future__ import absolute_import

import errno

import sys

from ..lazy_import import lazy_import

lazy_import(globals(), """

from stat import S_ISDIR

from breezy import (

    errors,

    osutils,

    ui,

    urlutils,

    )

""")

from ..sixish import (

    BytesIO,

    PY3,

    string_types,

    )

from ..trace import (

    mutter,

    )

from .. import (

    hooks,

    registry,

    )

# a dictionary of open file streams. Keys are absolute paths, values are

# transport defined.

_file_streams = {}

def _get_protocol_handlers():

    """Return a dictionary of {urlprefix: [factory]}"""

    return transport_list_registry

def _set_protocol_handlers(new_handlers):

    """Replace the current protocol handlers dictionary.

    WARNING this will remove all build in protocols. Use with care.

    """

    global transport_list_registry

    transport_list_registry = new_handlers

def _clear_protocol_handlers():

    global transport_list_registry

    transport_list_registry = TransportListRegistry()

def _get_transport_modules():

    """Return a list of the modules providing transports."""

    modules = set()

    for prefix, factory_list in transport_list_registry.items():

        for factory in factory_list:

            modules.add(factory.get_module())

    # Add chroot and pathfilter directly, because there is no handler

    # registered for it.

    modules.add('breezy.transport.chroot')

    modules.add('breezy.transport.pathfilter')

    result = sorted(modules)

    return result

class TransportListRegistry(registry.Registry):

    """A registry which simplifies tracking available Transports.

    A registration of a new protocol requires two steps:

    1) register the prefix with the function register_transport( )

    2) register the protocol provider with the function

    register_transport_provider( ) ( and the "lazy" variant )

    This is needed because:

    a) a single provider can support multiple protocols (like the ftp

    provider which supports both the ftp:// and the aftp:// protocols)

    b) a single protocol can have multiple providers (like the http://

    protocol which was supported by both the urllib and pycurl providers)

    """

    def register_transport_provider(self, key, obj):

        self.get(key).insert(0, registry._ObjectGetter(obj))

    def register_lazy_transport_provider(self, key, module_name, member_name):

        self.get(key).insert(0,

                registry._LazyObjectGetter(module_name, member_name))

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

        self.register(key, [], help)

transport_list_registry = TransportListRegistry()

def register_transport_proto(prefix, help=None, info=None,

                             register_netloc=False):

    transport_list_registry.register_transport(prefix, help)

    if register_netloc:

        if not prefix.endswith('://'):

            raise ValueError(prefix)

        register_urlparse_netloc_protocol(prefix[:-3])

def register_lazy_transport(prefix, module, classname):

    if not prefix in transport_list_registry:

        register_transport_proto(prefix)

    transport_list_registry.register_lazy_transport_provider(

        prefix, module, classname)

def register_transport(prefix, klass):

    if not prefix in transport_list_registry:

        register_transport_proto(prefix)

    transport_list_registry.register_transport_provider(prefix, klass)

def register_urlparse_netloc_protocol(protocol):

    """Ensure that protocol is setup to be used with urlparse netloc parsing."""

    if protocol not in urlutils.urlparse.uses_netloc:

        urlutils.urlparse.uses_netloc.append(protocol)

def _unregister_urlparse_netloc_protocol(protocol):

    """Remove protocol from urlparse netloc parsing.

    Except for tests, you should never use that function. Using it with 'http',

    for example, will break all http transports.

    """

    if protocol in urlutils.urlparse.uses_netloc:

        urlutils.urlparse.uses_netloc.remove(protocol)

def unregister_transport(scheme, factory):

    """Unregister a transport."""

    l = transport_list_registry.get(scheme)

    for i in l:

        o = i.get_obj( )

        if o == factory:

            transport_list_registry.get(scheme).remove(i)

            break

    if len(l) == 0:

        transport_list_registry.remove(scheme)

class _CoalescedOffset(object):

    """A data container for keeping track of coalesced offsets."""

    __slots__ = ['start', 'length', 'ranges']

    def __init__(self, start, length, ranges):

        self.start = start

        self.length = length

        self.ranges = ranges

    def __cmp__(self, other):

        return cmp((self.start, self.length, self.ranges),

                   (other.start, other.length, other.ranges))

    def __repr__(self):

        return '%s(%r, %r, %r)' % (self.__class__.__name__,

            self.start, self.length, self.ranges)

class LateReadError(object):

    """A helper for transports which pretends to be a readable file.

    When read() is called, errors.ReadError is raised.

    """

    def __init__(self, path):

        self._path = path

    def close(self):

        """a no-op - do nothing."""

    def _fail(self):

        """Raise ReadError."""

        raise errors.ReadError(self._path)

    def __iter__(self):

        self._fail()

    def read(self, count=-1):

        self._fail()

    def readlines(self):

        self._fail()

class FileStream(object):

    """Base class for FileStreams."""

    def __init__(self, transport, relpath):

        """Create a FileStream for relpath on transport."""

        self.transport = transport

        self.relpath = relpath

    def _close(self):

        """A hook point for subclasses that need to take action on close."""

    def close(self, want_fdatasync=False):

        if want_fdatasync:

            try:

                self.fdatasync()

            except errors.TransportNotPossible:

                pass

        self._close()

        del _file_streams[self.transport.abspath(self.relpath)]

    def fdatasync(self):

        """Force data out to physical disk if possible.

        :raises TransportNotPossible: If this transport has no way to 

            flush to disk.

        """

        raise errors.TransportNotPossible(

            "%s cannot fdatasync" % (self.transport,))

class FileFileStream(FileStream):

    """A file stream object returned by open_write_stream.

    This version uses a file like object to perform writes.

    """

    def __init__(self, transport, relpath, file_handle):

        FileStream.__init__(self, transport, relpath)

        self.file_handle = file_handle

    def _close(self):

        self.file_handle.close()

    def fdatasync(self):

        """Force data out to physical disk if possible."""

        self.file_handle.flush()

        try:

            fileno = self.file_handle.fileno()

        except AttributeError:

            raise errors.TransportNotPossible()

        osutils.fdatasync(fileno)

    def write(self, bytes):

        osutils.pump_string_file(bytes, self.file_handle)

class AppendBasedFileStream(FileStream):

    """A file stream object returned by open_write_stream.

    This version uses append on a transport to perform writes.

    """

    def write(self, bytes):

        self.transport.append_bytes(self.relpath, bytes)

class TransportHooks(hooks.Hooks):

    """Mapping of hook names to registered callbacks for transport hooks"""

    def __init__(self):

        super(TransportHooks, self).__init__()

        self.add_hook("post_connect",

            "Called after a new connection is established or a reconnect "

            "occurs. The sole argument passed is either the connected "

            "transport or smart medium instance.", (2, 5))

class Transport(object):

    """This class encapsulates methods for retrieving or putting a file

    from/to a storage location.

    Most functions have a _multi variant, which allows you to queue up

    multiple requests. They generally have a dumb base implementation

    which just iterates over the arguments, but smart Transport

    implementations can do pipelining.

    In general implementations should support having a generator or a list

    as an argument (ie always iterate, never index)

    :ivar base: Base URL for the transport; should always end in a slash.

    """

    # implementations can override this if it is more efficient

    # for them to combine larger read chunks together

    _max_readv_combine = 50

    # It is better to read this much more data in order, rather

    # than doing another seek. Even for the local filesystem,

    # there is a benefit in just reading.

    # TODO: jam 20060714 Do some real benchmarking to figure out

    #       where the biggest benefit between combining reads and

    #       and seeking is. Consider a runtime auto-tune.

    _bytes_to_read_before_seek = 0

    hooks = TransportHooks()

    def __init__(self, base):

        super(Transport, self).__init__()

        self.base = base

        (self._raw_base, self._segment_parameters) = (

            urlutils.split_segment_parameters(base))

    def _translate_error(self, e, path, raise_generic=True):

        """Translate an IOError or OSError into an appropriate bzr error.

        This handles things like ENOENT, ENOTDIR, EEXIST, and EACCESS

        """

        if getattr(e, 'errno', None) is not None:

            if e.errno in (errno.ENOENT, errno.ENOTDIR):

                raise errors.NoSuchFile(path, extra=e)

            elif e.errno == errno.EINVAL:

                mutter("EINVAL returned on path %s: %r" % (path, e))

                raise errors.NoSuchFile(path, extra=e)

            # I would rather use errno.EFOO, but there doesn't seem to be

            # any matching for 267

            # This is the error when doing a listdir on a file:

            # WindowsError: [Errno 267] The directory name is invalid

            if sys.platform == 'win32' and e.errno in (errno.ESRCH, 267):

                raise errors.NoSuchFile(path, extra=e)

            if e.errno == errno.EEXIST:

                raise errors.FileExists(path, extra=e)

            if e.errno == errno.EACCES:

                raise errors.PermissionDenied(path, extra=e)

            if e.errno == errno.ENOTEMPTY:

                raise errors.DirectoryNotEmpty(path, extra=e)

            if e.errno == errno.EBUSY:

                raise errors.ResourceBusy(path, extra=e)

        if raise_generic:

            raise errors.TransportError(orig_error=e)

    def clone(self, offset=None):

        """Return a new Transport object, cloned from the current location,

        using a subdirectory or parent directory. This allows connections

        to be pooled, rather than a new one needed for each subdir.

        """

        raise NotImplementedError(self.clone)

    def create_prefix(self, mode=None):

        """Create all the directories leading down to self.base."""

        cur_transport = self

        needed = [cur_transport]

        # Recurse upwards until we can create a directory successfully

        while True:

            new_transport = cur_transport.clone('..')

            if new_transport.base == cur_transport.base:

                raise errors.BzrCommandError(

                    "Failed to create path prefix for %s."

                    % cur_transport.base)

            try:

                new_transport.mkdir('.', mode=mode)

            except errors.NoSuchFile:

                needed.append(new_transport)

                cur_transport = new_transport

            except errors.FileExists:

                break

            else:

                break

        # Now we only need to create child directories

        while needed:

            cur_transport = needed.pop()

            cur_transport.ensure_base(mode=mode)

    def ensure_base(self, mode=None):

        """Ensure that the directory this transport references exists.

        This will create a directory if it doesn't exist.

        :return: True if the directory was created, False otherwise.

        """

        # The default implementation just uses "Easier to ask for forgiveness

        # than permission". We attempt to create the directory, and just

        # suppress FileExists and PermissionDenied (for Windows) exceptions.

        try:

            self.mkdir('.', mode=mode)

        except (errors.FileExists, errors.PermissionDenied):

            return False

        else:

            return True

    def external_url(self):

        """Return a URL for self that can be given to an external process.

        There is no guarantee that the URL can be accessed from a different

        machine - e.g. file:/// urls are only usable on the local machine,

        sftp:/// urls when the server is only bound to localhost are only

        usable from localhost etc.

        NOTE: This method may remove security wrappers (e.g. on chroot

        transports) and thus should *only* be used when the result will not

        be used to obtain a new transport within breezy. Ideally chroot

        transports would know enough to cause the external url to be the exact

        one used that caused the chrooting in the first place, but that is not

        currently the case.

        :return: A URL that can be given to another process.

        :raises InProcessTransport: If the transport is one that cannot be

            accessed out of the current process (e.g. a MemoryTransport)

            then InProcessTransport is raised.

        """

        raise NotImplementedError(self.external_url)

    def get_segment_parameters(self):

        """Return the segment parameters for the top segment of the URL.

        """

        return self._segment_parameters

    def set_segment_parameter(self, name, value):

        """Set a segment parameter.

        :param name: Segment parameter name (urlencoded string)

        :param value: Segment parameter value (urlencoded string)

        """

        if value is None:

            try:

                del self._segment_parameters[name]

            except KeyError:

                pass

        else:

            self._segment_parameters[name] = value

        self.base = urlutils.join_segment_parameters(

            self._raw_base, self._segment_parameters)

    def _pump(self, from_file, to_file):

        """Most children will need to copy from one file-like

        object or string to another one.

        This just gives them something easy to call.

        """

        return osutils.pumpfile(from_file, to_file)

    def _get_total(self, multi):

        """Try to figure out how many entries are in multi,

        but if not possible, return None.

        """

        try:

            return len(multi)

        except TypeError: # We can't tell how many, because relpaths is a generator

            return None

    def _report_activity(self, bytes, direction):

        """Notify that this transport has activity.

        Implementations should call this from all methods that actually do IO.

        Be careful that it's not called twice, if one method is implemented on

        top of another.

        :param bytes: Number of bytes read or written.

        :param direction: 'read' or 'write' or None.

        """

        ui.ui_factory.report_transport_activity(self, bytes, direction)

    def _update_pb(self, pb, msg, count, total):

        """Update the progress bar based on the current count

        and total available, total may be None if it was

        not possible to determine.

        """

        if pb is None:

            return

        if total is None:

            pb.update(msg, count, count+1)

        else:

            pb.update(msg, count, total)

    def _iterate_over(self, multi, func, pb, msg, expand=True):

        """Iterate over all entries in multi, passing them to func,

        and update the progress bar as you go along.

        :param expand:  If True, the entries will be passed to the function

                        by expanding the tuple. If False, it will be passed

                        as a single parameter.

        """

        total = self._get_total(multi)

        result = []

        count = 0

        for entry in multi:

            self._update_pb(pb, msg, count, total)

            if expand:

                result.append(func(*entry))

            else:

                result.append(func(entry))

            count += 1

        return tuple(result)

    def abspath(self, relpath):

        """Return the full url to the given relative path.

        :param relpath: a string of a relative path

        """

        # XXX: Robert Collins 20051016 - is this really needed in the public

        # interface ?

        raise NotImplementedError(self.abspath)

    def recommended_page_size(self):

        """Return the recommended page size for this transport.

        This is potentially different for every path in a given namespace.

        For example, local transports might use an operating system call to

        get the block size for a given path, which can vary due to mount

        points.

        :return: The page size in bytes.

        """

        return 4 * 1024

    def relpath(self, abspath):

        """Return the local path portion from a given absolute path.

        This default implementation is not suitable for filesystems with

        aliasing, such as that given by symlinks, where a path may not

        start with our base, but still be a relpath once aliasing is

        resolved.

        """

        # TODO: This might want to use breezy.osutils.relpath

        #       but we have to watch out because of the prefix issues

        if not (abspath == self.base[:-1] or abspath.startswith(self.base)):

            raise errors.PathNotChild(abspath, self.base)

        pl = len(self.base)

        return abspath[pl:].strip('/')

    def local_abspath(self, relpath):

        """Return the absolute path on the local filesystem.

        This function will only be defined for Transports which have a

        physical local filesystem representation.

        :raises errors.NotLocalUrl: When no local path representation is

            available.

        """

        raise errors.NotLocalUrl(self.abspath(relpath))

    def has(self, relpath):

        """Does the file relpath exist?

        Note that some transports MAY allow querying on directories, but this

        is not part of the protocol.  In other words, the results of

        t.has("a_directory_name") are undefined.

        :rtype: bool

        """

        raise NotImplementedError(self.has)

    def has_multi(self, relpaths, pb=None):

        """Return True/False for each entry in relpaths"""

        total = self._get_total(relpaths)

        count = 0

        for relpath in relpaths:

            self._update_pb(pb, 'has', count, total)

            yield self.has(relpath)

            count += 1

    def has_any(self, relpaths):

        """Return True if any of the paths exist."""

        for relpath in relpaths:

            if self.has(relpath):

                return True

        return False

    def iter_files_recursive(self):

        """Iter the relative paths of files in the transports sub-tree.

        *NOTE*: This only lists *files*, not subdirectories!

        As with other listing functions, only some transports implement this,.

        you may check via listable() to determine if it will.

        """

        raise errors.TransportNotPossible("This transport has not "

                                          "implemented iter_files_recursive "

                                          "(but must claim to be listable "

                                          "to trigger this error).")

    def get(self, relpath):

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

        This may fail in a number of ways:

         - HTTP servers may return content for a directory. (unexpected

           content failure)

         - FTP servers may indicate NoSuchFile for a directory.

         - SFTP servers may give a file handle for a directory that will

           fail on read().

        For correct use of the interface, be sure to catch errors.PathError

        when calling it and catch errors.ReadError when reading from the

        returned object.

        :param relpath: The relative path to the file

        :rtype: File-like object.

        """

        raise NotImplementedError(self.get)

    def get_bytes(self, relpath):

        """Get a raw string of the bytes for a file at the given location.

        :param relpath: The relative path to the file

        """

        f = self.get(relpath)

        try:

            return f.read()

        finally:

            f.close()

    def get_smart_medium(self):

        """Return a smart client medium for this transport if possible.

        A smart medium doesn't imply the presence of a smart server: it implies

        that the smart protocol can be tunnelled via this transport.

        :raises NoSmartMedium: if no smart server medium is available.

        """

        raise errors.NoSmartMedium(self)

    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 accomodate

            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.

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

        """

        if not offsets:

            return

        fp = self.get(relpath)

        return self._seek_and_read(fp, offsets, relpath)

    def _seek_and_read(self, fp, offsets, relpath='<unknown>'):

        """An implementation of readv that uses fp.seek and fp.read.

        This uses _coalesce_offsets to issue larger reads and fewer seeks.

        :param fp: A file-like object that supports seek() and read(size).

            Note that implementations are allowed to call .close() on this file

            handle, so don't trust that you can use it for other work.

        :param offsets: A list of offsets to be read from the given file.

        :return: yield (pos, data) tuples for each request

        """

        # We are going to iterate multiple times, we need a list

        offsets = list(offsets)

        sorted_offsets = sorted(offsets)

        # turn the list of offsets into a stack

        offset_stack = iter(offsets)

        cur_offset_and_size = next(offset_stack)