/brz/remove-bazaar

# Copyright (C) 2005-2011 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

from bzrlib.lazy_import import lazy_import

lazy_import(globals(), """

import itertools

import time

from bzrlib import (

    bzrdir,

    config,

    controldir,

    debug,

    generate_ids,

    graph,

    lockable_files,

    lockdir,

    osutils,

    revision as _mod_revision,

    testament as _mod_testament,

    tsort,

    )

from bzrlib.bundle import serializer

""")

from bzrlib import (

    errors,

    registry,

    symbol_versioning,

    ui,

    )

from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises

from bzrlib.inter import InterObject

from bzrlib.lock import _RelockDebugMixin, LogicalLockResult

from bzrlib.trace import (

    log_exception_quietly, note, mutter, mutter_callsite, warning)

# Old formats display a warning, but only once

_deprecation_warning_done = False

class IsInWriteGroupError(errors.InternalBzrError):

    _fmt = "May not refresh_data of repo %(repo)s while in a write group."

    def __init__(self, repo):

        errors.InternalBzrError.__init__(self, repo=repo)

class CommitBuilder(object):

    """Provides an interface to build up a commit.

    This allows describing a tree to be committed without needing to

    know the internals of the format of the repository.

    """

    # all clients should supply tree roots.

    record_root_entry = True

    # whether this commit builder supports the record_entry_contents interface

    supports_record_entry_contents = False

    def __init__(self, repository, parents, config, timestamp=None,

                 timezone=None, committer=None, revprops=None,

                 revision_id=None, lossy=False):

        """Initiate a CommitBuilder.

        :param repository: Repository to commit to.

        :param parents: Revision ids of the parents of the new revision.

        :param timestamp: Optional timestamp recorded for commit.

        :param timezone: Optional timezone for timestamp.

        :param committer: Optional committer to set for commit.

        :param revprops: Optional dictionary of revision properties.

        :param revision_id: Optional revision id.

        :param lossy: Whether to discard data that can not be natively

            represented, when pushing to a foreign VCS 

        """

        self._config = config

        self._lossy = lossy

        if committer is None:

            self._committer = self._config.username()

        elif not isinstance(committer, unicode):

            self._committer = committer.decode() # throw if non-ascii

        else:

            self._committer = committer

        self._new_revision_id = revision_id

        self.parents = parents

        self.repository = repository

        self._revprops = {}

        if revprops is not None:

            self._validate_revprops(revprops)

            self._revprops.update(revprops)

        if timestamp is None:

            timestamp = time.time()

        # Restrict resolution to 1ms

        self._timestamp = round(timestamp, 3)

        if timezone is None:

            self._timezone = osutils.local_time_offset()

        else:

            self._timezone = int(timezone)

        self._generate_revision_if_needed()

    def any_changes(self):

        """Return True if any entries were changed.

        This includes merge-only changes. It is the core for the --unchanged

        detection in commit.

        :return: True if any changes have occured.

        """

        raise NotImplementedError(self.any_changes)

    def _validate_unicode_text(self, text, context):

        """Verify things like commit messages don't have bogus characters."""

        if '\r' in text:

            raise ValueError('Invalid value for %s: %r' % (context, text))

    def _validate_revprops(self, revprops):

        for key, value in revprops.iteritems():

            # We know that the XML serializers do not round trip '\r'

            # correctly, so refuse to accept them

            if not isinstance(value, basestring):

                raise ValueError('revision property (%s) is not a valid'

                                 ' (unicode) string: %r' % (key, value))

            self._validate_unicode_text(value,

                                        'revision property (%s)' % (key,))

    def commit(self, message):

        """Make the actual commit.

        :return: The revision id of the recorded revision.

        """

        raise NotImplementedError(self.commit)

    def abort(self):

        """Abort the commit that is being built.

        """

        raise NotImplementedError(self.abort)

    def revision_tree(self):

        """Return the tree that was just committed.

        After calling commit() this can be called to get a

        RevisionTree representing the newly committed tree. This is

        preferred to calling Repository.revision_tree() because that may

        require deserializing the inventory, while we already have a copy in

        memory.

        """

        raise NotImplementedError(self.revision_tree)

    def finish_inventory(self):

        """Tell the builder that the inventory is finished.

        :return: The inventory id in the repository, which can be used with

            repository.get_inventory.

        """

        raise NotImplementedError(self.finish_inventory)

    def _gen_revision_id(self):

        """Return new revision-id."""

        return generate_ids.gen_revision_id(self._committer, self._timestamp)

    def _generate_revision_if_needed(self):

        """Create a revision id if None was supplied.

        If the repository can not support user-specified revision ids

        they should override this function and raise CannotSetRevisionId

        if _new_revision_id is not None.

        :raises: CannotSetRevisionId

        """

        if self._new_revision_id is None:

            self._new_revision_id = self._gen_revision_id()

            self.random_revid = True

        else:

            self.random_revid = False

    def will_record_deletes(self):

        """Tell the commit builder that deletes are being notified.

        This enables the accumulation of an inventory delta; for the resulting

        commit to be valid, deletes against the basis MUST be recorded via

        builder.record_delete().

        """

        raise NotImplementedError(self.will_record_deletes)

    def record_iter_changes(self, tree, basis_revision_id, iter_changes):

        """Record a new tree via iter_changes.

        :param tree: The tree to obtain text contents from for changed objects.

        :param basis_revision_id: The revision id of the tree the iter_changes

            has been generated against. Currently assumed to be the same

            as self.parents[0] - if it is not, errors may occur.

        :param iter_changes: An iter_changes iterator with the changes to apply

            to basis_revision_id. The iterator must not include any items with

            a current kind of None - missing items must be either filtered out

            or errored-on beefore record_iter_changes sees the item.

        :return: A generator of (file_id, relpath, fs_hash) tuples for use with

            tree._observed_sha1.

        """

        raise NotImplementedError(self.record_iter_changes)

