~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005, 2006, 2007, 2008 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

"""BzrDir logic. The BzrDir is the basic control directory used by bzr.

At format 7 this was split out into Branch, Repository and Checkout control

directories.

Note: This module has a lot of ``open`` functions/methods that return

references to in-memory objects. As a rule, there are no matching ``close``

methods. To free any associated resources, simply stop referencing the

objects returned.

"""

# TODO: Move old formats into a plugin to make this file smaller.

from cStringIO import StringIO

import os

import sys

from bzrlib.lazy_import import lazy_import

lazy_import(globals(), """

from stat import S_ISDIR

import textwrap

from warnings import warn

import bzrlib

from bzrlib import (

    errors,

    graph,

    lockable_files,

    lockdir,

    osutils,

    registry,

    remote,

    revision as _mod_revision,

    symbol_versioning,

    ui,

    urlutils,

    versionedfile,

    win32utils,

    workingtree,

    workingtree_4,

    xml4,

    xml5,

    )

from bzrlib.osutils import (

    sha_strings,

    sha_string,

    )

from bzrlib.smart.client import _SmartClient

from bzrlib.smart import protocol

from bzrlib.store.versioned import WeaveStore

from bzrlib.transactions import WriteTransaction

from bzrlib.transport import (

    do_catching_redirections,

    get_transport,

    )

from bzrlib.weave import Weave

""")

from bzrlib.trace import (

    mutter,

    note,

    )

from bzrlib.transport.local import LocalTransport

from bzrlib.symbol_versioning import (

    deprecated_function,

    deprecated_method,

    )

