/brz/remove-bazaar

# 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

from cStringIO import StringIO

from bzrlib.lazy_import import lazy_import

lazy_import(globals(), """

import re

import time

from bzrlib import (

    bzrdir,

    check,

    deprecated_graph,

    errors,

    generate_ids,

    gpg,

    graph,

    lazy_regex,

    lockable_files,

    lockdir,

    osutils,

    registry,

    remote,

    revision as _mod_revision,

    symbol_versioning,

    transactions,

    ui,

    )

from bzrlib.bundle import serializer

from bzrlib.revisiontree import RevisionTree

from bzrlib.store.versioned import VersionedFileStore

from bzrlib.store.text import TextStore

from bzrlib.testament import Testament

""")

from bzrlib.decorators import needs_read_lock, needs_write_lock

from bzrlib.inter import InterObject

from bzrlib.inventory import Inventory, InventoryDirectory, ROOT_ID

from bzrlib.symbol_versioning import (

        deprecated_method,

        )

from bzrlib.trace import mutter, note, warning

# Old formats display a warning, but only once

_deprecation_warning_done = False

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

# Repositories

class Repository(object):

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

    The Repository builds on top of Stores and a Transport, which respectively 

    describe the disk data format and the way of accessing the (possibly 

    remote) disk.

    """

    _file_ids_altered_regex = lazy_regex.lazy_compile(

        r'file_id="(?P<file_id>[^"]+)"'

        r'.*revision="(?P<revision_id>[^"]+)"'

        )

    def abort_write_group(self):

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

        :seealso: start_write_group.

        """

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

            # has an unlock or relock occured ?

            raise errors.BzrError('mismatched lock context and write group.')

        self._abort_write_group()

        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.

        """

    @needs_write_lock

    def add_inventory(self, revision_id, inv, parents):

        """Add the inventory inv to the repository as revision_id.

        :param parents: The revision ids of the parents that revision_id

                        is known to have and are in the repository already.

        returns the sha1 of the serialized inventory.

        """

        revision_id = osutils.safe_revision_id(revision_id)

        _mod_revision.check_not_reserved_id(revision_id)

        assert inv.revision_id is None or inv.revision_id == revision_id, \

            "Mismatch between inventory revision" \

            " id and insertion revid (%r, %r)" % (inv.revision_id, revision_id)

        assert inv.root is not None

        inv_text = self.serialise_inventory(inv)

        inv_sha1 = osutils.sha_string(inv_text)

        inv_vf = self.control_weaves.get_weave('inventory',

                                               self.get_transaction())

        self._inventory_add_lines(inv_vf, revision_id, parents,

                                  osutils.split_lines(inv_text))

        return inv_sha1

    def _inventory_add_lines(self, inv_vf, revision_id, parents, lines):

        final_parents = []

        for parent in parents:

            if parent in inv_vf:

                final_parents.append(parent)

        inv_vf.add_lines(revision_id, final_parents, lines)

    @needs_write_lock

    def add_revision(self, revision_id, rev, inv=None, config=None):

        """Add rev to the revision store as revision_id.

        :param revision_id: the revision id to use.

        :param rev: The revision object.

        :param inv: The inventory for the revision. if None, it will be looked

                    up in the inventory storer

        :param config: If None no digital signature will be created.

                       If supplied its signature_needed method will be used

                       to determine if a signature should be made.

        """

        revision_id = osutils.safe_revision_id(revision_id)

        # TODO: jam 20070210 Shouldn't we check rev.revision_id and

        #       rev.parent_ids?

        _mod_revision.check_not_reserved_id(revision_id)

        if config is not None and config.signature_needed():

            if inv is None:

                inv = self.get_inventory(revision_id)

            plaintext = Testament(rev, inv).as_short_text()

            self.store_revision_signature(

                gpg.GPGStrategy(config), plaintext, revision_id)

        if not revision_id in self.get_inventory_weave():

            if inv is None:

                raise errors.WeaveRevisionNotPresent(revision_id,

                                                     self.get_inventory_weave())

            else:

                # yes, this is not suitable for adding with ghosts.

                self.add_inventory(revision_id, inv, rev.parent_ids)

        self._revision_store.add_revision(rev, self.get_transaction())

    def _add_revision_text(self, revision_id, text):

        revision = self._revision_store._serializer.read_revision_from_string(

            text)

        self._revision_store._add_revision(revision, StringIO(text),

                                           self.get_transaction())

    @needs_read_lock

    def _all_possible_ids(self):

        """Return all the possible revisions that we could find."""

        return self.get_inventory_weave().versions()

    def all_revision_ids(self):

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

        This is 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.

        """

        return self._all_revision_ids()

    @needs_read_lock

    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: for weaves ghosts may lead to a lack of correctness until

        the reweave updates the parents list.

        """

        if self._revision_store.text_store.listable():

            return self._revision_store.all_revision_ids(self.get_transaction())

        result = self._all_possible_ids()

        # TODO: jam 20070210 Ensure that _all_possible_ids returns non-unicode

        #       ids. (It should, since _revision_store's API should change to

        #       return utf8 revision_ids)

        return self._eliminate_revisions_not_present(result)

    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 = []

        for id in revision_ids:

            if self.has_revision(id):

               result.append(id)

        return result

    @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, _revision_store, control_store, text_store):

        """instantiate a Repository.

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

        :param a_bzrdir: The BzrDir of the repository.

        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._revision_store = _revision_store

        # backwards compatibility

        self.weave_store = text_store

        # not right yet - should be more semantically clear ? 

        # 

        self.control_store = control_store

        self.control_weaves = control_store

        # TODO: make sure to construct the right store classes, etc, depending

        # on whether escaping is required.

        self._warn_if_deprecated()

        self._write_group = None

    def __repr__(self):

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

                           self.bzrdir.transport.base)

    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.control_files._transport.base ==

                other.control_files._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 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.

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

        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

        """

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

        self._refresh_data()

        return result

    def lock_read(self):

        self.control_files.lock_read()

        self._refresh_data()

    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)

        # now gather global repository information

        if self.bzrdir.root_transport.listable():

            c, t = self._revision_store.total_size(self.get_transaction())

            result['revisions'] = c

            result['size'] = t

        return result

    @needs_read_lock

    def missing_revision_ids(self, other, revision_id=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.

        """

        revision_id = osutils.safe_revision_id(revision_id)

        return InterRepository.get(other, self).missing_revision_ids(revision_id)

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

        """

        revision_id = osutils.safe_revision_id(revision_id)

        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.

        """

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

            # has an unlock or relock occured ?

            raise errors.BzrError('mismatched lock context and write group.')

        self._commit_write_group()

        self._write_group = None

    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 fetch(self, source, revision_id=None, pb=None):

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

        If revision_id is None all content is copied.

        """

        revision_id = osutils.safe_revision_id(revision_id)

        inter = InterRepository.get(source, self)

        try:

            return inter.fetch(revision_id=revision_id, pb=pb)

        except NotImplementedError:

            raise errors.IncompatibleRepositories(source, self)

    def create_bundle(self, target, base, fileobj, format=None):

        return serializer.write_bundle(self, target, base, fileobj, format)

    def get_commit_builder(self, branch, parents, config, timestamp=None, 

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

                           revision_id=None):

        """Obtain a CommitBuilder for this repository.

        :param branch: Branch to commit to.

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

        :param config: Configuration to use.

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

        """

        revision_id = osutils.safe_revision_id(revision_id)

        result =_CommitBuilder(self, parents, config, timestamp, timezone,

                              committer, revprops, revision_id)

        self.start_write_group()

        return result

    def unlock(self):

        if (self.control_files._lock_count == 1 and

            self.control_files._lock_mode == 'w'):

            if self._write_group is not None:

                raise errors.BzrError(

                    'Must end write groups before releasing write locks.')

        self.control_files.unlock()

    @needs_read_lock

    def clone(self, a_bzrdir, revision_id=None):

        """Clone this repository into a_bzrdir using the current format.

        Currently no check is made that the format of this repository and

        the bzrdir format are compatible. FIXME RBC 20060201.

        :return: The newly created destination repository.

        """

        # TODO: deprecate after 0.16; cloning this with all its settings is

        # probably not very useful -- mbp 20070423

        dest_repo = self._create_sprouting_repo(a_bzrdir, shared=self.is_shared())

        self.copy_content_into(dest_repo, revision_id)

        return dest_repo

    def start_write_group(self):

        """Start a write group in the repository.

        Write groups are used by repositories which do not have a 1:1 mapping

        between file ids and backend store to manage the insertion of data from

        both fetch and commit operations.

        A write lock is required around the start_write_group/commit_write_group

        for the support of lock-requiring repository formats.

        One can only insert data into a repository inside a write group.

        :return: None.

        """

        if not self.is_locked() or self.control_files._lock_mode != 'w':

            raise errors.NotWriteLocked(self)

        if self._write_group:

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

        self._start_write_group()

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

        self._write_group = self.get_transaction()

    def _start_write_group(self):

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

        This is called before the write group is considered to be 

        entered.

        """

    @needs_read_lock

    def sprout(self, to_bzrdir, revision_id=None):

        """Create a descendent repository for new development.

        Unlike clone, this does not copy the settings of the repository.

        """

        dest_repo = self._create_sprouting_repo(to_bzrdir, shared=False)

        dest_repo.fetch(self, revision_id=revision_id)

        return dest_repo

    def _create_sprouting_repo(self, a_bzrdir, shared):

        if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):

            # use target default format.

            dest_repo = a_bzrdir.create_repository()

        else:

            # Most control formats need the repository to be specifically

            # created, but on some old all-in-one formats it's not needed

            try:

                dest_repo = self._format.initialize(a_bzrdir, shared=shared)

            except errors.UninitializableFormat:

                dest_repo = a_bzrdir.open_repository()

        return dest_repo

    @needs_read_lock

    def has_revision(self, revision_id):

        """True if this repository has a copy of the revision."""

        revision_id = osutils.safe_revision_id(revision_id)

        return self._revision_store.has_revision_id(revision_id,

                                                    self.get_transaction())

    @needs_read_lock

    def get_revision_reconcile(self, revision_id):

        """'reconcile' helper routine that allows access to a revision always.

        This variant of get_revision does not cross check the weave graph

        against the revision one as get_revision does: but it should only

        be used by reconcile, or reconcile-alike commands that are correcting

        or testing the revision graph.

        """

        if not revision_id or not isinstance(revision_id, basestring):

            raise errors.InvalidRevisionId(revision_id=revision_id,

                                           branch=self)

        return self.get_revisions([revision_id])[0]

    @needs_read_lock

    def get_revisions(self, revision_ids):

        revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]

        revs = self._revision_store.get_revisions(revision_ids,

                                                  self.get_transaction())

        for rev in revs:

            assert not isinstance(rev.revision_id, unicode)

            for parent_id in rev.parent_ids:

                assert not isinstance(parent_id, unicode)

        return revs

    @needs_read_lock

    def get_revision_xml(self, revision_id):

        # TODO: jam 20070210 This shouldn't be necessary since get_revision

        #       would have already do it.

        # TODO: jam 20070210 Just use _serializer.write_revision_to_string()

        revision_id = osutils.safe_revision_id(revision_id)

        rev = self.get_revision(revision_id)

        rev_tmp = StringIO()

        # the current serializer..

        self._revision_store._serializer.write_revision(rev, rev_tmp)

        rev_tmp.seek(0)

        return rev_tmp.getvalue()

    @needs_read_lock

    def get_revision(self, revision_id):

        """Return the Revision object for a named revision"""

        # TODO: jam 20070210 get_revision_reconcile should do this for us

        revision_id = osutils.safe_revision_id(revision_id)

        r = self.get_revision_reconcile(revision_id)

        # weave corruption can lead to absent revision markers that should be

        # present.

        # the following test is reasonably cheap (it needs a single weave read)

        # and the weave is cached in read transactions. In write transactions

        # it is not cached but typically we only read a small number of

        # revisions. For knits when they are introduced we will probably want

        # to ensure that caching write transactions are in use.

        inv = self.get_inventory_weave()

        self._check_revision_parents(r, inv)

        return r

    @needs_read_lock

    def get_deltas_for_revisions(self, revisions):

        """Produce a generator of revision deltas.

        Note that the input is a sequence of REVISIONS, not revision_ids.

        Trees will be held in memory until the generator exits.

        Each delta is relative to the revision's lefthand predecessor.

        """

        required_trees = set()

        for revision in revisions:

            required_trees.add(revision.revision_id)

            required_trees.update(revision.parent_ids[:1])

        trees = dict((t.get_revision_id(), t) for 

                     t in self.revision_trees(required_trees))

        for revision in revisions:

            if not revision.parent_ids:

                old_tree = self.revision_tree(None)

            else:

                old_tree = trees[revision.parent_ids[0]]

            yield trees[revision.revision_id].changes_from(old_tree)

    @needs_read_lock

    def get_revision_delta(self, revision_id):

        """Return the delta for one revision.

        The delta is relative to the left-hand predecessor of the

        revision.

        """

        r = self.get_revision(revision_id)

        return list(self.get_deltas_for_revisions([r]))[0]

    def _check_revision_parents(self, revision, inventory):

        """Private to Repository and Fetch.

        This checks the parentage of revision in an inventory weave for 

        consistency and is only applicable to inventory-weave-for-ancestry

        using repository formats & fetchers.

        """

        weave_parents = inventory.get_parents(revision.revision_id)

        weave_names = inventory.versions()

        for parent_id in revision.parent_ids:

            if parent_id in weave_names:

                # this parent must not be a ghost.

                if not parent_id in weave_parents:

                    # but it is a ghost

                    raise errors.CorruptRepository(self)

    @needs_write_lock

    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):

        revision_id = osutils.safe_revision_id(revision_id)

        signature = gpg_strategy.sign(plaintext)

        self._revision_store.add_revision_signature_text(revision_id,

                                                         signature,

                                                         self.get_transaction())

    def fileids_altered_by_revision_ids(self, revision_ids):

        """Find the file ids and versions affected by revisions.

        :param revisions: an iterable containing revision ids.

        :return: a dictionary mapping altered file-ids to an iterable of

        revision_ids. Each altered file-ids has the exact revision_ids that

        altered it listed explicitly.

        """

        assert self._serializer.support_altered_by_hack, \

            ("fileids_altered_by_revision_ids only supported for branches " 

             "which store inventory as unnested xml, not on %r" % self)

        selected_revision_ids = set(osutils.safe_revision_id(r)

                                    for r in revision_ids)

        w = self.get_inventory_weave()

        result = {}

        # this code needs to read every new line in every inventory for the

        # inventories [revision_ids]. Seeing a line twice is ok. Seeing a line

        # not present in one of those inventories is unnecessary but not 

        # harmful because we are filtering by the revision id marker in the

        # inventory lines : we only select file ids altered in one of those  

        # revisions. We don't need to see all lines in the inventory because

        # only those added in an inventory in rev X can contain a revision=X

        # line.

        unescape_revid_cache = {}

        unescape_fileid_cache = {}

        # jam 20061218 In a big fetch, this handles hundreds of thousands

        # of lines, so it has had a lot of inlining and optimizing done.

        # Sorry that it is a little bit messy.

        # Move several functions to be local variables, since this is a long

        # running loop.

        search = self._file_ids_altered_regex.search

        unescape = _unescape_xml

        setdefault = result.setdefault

        pb = ui.ui_factory.nested_progress_bar()

        try:

            for line in w.iter_lines_added_or_present_in_versions(

                                        selected_revision_ids, pb=pb):

                match = search(line)

                if match is None:

                    continue

                # One call to match.group() returning multiple items is quite a

                # bit faster than 2 calls to match.group() each returning 1