~bzr-pqm/bzr/bzr.dev

#

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

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

 

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

 

from bzrlib.osutils import (

    sha_string,

    )

from bzrlib.smart.client import _SmartClient

from bzrlib.store.versioned import WeaveStore

from bzrlib.transactions import WriteTransaction

    )

 

from bzrlib import (

    registry,

    symbol_versioning,

    )

 

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:

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

 

    Everything in the bzrdir should have the same file permissions.

    """

 

    def break_lock(self):

        basedir=None):

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

 

        or repository.

 

        have limited functionality.

 

        :param recommend_upgrade: If true (default), warn

        transport.ensure_base()

        require_stacking = (stacked_on is not None)

        format = self.cloning_metadir(require_stacking)

        result = format.initialize_on_transport(transport)

        repository_policy = None

        try:

                force_new_repo, stacked_on, self.root_transport.base,

                require_stacking=require_stacking)

            make_working_trees = local_repo.make_working_trees()

                make_working_trees, local_repo.is_shared())

            if not require_stacking and repository_policy._require_stacking:

                require_stacking = True

                result._format.require_stacking()

        else:

            result_repo = None

        # 1 if there is a branch present

        #   make sure its content is available in the target repository

        #   clone it.

        if local_branch is not None:

                self.open_workingtree().clone(result)

        return result

 

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

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

            can be reused to share a remote connection.

        """

        if cls is not BzrDir:

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

 

        This will use the current default BzrDirFormat unless one is

        repository format that that uses via bzrdir.create_branch and

        create_repository. If a shared repository is available that is used

        preferentially.

                                    stack_on_pwd=None, require_stacking=False):

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

 

 

        If stack_on is supplied, will not seek a containing shared repo.

 

                if stack_on is not None:

                    stack_on_pwd = found_bzrdir.root_transport.base

                    stop = True

            # does it have a repository ?

            try:

                repository = found_bzrdir.open_repository()

            else:

                if ((found_bzrdir.root_transport.base !=

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

                    repository = None

                else:

                    stop = True

            if not stop:

    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)

 

    @staticmethod

    def create_branch_convenience(base, force_new_repo=False,

        not.

 

        This will use the current default BzrDirFormat unless one is

        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

 

        The created Branch object is returned.

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

        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.

                               prevent such creation respectively.

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

        :param possible_transports: An optional reusable transports list.

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

 

        This will use the current default BzrDirFormat unless one is

        repository format that that uses for bzrdirformat.create_workingtree,

        create_branch and create_repository.

 

    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

 

    def backup_bzrdir(self):

        """Backup this bzr control directory.

        :return: Tuple with old path name and new path name

        """

        pb = ui.ui_factory.nested_progress_bar()

            # already exists, but it should instead either remove it or make

            # a new backup directory.

            #

            # permissions as the .bzr directory (probably a bug in copy_tree)

            old_path = self.root_transport.abspath('.bzr')

            new_path = self.root_transport.abspath('backup.bzr')

        IncompatibleFormat if the branch format they are given has

        a format string, and vice versa.

 

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

        guaranteed to point to an existing directory ready for use.

        """

        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.

 

        IncompatibleFormat if the repository format they are given has

        a format string, and vice versa.

 

        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.

 

        IncompatibleFormat if the workingtree format they are given has a

        format string, and vice versa.

 

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

        guaranteed to point to an existing directory ready for use.

        """

 

    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.

 

 

    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

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

        trees.

        """

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

 

    def needs_format_conversion(self, format=None):

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

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

 

        :param format: Optional parameter indicating a specific desired

    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)

        :param transport: Transport containing the bzrdir.

        :param _unsupported: private.

        """

        # Keep initial base since 'transport' may be modified while following

        # the redirections.

        base = transport.base

        BzrDir._check_supported(format, _unsupported)

        return format.open(transport, _found=True)

 

        """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, possible_transports=None):

        """Open an existing branch which contains url.

        :param url: url to search from.

        See open_containing_from_transport for more detail.

        """

        transport = get_transport(url, possible_transports)

        return BzrDir.open_containing_from_transport(transport)

    @staticmethod

    def open_containing_from_transport(a_transport):

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

 

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

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

        format, UnknownFormatError or UnsupportedFormatError are raised.

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

 

                for the rest of the URL.

        """

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

 

    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

        """

        try:

            self.open_branch()

 

        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

        """

        try:

            self.open_workingtree(recommend_upgrade=False)

 

    def _cloning_metadir(self):

        """Produce a metadir suitable for cloning with.

        :returns: (destination_bzrdir_format, source_repository)

        """

        result_format = self._format.__class__()

        try:

            try:

                source_repository = branch.repository

                result_format._branch_format = branch._format

            except errors.NotBranchError:

                    source_repository = None

        repository_policy = result.determine_repository_policy(

            force_new_repo, stacked_branch_url, require_stacking=stacked)

        if source_repository is not None:

            # Fetch while stacked to prevent unstacked fetch from

            # Branch.sprout.

 

        if source_branch is None:

            # this is for sprouting a bzrdir without a branch; is that

            # Not especially, but it's part of the contract.

            result_branch = result.create_branch()

        else:

        mutter("created new branch %r" % (result_branch,))

 

        # Create/update the result working tree

        if (create_tree_if_local and

                    basis.unlock()

        return result

 

 

class BzrDirPreSplitOut(BzrDir):

    """A common class for the all-in-one formats."""

        # and that will have set it for us, its only

        # specific uses of create_workingtree in isolation

        # that can do wonky stuff here, and that only

        # done on this format anyway. So - acceptable wart.

        try:

            result = self.open_workingtree(recommend_upgrade=False)

 

    def destroy_workingtree_metadata(self):

        """See BzrDir.destroy_workingtree_metadata."""

                                          self)

 

    def get_branch_transport(self, branch_format):

            format = BzrDirFormat.get_default_format()

        return not isinstance(self._format, format.__class__)

 

        """See BzrDir.open_branch."""

        from bzrlib.branch import BzrBranchFormat4

        format = BzrBranchFormat4()

 

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

               possible_transports=None, accelerator_tree=None,

        """See BzrDir.sprout()."""

        if stacked:

            raise errors.UnstackableBranchFormat(

                self._format, self.root_transport.base)

 

class BzrDir4(BzrDirPreSplitOut):

    """A .bzr version 4 control object.

    This is a deprecated format and may be removed after sept 2006.

    """

 

 

class BzrDirMeta1(BzrDir):

    """A .bzr meta version 1 control object.

    individual aspects are really split out: there are separate repository,

    workingtree and branch subdirectories and any subset of the three can be

    present within a BzrDir.

            pass

        return False

 

        """See BzrDir.open_branch."""

        format = self.find_branch_format()

        self._check_supported(format, unsupported)

 

    def open_repository(self, unsupported=False):

        """See BzrDir.open_repository."""

     * a format string,

     * an open routine.

 

    during bzrdir opening. These should be subclasses of BzrDirFormat

    for consistency.

 

    Once a format is deprecated, just deprecate the initialize and open

    object will be created every system load.

    """

 

 

    _control_formats = []

    """The registered control formats - .bzr, ....

    This is a list of BzrDirFormat objects.

    """

 

        current default format. In the case of plugins we can/should provide

        some means for them to extend the range of returnable converters.

 

                       library.

        """

        raise NotImplementedError(self.get_converter)

 

    def initialize(self, url, possible_transports=None):

        """Create a bzr control dir at this url and return an opened copy.

        Subclasses should typically override initialize_on_transport

        instead of this method.

        """

 

    def _initialize_on_transport_vfs(self, transport):

        """Initialize a new bzrdir using VFS calls.

        :param transport: The transport to create the .bzr directory in.

        :return: A

        """

        """Is this format supported?

 

        Supported formats must be initializable and openable.

        some other features depending on the reason for not being supported.

        """

        return True

 

    def same_model(self, target_format):

            target_format.rich_root_data)

 

    @classmethod

    def known_formats(klass):

        """Return all the known formats.

        Concrete formats should override _known_formats.

        """

        # once. This can otherwise be quite expensive for remote connections.

        result = set()

        for format in klass._control_formats:

            result.update(format._known_formats())

        return result

    @classmethod

    def _known_formats(klass):

        """Return the known format instances for this control format."""

 

    def open(self, transport, _found=False):

        """Return an instance of this format for the dir transport points at.

        _found is a private parameter, do not use it.

        """

        if not _found:

            found_format = BzrDirFormat.find_format(transport)

            if not isinstance(found_format, self.__class__):

                raise AssertionError("%s was asked to open %s, but it seems to need "

                        % (self, transport, found_format))

            # Allow subclasses - use the found format.

            self._supply_sub_formats_to(found_format)

    @classmethod

    def register_format(klass, format):

        klass._formats[format.get_format_string()] = format

 

    @classmethod

    def register_control_format(klass, format):

        """Register a format that does not use '.bzr' for its control dir.

 

        TODO: This should be pulled up into a 'ControlDirFormat' base class

        there. It has been done without that for now for simplicity of

        implementation.

        """

 

    def __str__(self):

        # Trim the newline

 

    def _supply_sub_formats_to(self, other_format):

        """Give other_format the same values for sub formats as this has.

        """See BzrDirFormat.get_converter()."""

        # there is one and only one upgrade path here.

        return ConvertBzrDir4To5()

    def initialize_on_transport(self, transport):

        """Format 4 branches cannot be created."""

        raise errors.UninitializableFormat(self)

        """Format 4 is not supported.

 

        It is not supported because the model changed from 4 to 5 and the

        feasible.

        """

        return False

 

    def _open(self, transport):

        """See BzrDirFormat._open."""

        return BzrDir4(transport, self)

 

    This format is a combined format for working tree, branch and repository.

    It has:

     - Format 5 repositories [always]

       Unhashed stores in the repository.

    """

 

    def _initialize_for_clone(self, url):

        return self.initialize_on_transport(get_transport(url), _cloning=True)

    def initialize_on_transport(self, transport, _cloning=False):

        """Format 5 dirs always have working tree, branch and repository.

        Except when they are being cloned.

        """

        from bzrlib.branch import BzrBranchFormat4

            result._init_workingtree()

        return result

 

    def _open(self, transport):

        """See BzrDirFormat._open."""

        return BzrDir5(transport, self)

 

    This format is a combined format for working tree, branch and repository.

    It has:

     - Format 6 repositories [always]

    """

 

        """See BzrDirFormat.get_converter()."""

        # there is one and only one upgrade path here.

        return ConvertBzrDir6ToMeta()

    def _initialize_for_clone(self, url):

        return self.initialize_on_transport(get_transport(url), _cloning=True)

 

    def initialize_on_transport(self, transport, _cloning=False):

        """Format 6 dirs always have working tree, branch and repository.

        Except when they are being cloned.

        """

        from bzrlib.branch import BzrBranchFormat4

            result._init_workingtree()

        return result

 

    def _open(self, transport):

        """See BzrDirFormat._open."""

        return BzrDir6(transport, self)

    def __init__(self):

        self._workingtree_format = None

        self._branch_format = None

 

    def __eq__(self, other):

        if other.__class__ is not self.__class__:

            # target doesn't support stacking.  So force a branch that *can*

            # support stacking.

            from bzrlib.branch import BzrBranchFormat7

            from bzrlib.repofmt import pack_repo

            if self.repository_format.rich_root_data:

                bzrdir_format_name = '1.6.1-rich-root'

        """See BzrDirFormat.get_format_description()."""

        return "Meta directory format 1"

 

    def _open(self, transport):

        """See BzrDirFormat._open."""

        return BzrDirMeta1(transport, self)

 

    def __return_repository_format(self):

        """Circular import protection."""

            return self._repository_format

        from bzrlib.repository import RepositoryFormat

        return RepositoryFormat.get_default_format()

                                  __set_workingtree_format)

 

 

# Register bzr control format

BzrDirFormat.register_control_format(BzrDirFormat)

 

        self.absent_revisions = set()

        self.text_count = 0

        self.revisions = {}

    def convert(self, to_convert, pb):

        """See Converter.convert()."""

        self.bzrdir = to_convert

                revision_store.add_lines(key, None, osutils.split_lines(text))

        finally:

            self.pb.clear()

    def _load_one_rev(self, rev_id):

        """Load a revision object into memory.

 

        text_changed = False

        parent_candiate_entries = ie.parent_candidates(parent_invs)

        heads = graph.Graph(self).heads(parent_candiate_entries.keys())

        # the previous code was also unordered.

        previous_entries = dict((head, parent_candiate_entries[head]) for head

            in heads)

        self.snapshot_ie(previous_entries, ie, w, rev_id)

        del ie.text_id

 

    def get_parent_map(self, revision_ids):

        """See graph._StackedParentsProvider.get_parent_map"""

        return dict((revision_id, self.revisions[revision_id])

        # a call to:. This needs the path figured out. rather than a work_tree

        # a v4 revision_tree can be given, or something that looks enough like

        # one to give the file content to the entry if it needs it.

        # save against.

        #ie.snapshot(rev, PATH, previous_revisions, REVISION_TREE, InMemoryWeaveStore(self.text_weaves))

        if len(previous_revisions) == 1:

        self.bzrdir.transport.mkdir('repository', mode=self.dir_mode)

        self.make_lock('repository')

        # we hard code the formats here because we are converting into

        # future format within each component.

        self.put_format('repository', RepositoryFormat7())

        for entry in repository_names:

                isinstance(self.target_format.workingtree_format,

                    workingtree_4.WorkingTreeFormat5)):

                workingtree_4.Converter4to5().convert(tree)

        return to_convert

 

 

class RemoteBzrDirFormat(BzrDirMetaFormat1):

    """Format representing bzrdirs accessed via a smart server"""

 

    def get_format_description(self):

        return 'bzr remote bzrdir'

    @classmethod

    def probe_transport(klass, transport):

        """Return a RemoteBzrDirFormat object if it looks possible."""

        # Always return a RemoteRepositoryFormat object, but if a specific bzr

        # repository format has been asked for, tell the RemoteRepositoryFormat

        # that it should use that for init() etc.

        custom_format = getattr(self, '_repository_format', None)

        if custom_format:

            if isinstance(custom_format, remote.RemoteRepositoryFormat):

            else:

                result._custom_format = custom_format

        return result

 

    repository_format = property(__return_repository_format,

 

class BzrDirFormatRegistry(registry.Registry):

    """Registry of user-selectable BzrDir subformats.

    Differs from BzrDirFormat._control_formats in that it provides sub-formats,

    e.g. BzrDirMeta1 with weave repository.  Also, it's more user-oriented.

    """

        """Register a metadir subformat.

 

        These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized

 

        :param repository_format: The fully-qualified repository format class

            name as a string.

    def register(self, key, factory, help, native=True, deprecated=False,

                 hidden=False, experimental=False, alias=False):

        """Register a BzrDirFormat factory.

        The factory must be a callable that takes one parameter: the key.

        It must produce an instance of the BzrDirFormat when called.

 

 

    def set_default(self, key):

        """Set the 'default' key to be a clone of the supplied key.

        This method must be called once and only once.

        """

        registry.Registry.register(self, 'default', self.get(key),

 

    def set_default_repository(self, key):

        """Set the FormatRegistry default and Repository default.

        This is a transitional method while Repository.set_default_format

        is deprecated.

        """

        def wrapped(key, help, info):

            if info.native:

                help = '(native) ' + help

                    subsequent_indent='    '))

        if default_realkey is not None:

            output += wrapped(default_realkey, '(default) %s' % default_help,

                stack_on = self._get_full_stack_on()

        try:

            branch.set_stacked_on_url(stack_on)

            if self._require_stacking:

                raise

 

        :param make_working_trees: If creating a repository, set

            make_working_trees to this value (if non-None)

        :param shared: If creating a repository, make it shared if True

        """

        raise NotImplemented(RepositoryAcquisitionPolicy.acquire_repository)

 

 

        Creates the desired repository in the bzrdir we already have.

        """