class BzrDir(object):

    """A .bzr control diretory.

    BzrDir instances let you create or open any of the things that can be

    found within .bzr - checkouts, branches and repositories.

    :ivar transport:

        the transport which this bzr dir is rooted at (i.e. file:///.../.bzr/)

    :ivar root_transport:

        a transport connected to the directory this bzr was opened from

        (i.e. the parent directory holding the .bzr directory).

    Everything in the bzrdir should have the same file permissions.

    """

    def break_lock(self):

        """Invoke break_lock on the first object in the bzrdir.

        If there is a tree, the tree is opened and break_lock() called.

        Otherwise, branch is tried, and finally repository.

        """

        # XXX: This seems more like a UI function than something that really

        # belongs in this class.

        try:

            thing_to_unlock = self.open_workingtree()

        except (errors.NotLocalUrl, errors.NoWorkingTree):

            try:

                thing_to_unlock = self.open_branch()

            except errors.NotBranchError:

                try:

                    thing_to_unlock = self.open_repository()

                except errors.NoRepositoryPresent:

                    return

        thing_to_unlock.break_lock()

    def can_convert_format(self):

        """Return true if this bzrdir is one whose format we can convert from."""

        return True

    def check_conversion_target(self, target_format):

        target_repo_format = target_format.repository_format

        source_repo_format = self._format.repository_format

        source_repo_format.check_conversion_target(target_repo_format)

    @staticmethod

    def _check_supported(format, allow_unsupported,

        recommend_upgrade=True,

        basedir=None):

        """Give an error or warning on old formats.

        :param format: may be any kind of format - workingtree, branch, 

        or repository.

        :param allow_unsupported: If true, allow opening 

        formats that are strongly deprecated, and which may 

        have limited functionality.

        :param recommend_upgrade: If true (default), warn

        the user through the ui object that they may wish

        to upgrade the object.

        """

        # TODO: perhaps move this into a base Format class; it's not BzrDir

        # specific. mbp 20070323

        if not allow_unsupported and not format.is_supported():

            # see open_downlevel to open legacy branches.

            raise errors.UnsupportedFormatError(format=format)

        if recommend_upgrade \

            and getattr(format, 'upgrade_recommended', False):

            ui.ui_factory.recommend_upgrade(

                format.get_format_description(),

                basedir)

    def clone(self, url, revision_id=None, force_new_repo=False):

        """Clone this bzrdir and its contents to url verbatim.

        If url's last component does not exist, it will be created.

        if revision_id is not None, then the clone operation may tune

            itself to download less data.

        :param force_new_repo: Do not use a shared repository for the target 

                               even if one is available.

        """

        return self.clone_on_transport(get_transport(url),

                                       revision_id=revision_id,

                                       force_new_repo=force_new_repo)

    def clone_on_transport(self, transport, revision_id=None,

                           force_new_repo=False):

        """Clone this bzrdir and its contents to transport verbatim.

        If the target directory does not exist, it will be created.

        if revision_id is not None, then the clone operation may tune

            itself to download less data.

        :param force_new_repo: Do not use a shared repository for the target 

                               even if one is available.

        """

        transport.ensure_base()

        result = self.cloning_metadir().initialize_on_transport(transport)

        repository_policy = None

        try:

            local_repo = self.find_repository()

        except errors.NoRepositoryPresent:

            local_repo = None

        if local_repo:

            # may need to copy content in

            repository_policy = result.determine_repository_policy(

                force_new_repo)

            make_working_trees = local_repo.make_working_trees()

            result_repo = repository_policy.acquire_repository(

                make_working_trees, local_repo.is_shared())

            result_repo.fetch(local_repo, revision_id=revision_id)

        # 1 if there is a branch present

        #   make sure its content is available in the target repository

        #   clone it.

        try:

            local_branch = self.open_branch()

        except errors.NotBranchError:

            pass

        else:

            result_branch = local_branch.clone(result, revision_id=revision_id)

            if repository_policy is not None:

                repository_policy.configure_branch(result_branch)

        try:

            result_repo = result.find_repository()

        except errors.NoRepositoryPresent:

            result_repo = None

        if result_repo is None or result_repo.make_working_trees():

            try:

                self.open_workingtree().clone(result)

            except (errors.NoWorkingTree, errors.NotLocalUrl):

                pass

        return result

    # TODO: This should be given a Transport, and should chdir up; otherwise

    # this will open a new connection.

    def _make_tail(self, url):

        t = get_transport(url)

        t.ensure_base()

    @classmethod

    def create(cls, base, format=None, possible_transports=None):

        """Create a new BzrDir at the url 'base'.

        :param format: If supplied, the format of branch to create.  If not

            supplied, the default is used.

        :param possible_transports: If supplied, a list of transports that 

            can be reused to share a remote connection.

        """

        if cls is not BzrDir:

            raise AssertionError("BzrDir.create always creates the default"

                " format, not one of %r" % cls)

        t = get_transport(base, possible_transports)

        t.ensure_base()

        if format is None:

            format = BzrDirFormat.get_default_format()

        return format.initialize_on_transport(t)

    @staticmethod

    def find_bzrdirs(transport, evaluate=None, list_current=None):

        """Find bzrdirs recursively from current location.

        This is intended primarily as a building block for more sophisticated

        functionality, like finding trees under a directory, or finding

        branches that use a given repository.

        :param evaluate: An optional callable that yields recurse, value,

            where recurse controls whether this bzrdir is recursed into

            and value is the value to yield.  By default, all bzrdirs

            are recursed into, and the return value is the bzrdir.

        :param list_current: if supplied, use this function to list the current

            directory, instead of Transport.list_dir

        :return: a generator of found bzrdirs, or whatever evaluate returns.

        """

        if list_current is None:

            def list_current(transport):

                return transport.list_dir('')

        if evaluate is None:

            def evaluate(bzrdir):

                return True, bzrdir

        pending = [transport]

        while len(pending) > 0:

            current_transport = pending.pop()

            recurse = True

            try:

                bzrdir = BzrDir.open_from_transport(current_transport)

            except errors.NotBranchError:

                pass

            else:

                recurse, value = evaluate(bzrdir)

                yield value

            try:

                subdirs = list_current(current_transport)

            except errors.NoSuchFile:

                continue

            if recurse:

                for subdir in sorted(subdirs, reverse=True):

                    pending.append(current_transport.clone(subdir))

    @staticmethod

    def find_branches(transport):

        """Find all branches under a transport.

        This will find all branches below the transport, including branches

        inside other branches.  Where possible, it will use

        Repository.find_branches.

        To list all the branches that use a particular Repository, see

        Repository.find_branches

        """

        def evaluate(bzrdir):

            try:

                repository = bzrdir.open_repository()

            except errors.NoRepositoryPresent:

                pass

            else:

                return False, (None, repository)

            try:

                branch = bzrdir.open_branch()

            except errors.NotBranchError:

                return True, (None, None)

            else:

                return True, (branch, None)

        branches = []

        for branch, repo in BzrDir.find_bzrdirs(transport, evaluate=evaluate):

            if repo is not None:

                branches.extend(repo.find_branches())

            if branch is not None:

                branches.append(branch)

        return branches

    def destroy_repository(self):

        """Destroy the repository in this BzrDir"""

        raise NotImplementedError(self.destroy_repository)

    def create_branch(self):

        """Create a branch in this BzrDir.

        The bzrdir's format will control what branch format is created.

        For more control see BranchFormatXX.create(a_bzrdir).

        """

        raise NotImplementedError(self.create_branch)

    def destroy_branch(self):

        """Destroy the branch in this BzrDir"""

        raise NotImplementedError(self.destroy_branch)

    @staticmethod

    def create_branch_and_repo(base, force_new_repo=False, format=None):

        """Create a new BzrDir, Branch and Repository at the url 'base'.

        This will use the current default BzrDirFormat unless one is

        specified, and use whatever 

        repository format that that uses via bzrdir.create_branch and

        create_repository. If a shared repository is available that is used

        preferentially.

        The created Branch object is returned.

        :param base: The URL to create the branch at.

        :param force_new_repo: If True a new repository is always created.

        :param format: If supplied, the format of branch to create.  If not

            supplied, the default is used.

        """

        bzrdir = BzrDir.create(base, format)

        bzrdir._find_or_create_repository(force_new_repo)

        return bzrdir.create_branch()

    def determine_repository_policy(self, force_new_repo=False):

        """Return an object representing a policy to use.

        This controls whether a new repository is created, or a shared

        repository used instead.

        """

        def repository_policy(found_bzrdir):

            stop = False

            # does it have a repository ?

            try:

                repository = found_bzrdir.open_repository()

            except errors.NoRepositoryPresent:

                repository = None

            else:

                if ((found_bzrdir.root_transport.base !=

                     self.root_transport.base) and not repository.is_shared()):

                    repository = None

                else:

                    stop = True

            if not stop:

                return None, False

            if repository:

                return UseExistingRepository(repository), True

            else:

                return CreateRepository(self), True

        if not force_new_repo:

            policy = self._find_containing(repository_policy)

            if policy is not None:

                return policy

        return CreateRepository(self)

    def _find_or_create_repository(self, force_new_repo):

        """Create a new repository if needed, returning the repository."""

        policy = self.determine_repository_policy(force_new_repo)

        return policy.acquire_repository()

    @staticmethod

    def create_branch_convenience(base, force_new_repo=False,

                                  force_new_tree=None, format=None,

                                  possible_transports=None):

        """Create a new BzrDir, Branch and Repository at the url 'base'.

        This is a convenience function - it will use an existing repository

        if possible, can be told explicitly whether to create a working tree or

        not.

        This will use the current default BzrDirFormat unless one is

        specified, and use whatever 

        repository format that that uses via bzrdir.create_branch and

        create_repository. If a shared repository is available that is used

        preferentially. Whatever repository is used, its tree creation policy

        is followed.

        The created Branch object is returned.

        If a working tree cannot be made due to base not being a file:// url,

        no error is raised unless force_new_tree is True, in which case no 

        data is created on disk and NotLocalUrl is raised.

        :param base: The URL to create the branch at.

        :param force_new_repo: If True a new repository is always created.

        :param force_new_tree: If True or False force creation of a tree or 

                               prevent such creation respectively.

        :param format: Override for the bzrdir format to create.

        :param possible_transports: An optional reusable transports list.

        """

        if force_new_tree:

            # check for non local urls

            t = get_transport(base, possible_transports)

            if not isinstance(t, LocalTransport):

                raise errors.NotLocalUrl(base)

        bzrdir = BzrDir.create(base, format, possible_transports)

        repo = bzrdir._find_or_create_repository(force_new_repo)

        result = bzrdir.create_branch()

        if force_new_tree or (repo.make_working_trees() and

                              force_new_tree is None):

            try:

                bzrdir.create_workingtree()

            except errors.NotLocalUrl:

                pass

        return result

    @staticmethod

    def create_standalone_workingtree(base, format=None):

        """Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.

        'base' must be a local path or a file:// url.

        This will use the current default BzrDirFormat unless one is

        specified, and use whatever 

        repository format that that uses for bzrdirformat.create_workingtree,

        create_branch and create_repository.

        :param format: Override for the bzrdir format to create.

        :return: The WorkingTree object.

        """

        t = get_transport(base)

        if not isinstance(t, LocalTransport):

            raise errors.NotLocalUrl(base)

        bzrdir = BzrDir.create_branch_and_repo(base,

                                               force_new_repo=True,

                                               format=format).bzrdir

        return bzrdir.create_workingtree()

    def create_workingtree(self, revision_id=None, from_branch=None,

        accelerator_tree=None, hardlink=False):

        """Create a working tree at this BzrDir.

        :param revision_id: create it as of this revision id.

        :param from_branch: override bzrdir branch (for lightweight checkouts)

        :param accelerator_tree: A tree which can be used for retrieving file

            contents more quickly than the revision tree, i.e. a workingtree.

            The revision tree will be used for cases where accelerator_tree's

            content is different.

        """

        raise NotImplementedError(self.create_workingtree)

    def retire_bzrdir(self, limit=10000):

        """Permanently disable the bzrdir.

        This is done by renaming it to give the user some ability to recover

        if there was a problem.

        This will have horrible consequences if anyone has anything locked or

        in use.

        :param limit: number of times to retry

        """

        i  = 0

        while True:

            try:

                to_path = '.bzr.retired.%d' % i

                self.root_transport.rename('.bzr', to_path)

                note("renamed %s to %s"

                    % (self.root_transport.abspath('.bzr'), to_path))

                return

            except (errors.TransportError, IOError, errors.PathError):

                i += 1

                if i > limit:

                    raise

                else:

                    pass

    def destroy_workingtree(self):

        """Destroy the working tree at this BzrDir.

        Formats that do not support this may raise UnsupportedOperation.

        """

        raise NotImplementedError(self.destroy_workingtree)

    def destroy_workingtree_metadata(self):

        """Destroy the control files for the working tree at this BzrDir.

        The contents of working tree files are not affected.

        Formats that do not support this may raise UnsupportedOperation.

        """

        raise NotImplementedError(self.destroy_workingtree_metadata)

    def _find_containing(self, evaluate):

        """Find something in a containing control directory.

        This method will scan containing control dirs, until it finds what

        it is looking for, decides that it will never find it, or runs out

        of containing control directories to check.

        It is used to implement find_repository and

        determine_repository_policy.

        :param evaluate: A function returning (value, stop).  If stop is True,

            the value will be returned.

        """

        found_bzrdir = self

        while True:

            result, stop = evaluate(found_bzrdir)

            if stop:

                return result

            next_transport = found_bzrdir.root_transport.clone('..')

            if (found_bzrdir.root_transport.base == next_transport.base):

                # top of the file system

                return None

            # find the next containing bzrdir

            try:

                found_bzrdir = BzrDir.open_containing_from_transport(

                    next_transport)[0]

            except errors.NotBranchError:

                return None

    def find_repository(self):

        """Find the repository that should be used.

        This does not require a branch as we use it to find the repo for

        new branches as well as to hook existing branches up to their

        repository.

        """

        def usable_repository(found_bzrdir):

            # does it have a repository ?

            try:

                repository = found_bzrdir.open_repository()

            except errors.NoRepositoryPresent:

                return None, False

            if found_bzrdir.root_transport.base == self.root_transport.base:

                return repository, True

            elif repository.is_shared():

                return repository, True

            else:

                return None, True

        found_repo = self._find_containing(usable_repository)

        if found_repo is None:

            raise errors.NoRepositoryPresent(self)

        return found_repo

    def get_branch_reference(self):

        """Return the referenced URL for the branch in this bzrdir.

        :raises NotBranchError: If there is no Branch.

        :return: The URL the branch in this bzrdir references if it is a

            reference branch, or None for regular branches.

        """

        return None

    def get_branch_transport(self, branch_format):

        """Get the transport for use by branch format in this BzrDir.

        Note that bzr dirs that do not support format strings will raise

        IncompatibleFormat if the branch format they are given has

        a format string, and vice versa.

        If branch_format is None, the transport is returned with no 

        checking. If it is not None, then the returned transport is

        guaranteed to point to an existing directory ready for use.

        """

        raise NotImplementedError(self.get_branch_transport)

    def _find_creation_modes(self):

        """Determine the appropriate modes for files and directories.

        They're always set to be consistent with the base directory,

        assuming that this transport allows setting modes.

        """

        # TODO: Do we need or want an option (maybe a config setting) to turn

        # this off or override it for particular locations? -- mbp 20080512

        if self._mode_check_done:

            return

        self._mode_check_done = True

        try:

            st = self.transport.stat('.')

        except errors.TransportNotPossible:

            self._dir_mode = None

            self._file_mode = None

        else:

            # Check the directory mode, but also make sure the created

            # directories and files are read-write for this user. This is

            # mostly a workaround for filesystems which lie about being able to

            # write to a directory (cygwin & win32)

            self._dir_mode = (st.st_mode & 07777) | 00700

            # Remove the sticky and execute bits for files

            self._file_mode = self._dir_mode & ~07111

    def _get_file_mode(self):

        """Return Unix mode for newly created files, or None.

        """

        if not self._mode_check_done:

            self._find_creation_modes()

        return self._file_mode

    def _get_dir_mode(self):

        """Return Unix mode for newly created directories, or None.

        """

        if not self._mode_check_done:

            self._find_creation_modes()

        return self._dir_mode

    def get_repository_transport(self, repository_format):

        """Get the transport for use by repository format in this BzrDir.

        Note that bzr dirs that do not support format strings will raise

        IncompatibleFormat if the repository format they are given has

        a format string, and vice versa.

        If repository_format is None, the transport is returned with no 

        checking. If it is not None, then the returned transport is

        guaranteed to point to an existing directory ready for use.

        """

        raise NotImplementedError(self.get_repository_transport)

    def get_workingtree_transport(self, tree_format):

        """Get the transport for use by workingtree format in this BzrDir.

        Note that bzr dirs that do not support format strings will raise

        IncompatibleFormat if the workingtree format they are given has a

        format string, and vice versa.

        If workingtree_format is None, the transport is returned with no 

        checking. If it is not None, then the returned transport is

        guaranteed to point to an existing directory ready for use.

        """

        raise NotImplementedError(self.get_workingtree_transport)

    def __init__(self, _transport, _format):

        """Initialize a Bzr control dir object.

        Only really common logic should reside here, concrete classes should be

        made with varying behaviours.

        :param _format: the format that is creating this BzrDir instance.

        :param _transport: the transport this dir is based at.

        """

        self._format = _format

        self.transport = _transport.clone('.bzr')

        self.root_transport = _transport

        self._mode_check_done = False

    def is_control_filename(self, filename):

        """True if filename is the name of a path which is reserved for bzrdir's.

        :param filename: A filename within the root transport of this bzrdir.

        This is true IF and ONLY IF the filename is part of the namespace reserved

        for bzr control dirs. Currently this is the '.bzr' directory in the root

        of the root_transport. it is expected that plugins will need to extend

        this in the future - for instance to make bzr talk with svn working

        trees.

        """

        # this might be better on the BzrDirFormat class because it refers to 

        # all the possible bzrdir disk formats. 

        # This method is tested via the workingtree is_control_filename tests- 

        # it was extracted from WorkingTree.is_control_filename. If the method's

        # contract is extended beyond the current trivial implementation, please

        # add new tests for it to the appropriate place.

        return filename == '.bzr' or filename.startswith('.bzr/')

    def needs_format_conversion(self, format=None):

        """Return true if this bzrdir needs convert_format run on it.

        For instance, if the repository format is out of date but the 

        branch and working tree are not, this should return True.

        :param format: Optional parameter indicating a specific desired

                       format we plan to arrive at.

        """

        raise NotImplementedError(self.needs_format_conversion)

    @staticmethod

    def open_unsupported(base):

        """Open a branch which is not supported."""

        return BzrDir.open(base, _unsupported=True)

    @staticmethod

    def open(base, _unsupported=False, possible_transports=None):

        """Open an existing bzrdir, rooted at 'base' (url).

        :param _unsupported: a private parameter to the BzrDir class.

        """

        t = get_transport(base, possible_transports=possible_transports)

        return BzrDir.open_from_transport(t, _unsupported=_unsupported)

    @staticmethod

    def open_from_transport(transport, _unsupported=False,

                            _server_formats=True):

        """Open a bzrdir within a particular directory.

        :param transport: Transport containing the bzrdir.

        :param _unsupported: private.

        """

        base = transport.base

        def find_format(transport):

            return transport, BzrDirFormat.find_format(

                transport, _server_formats=_server_formats)

        def redirected(transport, e, redirection_notice):

            qualified_source = e.get_source_url()

            relpath = transport.relpath(qualified_source)

            if not e.target.endswith(relpath):

                # Not redirected to a branch-format, not a branch

                raise errors.NotBranchError(path=e.target)

            target = e.target[:-len(relpath)]

            note('%s is%s redirected to %s',

                 transport.base, e.permanently, target)

            # Let's try with a new transport

            # FIXME: If 'transport' has a qualifier, this should

            # be applied again to the new transport *iff* the

            # schemes used are the same. Uncomment this code

            # once the function (and tests) exist.

            # -- vila20070212

            #target = urlutils.copy_url_qualifiers(original, target)

            return get_transport(target)

        try:

            transport, format = do_catching_redirections(find_format,

                                                         transport,

                                                         redirected)

        except errors.TooManyRedirections:

            raise errors.NotBranchError(base)