class RepositoryWriteLockResult(LogicalLockResult):

    """The result of write locking a repository.

    :ivar repository_token: The token obtained from the underlying lock, or

        None.

    :ivar unlock: A callable which will unlock the lock.

    """

    def __init__(self, unlock, repository_token):

        LogicalLockResult.__init__(self, unlock)

        self.repository_token = repository_token

    def __repr__(self):

        return "RepositoryWriteLockResult(%s, %s)" % (self.repository_token,

            self.unlock)

######################################################################

# Repositories

class Repository(_RelockDebugMixin, controldir.ControlComponent):

    """Repository holding history for one or more branches.

    The repository holds and retrieves historical information including

    revisions and file history.  It's normally accessed only by the Branch,

    which views a particular line of development through that history.

    See VersionedFileRepository in bzrlib.vf_repository for the

    base class for most Bazaar repositories.

    """

    def abort_write_group(self, suppress_errors=False):

        """Commit the contents accrued within the current write group.

        :param suppress_errors: if true, abort_write_group will catch and log

            unexpected errors that happen during the abort, rather than

            allowing them to propagate.  Defaults to False.

        :seealso: start_write_group.

        """

        if self._write_group is not self.get_transaction():

            # has an unlock or relock occured ?

            if suppress_errors:

                mutter(

                '(suppressed) mismatched lock context and write group. %r, %r',

                self._write_group, self.get_transaction())

                return

            raise errors.BzrError(

                'mismatched lock context and write group. %r, %r' %

                (self._write_group, self.get_transaction()))

        try:

            self._abort_write_group()

        except Exception, exc:

            self._write_group = None

            if not suppress_errors:

                raise

            mutter('abort_write_group failed')

            log_exception_quietly()

            note('bzr: ERROR (ignored): %s', exc)

        self._write_group = None

    def _abort_write_group(self):

        """Template method for per-repository write group cleanup.

        This is called during abort before the write group is considered to be

        finished and should cleanup any internal state accrued during the write

        group. There is no requirement that data handed to the repository be

        *not* made available - this is not a rollback - but neither should any

        attempt be made to ensure that data added is fully commited. Abort is

        invoked when an error has occured so futher disk or network operations

        may not be possible or may error and if possible should not be

        attempted.

        """

    def add_fallback_repository(self, repository):

        """Add a repository to use for looking up data not held locally.

        :param repository: A repository.

        """

        raise NotImplementedError(self.add_fallback_repository)

    def _check_fallback_repository(self, repository):

        """Check that this repository can fallback to repository safely.

        Raise an error if not.

        :param repository: A repository to fallback to.

        """

        return InterRepository._assert_same_model(self, repository)

    def all_revision_ids(self):

        """Returns a list of all the revision ids in the repository.

        This is conceptually deprecated because code should generally work on

        the graph reachable from a particular revision, and ignore any other

        revisions that might be present.  There is no direct replacement

        method.

        """

        if 'evil' in debug.debug_flags:

            mutter_callsite(2, "all_revision_ids is linear with history.")

        return self._all_revision_ids()

    def _all_revision_ids(self):

        """Returns a list of all the revision ids in the repository.

        These are in as much topological order as the underlying store can

        present.

        """

        raise NotImplementedError(self._all_revision_ids)

    def break_lock(self):

        """Break a lock if one is present from another instance.

        Uses the ui factory to ask for confirmation if the lock may be from

        an active process.

        """

        self.control_files.break_lock()

    @needs_read_lock

    def _eliminate_revisions_not_present(self, revision_ids):

        """Check every revision id in revision_ids to see if we have it.

        Returns a set of the present revisions.

        """

        result = []

        graph = self.get_graph()

        parent_map = graph.get_parent_map(revision_ids)

        # The old API returned a list, should this actually be a set?

        return parent_map.keys()

    @staticmethod

    def create(a_bzrdir):

        """Construct the current default format repository in a_bzrdir."""

        return RepositoryFormat.get_default_format().initialize(a_bzrdir)

    def __init__(self, _format, a_bzrdir, control_files):

        """instantiate a Repository.

        :param _format: The format of the repository on disk.

        :param a_bzrdir: The BzrDir of the repository.

        :param control_files: Control files to use for locking, etc.

        """

        # In the future we will have a single api for all stores for

        # getting file texts, inventories and revisions, then

        # this construct will accept instances of those things.

        super(Repository, self).__init__()

        self._format = _format

        # the following are part of the public API for Repository:

        self.bzrdir = a_bzrdir

        self.control_files = control_files

        self._transport = control_files._transport

        self.base = self._transport.base

        # for tests

        self._write_group = None

        # Additional places to query for data.

        self._fallback_repositories = []

    @property

    def user_transport(self):

        return self.bzrdir.user_transport

    @property

    def control_transport(self):

        return self._transport

    def __repr__(self):

        if self._fallback_repositories:

            return '%s(%r, fallback_repositories=%r)' % (

                self.__class__.__name__,

                self.base,

                self._fallback_repositories)

        else:

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

                               self.base)

    def _has_same_fallbacks(self, other_repo):

        """Returns true if the repositories have the same fallbacks."""

        my_fb = self._fallback_repositories

        other_fb = other_repo._fallback_repositories

        if len(my_fb) != len(other_fb):

            return False

        for f, g in zip(my_fb, other_fb):

            if not f.has_same_location(g):

                return False

        return True

    def has_same_location(self, other):

        """Returns a boolean indicating if this repository is at the same

        location as another repository.

        This might return False even when two repository objects are accessing

        the same physical repository via different URLs.

        """

        if self.__class__ is not other.__class__:

            return False

        return (self._transport.base == other._transport.base)

    def is_in_write_group(self):

        """Return True if there is an open write group.

        :seealso: start_write_group.

        """

        return self._write_group is not None

    def is_locked(self):

        return self.control_files.is_locked()

    def is_write_locked(self):

        """Return True if this object is write locked."""

        return self.is_locked() and self.control_files._lock_mode == 'w'

    def lock_write(self, token=None):

        """Lock this repository for writing.

        This causes caching within the repository obejct to start accumlating

        data during reads, and allows a 'write_group' to be obtained. Write

        groups must be used for actual data insertion.

        A token should be passed in if you know that you have locked the object

        some other way, and need to synchronise this object's state with that

        fact.

        XXX: this docstring is duplicated in many places, e.g. lockable_files.py

        :param token: if this is already locked, then lock_write will fail

            unless the token matches the existing lock.

        :returns: a token if this instance supports tokens, otherwise None.

        :raises TokenLockingNotSupported: when a token is given but this

            instance doesn't support using token locks.

        :raises MismatchedToken: if the specified token doesn't match the token

            of the existing lock.

        :seealso: start_write_group.

        :return: A RepositoryWriteLockResult.

        """

        locked = self.is_locked()

        token = self.control_files.lock_write(token=token)

        if not locked:

            self._warn_if_deprecated()

            self._note_lock('w')

            for repo in self._fallback_repositories:

                # Writes don't affect fallback repos

                repo.lock_read()

            self._refresh_data()

        return RepositoryWriteLockResult(self.unlock, token)

    def lock_read(self):

        """Lock the repository for read operations.

        :return: An object with an unlock method which will release the lock

            obtained.

        """

        locked = self.is_locked()

        self.control_files.lock_read()

        if not locked:

            self._warn_if_deprecated()

            self._note_lock('r')

            for repo in self._fallback_repositories:

                repo.lock_read()

            self._refresh_data()

        return LogicalLockResult(self.unlock)

    def get_physical_lock_status(self):

        return self.control_files.get_physical_lock_status()

    def leave_lock_in_place(self):

        """Tell this repository not to release the physical lock when this

        object is unlocked.

        If lock_write doesn't return a token, then this method is not supported.

        """

        self.control_files.leave_in_place()

    def dont_leave_lock_in_place(self):

        """Tell this repository to release the physical lock when this

        object is unlocked, even if it didn't originally acquire it.

        If lock_write doesn't return a token, then this method is not supported.

        """

        self.control_files.dont_leave_in_place()

    @needs_read_lock

    def gather_stats(self, revid=None, committers=None):

        """Gather statistics from a revision id.

        :param revid: The revision id to gather statistics from, if None, then

            no revision specific statistics are gathered.

        :param committers: Optional parameter controlling whether to grab

            a count of committers from the revision specific statistics.

        :return: A dictionary of statistics. Currently this contains:

            committers: The number of committers if requested.

            firstrev: A tuple with timestamp, timezone for the penultimate left

                most ancestor of revid, if revid is not the NULL_REVISION.

            latestrev: A tuple with timestamp, timezone for revid, if revid is

                not the NULL_REVISION.

            revisions: The total revision count in the repository.

            size: An estimate disk size of the repository in bytes.

        """

        result = {}

        if revid and committers:

            result['committers'] = 0

        if revid and revid != _mod_revision.NULL_REVISION:

            if committers:

                all_committers = set()

            revisions = self.get_ancestry(revid)

            # pop the leading None

            revisions.pop(0)

            first_revision = None

            if not committers:

                # ignore the revisions in the middle - just grab first and last

                revisions = revisions[0], revisions[-1]

            for revision in self.get_revisions(revisions):

                if not first_revision:

                    first_revision = revision

                if committers:

                    all_committers.add(revision.committer)

            last_revision = revision

            if committers:

                result['committers'] = len(all_committers)

            result['firstrev'] = (first_revision.timestamp,

                first_revision.timezone)

            result['latestrev'] = (last_revision.timestamp,

                last_revision.timezone)

        return result

    def find_branches(self, using=False):

        """Find branches underneath this repository.

        This will include branches inside other branches.

        :param using: If True, list only branches using this repository.

        """

        if using and not self.is_shared():

            return self.bzrdir.list_branches()

        class Evaluator(object):

            def __init__(self):

                self.first_call = True

            def __call__(self, bzrdir):

                # On the first call, the parameter is always the bzrdir

                # containing the current repo.

                if not self.first_call:

                    try:

                        repository = bzrdir.open_repository()

                    except errors.NoRepositoryPresent:

                        pass

                    else:

                        return False, ([], repository)

                self.first_call = False

                value = (bzrdir.list_branches(), None)

                return True, value

        ret = []

        for branches, repository in bzrdir.BzrDir.find_bzrdirs(

                self.user_transport, evaluate=Evaluator()):

            if branches is not None:

                ret.extend(branches)

            if not using and repository is not None:

                ret.extend(repository.find_branches())

        return ret

    @needs_read_lock

    def search_missing_revision_ids(self, other,

            revision_id=symbol_versioning.DEPRECATED_PARAMETER,

            find_ghosts=True, revision_ids=None, if_present_ids=None,

            limit=None):

        """Return the revision ids that other has that this does not.

        These are returned in topological order.

        revision_id: only return revision ids included by revision_id.

        """

        if symbol_versioning.deprecated_passed(revision_id):

            symbol_versioning.warn(

                'search_missing_revision_ids(revision_id=...) was '

                'deprecated in 2.4.  Use revision_ids=[...] instead.',

                DeprecationWarning, stacklevel=3)

            if revision_ids is not None:

                raise AssertionError(

                    'revision_ids is mutually exclusive with revision_id')

            if revision_id is not None:

                revision_ids = [revision_id]

        return InterRepository.get(other, self).search_missing_revision_ids(

            find_ghosts=find_ghosts, revision_ids=revision_ids,

            if_present_ids=if_present_ids, limit=limit)

    @staticmethod

    def open(base):

        """Open the repository rooted at base.

        For instance, if the repository is at URL/.bzr/repository,

        Repository.open(URL) -> a Repository instance.

        """

        control = bzrdir.BzrDir.open(base)

        return control.open_repository()

    def copy_content_into(self, destination, revision_id=None):

        """Make a complete copy of the content in self into destination.

        This is a destructive operation! Do not use it on existing

        repositories.

        """

        return InterRepository.get(self, destination).copy_content(revision_id)

    def commit_write_group(self):

        """Commit the contents accrued within the current write group.

        :seealso: start_write_group.

        :return: it may return an opaque hint that can be passed to 'pack'.

        """

        if self._write_group is not self.get_transaction():

            # has an unlock or relock occured ?

            raise errors.BzrError('mismatched lock context %r and '

                'write group %r.' %

                (self.get_transaction(), self._write_group))

        result = self._commit_write_group()

        self._write_group = None

        return result

    def _commit_write_group(self):

        """Template method for per-repository write group cleanup.

        This is called before the write group is considered to be

        finished and should ensure that all data handed to the repository

        for writing during the write group is safely committed (to the

        extent possible considering file system caching etc).

        """

    def suspend_write_group(self):

        raise errors.UnsuspendableWriteGroup(self)

    def refresh_data(self):

        """Re-read any data needed to synchronise with disk.

        This method is intended to be called after another repository instance

        (such as one used by a smart server) has inserted data into the

        repository. On all repositories this will work outside of write groups.

        Some repository formats (pack and newer for bzrlib native formats)

        support refresh_data inside write groups. If called inside a write

        group on a repository that does not support refreshing in a write group

        IsInWriteGroupError will be raised.

        """

        self._refresh_data()

    def resume_write_group(self, tokens):

        if not self.is_write_locked():

            raise errors.NotWriteLocked(self)

        if self._write_group:

            raise errors.BzrError('already in a write group')

        self._resume_write_group(tokens)

        # so we can detect unlock/relock - the write group is now entered.

        self._write_group = self.get_transaction()

    def _resume_write_group(self, tokens):

        raise errors.UnsuspendableWriteGroup(self)

    def fetch(self, source, revision_id=None, find_ghosts=False,

            fetch_spec=None):

        """Fetch the content required to construct revision_id from source.

        If revision_id is None and fetch_spec is None, then all content is

        copied.

        fetch() may not be used when the repository is in a write group -

        either finish the current write group before using fetch, or use

        fetch before starting the write group.

        :param find_ghosts: Find and copy revisions in the source that are

            ghosts in the target (and not reachable directly by walking out to

            the first-present revision in target from revision_id).

        :param revision_id: If specified, all the content needed for this

            revision ID will be copied to the target.  Fetch will determine for

            itself which content needs to be copied.

        :param fetch_spec: If specified, a SearchResult or

            PendingAncestryResult that describes which revisions to copy.  This

            allows copying multiple heads at once.  Mutually exclusive with

            revision_id.

        """

        if fetch_spec is not None and revision_id is not None:

            raise AssertionError(

                "fetch_spec and revision_id are mutually exclusive.")

        if self.is_in_write_group():

            raise errors.InternalBzrError(

                "May not fetch while in a write group.")

        # fast path same-url fetch operations