~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005, 2006, 2007 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.

"""

# TODO: Can we move specific formats into separate modules to make this file

# smaller?

from cStringIO import StringIO

import os

import textwrap

from bzrlib.lazy_import import lazy_import

lazy_import(globals(), """

from stat import S_ISDIR

import bzrlib

from bzrlib import (

    errors,

    lockable_files,

    lockdir,

    registry,

    remote,

    revision as _mod_revision,

    symbol_versioning,

    ui,

    urlutils,

    xml4,

    xml5,

    workingtree,

    workingtree_4,

    )

from bzrlib.osutils import (

    safe_unicode,

    sha_strings,

    sha_string,

    )

from bzrlib.smart.client import _SmartClient

from bzrlib.smart import protocol

from bzrlib.store.revision.text import TextRevisionStore

from bzrlib.store.text import TextStore

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

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.

    transport

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

    root_transport

        a transport connected to the directory this bzr was opened from.

    """

    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 urls 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._format.initialize_on_transport(transport)

        try:

            local_repo = self.find_repository()

        except errors.NoRepositoryPresent:

            local_repo = None

        if local_repo:

            # may need to copy content in

            if force_new_repo:

                result_repo = local_repo.clone(

                    result,

                    revision_id=revision_id)

                result_repo.set_make_working_trees(local_repo.make_working_trees())

            else:

                try:

                    result_repo = result.find_repository()

                    # fetch content this dir needs.

                    result_repo.fetch(local_repo, revision_id=revision_id)

                except errors.NoRepositoryPresent:

                    # needed to make one anyway.

                    result_repo = local_repo.clone(

                        result,

                        revision_id=revision_id)

                    result_repo.set_make_working_trees(local_repo.make_working_trees())

        # 1 if there is a branch present

        #   make sure its content is available in the target repository

        #   clone it.

        try:

            self.open_branch().clone(result, revision_id=revision_id)

        except errors.NotBranchError:

            pass

        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()

    # TODO: Should take a Transport

    @classmethod

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

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

        This will call the current default formats initialize with base

        as the only parameter.

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

            supplied, the default is used.

        """

        if cls is not BzrDir:

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

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

        t = get_transport(base)

        t.ensure_base()

        if format is None:

            format = BzrDirFormat.get_default_format()

        return format.initialize(safe_unicode(base))

    def create_branch(self):

        """Create a branch in this BzrDir.

        The bzrdirs format will control what branch format is created.

        For more control see BranchFormatXX.create(a_bzrdir).

        """

        raise NotImplementedError(self.create_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, 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.

        """

        bzrdir = BzrDir.create(base, format)

        bzrdir._find_or_create_repository(force_new_repo)

        return bzrdir.create_branch()

    def _find_or_create_repository(self, force_new_repo):

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

        if force_new_repo:

            return self.create_repository()

        try:

            return self.find_repository()

        except errors.NoRepositoryPresent:

            return self.create_repository()

    @staticmethod

    def create_branch_convenience(base, force_new_repo=False,

                                  force_new_tree=None, format=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, 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 for the bzrdir format to create

        """

        if force_new_tree:

            # check for non local urls

            t = get_transport(safe_unicode(base))

            if not isinstance(t, LocalTransport):

                raise errors.NotLocalUrl(base)

        bzrdir = BzrDir.create(base, format)

        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_repository(base, shared=False, format=None):

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

        If no format is supplied, this will default to the current default

        BzrDirFormat by default, and use whatever repository format that that

        uses for bzrdirformat.create_repository.

        :param shared: Create a shared repository rather than a standalone

                       repository.

        The Repository object is returned.

        This must be overridden as an instance method in child classes, where

        it should take no parameters and construct whatever repository format

        that child class desires.

        """

        bzrdir = BzrDir.create(base, format)

        return bzrdir.create_repository(shared)

    @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, and use whatever 

        repository format that that uses for bzrdirformat.create_workingtree,

        create_branch and create_repository.

        :return: The WorkingTree object.

        """

        t = get_transport(safe_unicode(base))

        if not isinstance(t, LocalTransport):

            raise errors.NotLocalUrl(base)

        bzrdir = BzrDir.create_branch_and_repo(safe_unicode(base),

                                               force_new_repo=True,

                                               format=format).bzrdir

        return bzrdir.create_workingtree()

    def create_workingtree(self, revision_id=None):

        """Create a working tree at this BzrDir.

        revision_id: create it as of this revision id.

        """

        raise NotImplementedError(self.create_workingtree)

    def retire_bzrdir(self):

        """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.

        """

        for i in xrange(10000):

            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))

                break

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

                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_repository(self):

        """Find the repository that should be used for a_bzrdir.

        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.

        """

        try:

            return self.open_repository()

        except errors.NoRepositoryPresent:

            pass

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

        while True:

            # find the next containing bzrdir

            try:

                found_bzrdir = BzrDir.open_containing_from_transport(

                    next_transport)[0]

            except errors.NotBranchError:

                # none found

                raise errors.NoRepositoryPresent(self)

            # does it have a repository ?

            try:

                repository = found_bzrdir.open_repository()

            except errors.NoRepositoryPresent:

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

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

                    # top of the file system

                    break

                else:

                    continue

            if ((found_bzrdir.root_transport.base ==

                 self.root_transport.base) or repository.is_shared()):

                return repository

            else:

                raise errors.NoRepositoryPresent(self)

        raise errors.NoRepositoryPresent(self)

    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 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

    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 methods

        # 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):

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

        _unsupported is a private parameter to the BzrDir class.

        """

        t = get_transport(base)

        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

            qualified_target = e.get_target_url()[:-len(relpath)]

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

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

            # schemes used are the same. It's a bit tricky to

            # verify, so I'll punt for now

            # -- vila20070212

            return get_transport(target)

        try:

            transport, format = do_catching_redirections(find_format,

                                                         transport,

                                                         redirected)

        except errors.TooManyRedirections:

            raise errors.NotBranchError(base)

        BzrDir._check_supported(format, _unsupported)

        return format.open(transport, _found=True)

    def open_branch(self, unsupported=False):

        """Open the branch object at this BzrDir if one is present.

        If unsupported is True, then no longer supported branch formats can

        still be opened.

        TODO: static convenience version of this?

        """

        raise NotImplementedError(self.open_branch)

    @staticmethod

    def open_containing(url):

        """Open an existing branch which contains url.

        :param url: url to search from.

        See open_containing_from_transport for more detail.

        """

        return BzrDir.open_containing_from_transport(get_transport(url))

    @staticmethod

    def open_containing_from_transport(a_transport):

        """Open an existing branch which contains a_transport.base

        This probes for a branch at a_transport, and searches upwards from there.

        Basically we keep looking up until we find the control directory or

        run into the root.  If there isn't one, raises NotBranchError.

        If there is one and it is either an unrecognised format or an unsupported 

        format, UnknownFormatError or UnsupportedFormatError are raised.

        If there is one, it is returned, along with the unused portion of url.

        :return: The BzrDir that contains the path, and a Unicode path 

                for the rest of the URL.

        """

        # this gets the normalised url back. I.e. '.' -> the full path.

        url = a_transport.base

        while True:

            try:

                result = BzrDir.open_from_transport(a_transport)

                return result, urlutils.unescape(a_transport.relpath(url))

            except errors.NotBranchError, e:

                pass

            try:

                new_t = a_transport.clone('..')

            except errors.InvalidURLJoin:

                # reached the root, whatever that may be

                raise errors.NotBranchError(path=url)

            if new_t.base == a_transport.base:

                # reached the root, whatever that may be

                raise errors.NotBranchError(path=url)

            a_transport = new_t

    @classmethod

    def open_containing_tree_or_branch(klass, location):

        """Return the branch and working tree contained by a location.

        Returns (tree, branch, relpath).

        If there is no tree at containing the location, tree will be None.

        If there is no branch containing the location, an exception will be

        raised

        relpath is the portion of the path that is contained by the branch.

        """

        bzrdir, relpath = klass.open_containing(location)

        try:

            tree = bzrdir.open_workingtree()

        except (errors.NoWorkingTree, errors.NotLocalUrl):

            tree = None

            branch = bzrdir.open_branch()

        else:

            branch = tree.branch

        return tree, branch, relpath

    def open_repository(self, _unsupported=False):

        """Open the repository object at this BzrDir if one is present.

        This will not follow the Branch object pointer - its strictly a direct

        open facility. Most client code should use open_branch().repository to

        get at a repository.

        _unsupported is a private parameter, not part of the api.

        TODO: static convenience version of this?

        """

        raise NotImplementedError(self.open_repository)

    def open_workingtree(self, _unsupported=False,

            recommend_upgrade=True):

        """Open the workingtree object at this BzrDir if one is present.

        :param recommend_upgrade: Optional keyword parameter, when True (the

            default), emit through the ui module a recommendation that the user

            upgrade the working tree when the workingtree being opened is old

            (but still fully supported).

        """

        raise NotImplementedError(self.open_workingtree)

    def has_branch(self):

        """Tell if this bzrdir contains a branch.

        Note: if you're going to open the branch, you should just go ahead

        and try, and not ask permission first.  (This method just opens the 

        branch and discards it, and that's somewhat expensive.) 

        """

        try:

            self.open_branch()

            return True

        except errors.NotBranchError:

            return False

    def has_workingtree(self):

        """Tell if this bzrdir contains a working tree.

        This will still raise an exception if the bzrdir has a workingtree that

        is remote & inaccessible.

        Note: if you're going to open the working tree, you should just go ahead

        and try, and not ask permission first.  (This method just opens the 

        workingtree and discards it, and that's somewhat expensive.) 

        """

        try:

            self.open_workingtree(recommend_upgrade=False)

            return True

        except errors.NoWorkingTree:

            return False

    def _cloning_metadir(self):

        """Produce a metadir suitable for cloning with"""

        result_format = self._format.__class__()

        try:

            try:

                branch = self.open_branch()

                source_repository = branch.repository

            except errors.NotBranchError:

                source_branch = None

                source_repository = self.open_repository()

        except errors.NoRepositoryPresent:

            source_repository = None

        else:

            # XXX TODO: This isinstance is here because we have not implemented

            # the fix recommended in bug # 103195 - to delegate this choice the

            # repository itself.

            repo_format = source_repository._format

            if not isinstance(repo_format, remote.RemoteRepositoryFormat):

                result_format.repository_format = repo_format

        try:

            # TODO: Couldn't we just probe for the format in these cases,

            # rather than opening the whole tree?  It would be a little

            # faster. mbp 20070401

            tree = self.open_workingtree(recommend_upgrade=False)

        except (errors.NoWorkingTree, errors.NotLocalUrl):

            result_format.workingtree_format = None

        else:

            result_format.workingtree_format = tree._format.__class__()

        return result_format, source_repository

    def cloning_metadir(self):

        """Produce a metadir suitable for cloning or sprouting with.

        These operations may produce workingtrees (yes, even though they're

        "cloning" something that doesn't have a tree, so a viable workingtree

        format must be selected.

        """

        format, repository = self._cloning_metadir()

        if format._workingtree_format is None:

            if repository is None:

                return format

            tree_format = repository._format._matchingbzrdir.workingtree_format

            format.workingtree_format = tree_format.__class__()

        return format

    def checkout_metadir(self):

        return self.cloning_metadir()

    def sprout(self, url, revision_id=None, force_new_repo=False,

               recurse='down'):

        """Create a copy of this bzrdir prepared for use as a new line of

        development.

        If urls last component does not exist, it will be created.

        Attributes related to the identity of the source branch like

        branch nickname will be cleaned, a working tree is created