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

    debug,

    deprecated_graph,

    errors,

    generate_ids,

    gpg,

    graph,

    lazy_regex,

    lockable_files,

    lockdir,

    lru_cache,

    osutils,

    registry,

    remote,

    revision as _mod_revision,

    symbol_versioning,

    transactions,

    tsort,

    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.util import bencode

""")

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, mutter_callsite, note, warning

# Old formats display a warning, but only once

_deprecation_warning_done = False

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

    # the default CommitBuilder does not manage trees whose root is versioned.

    _versioned_root = False

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

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

                 revision_id=None):

        """Initiate a CommitBuilder.

        :param repository: Repository 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.

        """

        self._config = config

        if committer is None:

            self._committer = self._config.username()

        else:

            assert isinstance(committer, basestring), type(committer)

            self._committer = committer

        self.new_inventory = Inventory(None)

        self._new_revision_id = revision_id

        self.parents = parents

        self.repository = repository

        self._revprops = {}

        if revprops is not None:

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

        self.__heads = graph.HeadsCache(repository.get_graph()).heads

    def commit(self, message):

        """Make the actual commit.

        :return: The revision id of the recorded revision.

        """

        rev = _mod_revision.Revision(

                       timestamp=self._timestamp,

                       timezone=self._timezone,

                       committer=self._committer,

                       message=message,

                       inventory_sha1=self.inv_sha1,

                       revision_id=self._new_revision_id,

                       properties=self._revprops)

        rev.parent_ids = self.parents

        self.repository.add_revision(self._new_revision_id, rev,

            self.new_inventory, self._config)

        self.repository.commit_write_group()

        return self._new_revision_id

    def abort(self):

        """Abort the commit that is being built.

        """

        self.repository.abort_write_group()

    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.

        """

        return RevisionTree(self.repository, self.new_inventory,

                            self._new_revision_id)

    def finish_inventory(self):

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

        if self.new_inventory.root is None:

            raise AssertionError('Root entry should be supplied to'

                ' record_entry_contents, as of bzr 0.10.',

                 DeprecationWarning, stacklevel=2)

            self.new_inventory.add(InventoryDirectory(ROOT_ID, '', None))

        self.new_inventory.revision_id = self._new_revision_id

        self.inv_sha1 = self.repository.add_inventory(

            self._new_revision_id,

            self.new_inventory,

            self.parents

            )

    def _gen_revision_id(self):

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

        return generate_ids.gen_revision_id(self._config.username(),

                                            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 _heads(self, file_id, revision_ids):

        """Calculate the graph heads for revision_ids in the graph of file_id.

        This can use either a per-file graph or a global revision graph as we

        have an identity relationship between the two graphs.

        """

        return self.__heads(revision_ids)

    def _check_root(self, ie, parent_invs, tree):

        """Helper for record_entry_contents.

        :param ie: An entry being added.

        :param parent_invs: The inventories of the parent revisions of the

            commit.

        :param tree: The tree that is being committed.

        """

        # In this revision format, root entries have no knit or weave When

        # serializing out to disk and back in root.revision is always

        # _new_revision_id

        ie.revision = self._new_revision_id

    def _get_delta(self, ie, basis_inv, path):

        """Get a delta against the basis inventory for ie."""

        if ie.file_id not in basis_inv:

            # add

            return (None, path, ie.file_id, ie)

        elif ie != basis_inv[ie.file_id]:

            # common but altered

            # TODO: avoid tis id2path call.

            return (basis_inv.id2path(ie.file_id), path, ie.file_id, ie)

        else:

            # common, unaltered

            return None

    def record_entry_contents(self, ie, parent_invs, path, tree,

        content_summary):

        """Record the content of ie from tree into the commit if needed.

        Side effect: sets ie.revision when unchanged

        :param ie: An inventory entry present in the commit.

        :param parent_invs: The inventories of the parent revisions of the

            commit.

        :param path: The path the entry is at in the tree.

        :param tree: The tree which contains this entry and should be used to 

            obtain content.

        :param content_summary: Summary data from the tree about the paths

            content - stat, length, exec, sha/link target. This is only

            accessed when the entry has a revision of None - that is when it is

            a candidate to commit.

        :return: A tuple (change_delta, version_recorded). change_delta is 

            an inventory_delta change for this entry against the basis tree of

            the commit, or None if no change occured against the basis tree.

            version_recorded is True if a new version of the entry has been

            recorded. For instance, committing a merge where a file was only

            changed on the other side will return (delta, False).

        """

        if self.new_inventory.root is None:

            if ie.parent_id is not None:

                raise errors.RootMissing()

            self._check_root(ie, parent_invs, tree)

        if ie.revision is None:

            kind = content_summary[0]

        else:

            # ie is carried over from a prior commit

            kind = ie.kind

        # XXX: repository specific check for nested tree support goes here - if

        # the repo doesn't want nested trees we skip it ?

        if (kind == 'tree-reference' and

            not self.repository._format.supports_tree_reference):

            # mismatch between commit builder logic and repository:

            # this needs the entry creation pushed down into the builder.

            raise NotImplementedError('Missing repository subtree support.')

        self.new_inventory.add(ie)

        # TODO: slow, take it out of the inner loop.

        try:

            basis_inv = parent_invs[0]

        except IndexError:

            basis_inv = Inventory(root_id=None)

        # ie.revision is always None if the InventoryEntry is considered

        # for committing. We may record the previous parents revision if the

        # content is actually unchanged against a sole head.

        if ie.revision is not None:

            if not self._versioned_root and path == '':

                # repositories that do not version the root set the root's

                # revision to the new commit even when no change occurs, and

                # this masks when a change may have occurred against the basis,

                # so calculate if one happened.

                if ie.file_id in basis_inv:

                    delta = (basis_inv.id2path(ie.file_id), path,

                        ie.file_id, ie)

                else:

                    # add

                    delta = (None, path, ie.file_id, ie)

                return delta, False

            else:

                # we don't need to commit this, because the caller already

                # determined that an existing revision of this file is

                # appropriate.

                return None, (ie.revision == self._new_revision_id)

        # XXX: Friction: parent_candidates should return a list not a dict

        #      so that we don't have to walk the inventories again.

        parent_candiate_entries = ie.parent_candidates(parent_invs)

        head_set = self._heads(ie.file_id, parent_candiate_entries.keys())

        heads = []

        for inv in parent_invs:

            if ie.file_id in inv:

                old_rev = inv[ie.file_id].revision

                if old_rev in head_set:

                    heads.append(inv[ie.file_id].revision)

                    head_set.remove(inv[ie.file_id].revision)

        store = False

        # now we check to see if we need to write a new record to the

        # file-graph.

        # We write a new entry unless there is one head to the ancestors, and

        # the kind-derived content is unchanged.

        # Cheapest check first: no ancestors, or more the one head in the

        # ancestors, we write a new node.

        if len(heads) != 1:

            store = True

        if not store:

            # There is a single head, look it up for comparison

            parent_entry = parent_candiate_entries[heads[0]]

            # if the non-content specific data has changed, we'll be writing a

            # node:

            if (parent_entry.parent_id != ie.parent_id or

                parent_entry.name != ie.name):

                store = True

        # now we need to do content specific checks:

        if not store:

            # if the kind changed the content obviously has

            if kind != parent_entry.kind:

                store = True

        if kind == 'file':

            assert content_summary[2] is not None, \

                "Files must not have executable = None"

            if not store:

                if (# if the file length changed we have to store:

                    parent_entry.text_size != content_summary[1] or

                    # if the exec bit has changed we have to store:

                    parent_entry.executable != content_summary[2]):

                    store = True

                elif parent_entry.text_sha1 == content_summary[3]:

                    # all meta and content is unchanged (using a hash cache

                    # hit to check the sha)

                    ie.revision = parent_entry.revision

                    ie.text_size = parent_entry.text_size

                    ie.text_sha1 = parent_entry.text_sha1

                    ie.executable = parent_entry.executable

                    return self._get_delta(ie, basis_inv, path), False

                else:

                    # Either there is only a hash change(no hash cache entry,

                    # or same size content change), or there is no change on

                    # this file at all.

                    # Provide the parent's hash to the store layer, so that the

                    # content is unchanged we will not store a new node.

                    nostore_sha = parent_entry.text_sha1

            if store:

                # We want to record a new node regardless of the presence or

                # absence of a content change in the file.

                nostore_sha = None

            ie.executable = content_summary[2]

            lines = tree.get_file(ie.file_id, path).readlines()

            try:

                ie.text_sha1, ie.text_size = self._add_text_to_weave(

                    ie.file_id, lines, heads, nostore_sha)

            except errors.ExistingContent:

                # Turns out that the file content was unchanged, and we were

                # only going to store a new node if it was changed. Carry over

                # the entry.

                ie.revision = parent_entry.revision

                ie.text_size = parent_entry.text_size

                ie.text_sha1 = parent_entry.text_sha1

                ie.executable = parent_entry.executable

                return self._get_delta(ie, basis_inv, path), False

        elif kind == 'directory':

            if not store:

                # all data is meta here, nothing specific to directory, so

                # carry over:

                ie.revision = parent_entry.revision

                return self._get_delta(ie, basis_inv, path), False

            lines = []

            self._add_text_to_weave(ie.file_id, lines, heads, None)

        elif kind == 'symlink':

            current_link_target = content_summary[3]

            if not store:

                # symlink target is not generic metadata, check if it has

                # changed.

                if current_link_target != parent_entry.symlink_target:

                    store = True

            if not store:

                # unchanged, carry over.

                ie.revision = parent_entry.revision

                ie.symlink_target = parent_entry.symlink_target

                return self._get_delta(ie, basis_inv, path), False

            ie.symlink_target = current_link_target

            lines = []

            self._add_text_to_weave(ie.file_id, lines, heads, None)

        elif kind == 'tree-reference':

            if not store:

                if content_summary[3] != parent_entry.reference_revision:

                    store = True

            if not store:

                # unchanged, carry over.

                ie.reference_revision = parent_entry.reference_revision

                ie.revision = parent_entry.revision

                return self._get_delta(ie, basis_inv, path), False

            ie.reference_revision = content_summary[3]

            lines = []

            self._add_text_to_weave(ie.file_id, lines, heads, None)

        else:

            raise NotImplementedError('unknown kind')

        ie.revision = self._new_revision_id

        return self._get_delta(ie, basis_inv, path), True

    def _add_text_to_weave(self, file_id, new_lines, parents, nostore_sha):

        versionedfile = self.repository.weave_store.get_weave_or_empty(

            file_id, self.repository.get_transaction())

        # Don't change this to add_lines - add_lines_with_ghosts is cheaper

        # than add_lines, and allows committing when a parent is ghosted for

        # some reason.

        # Note: as we read the content directly from the tree, we know its not

        # been turned into unicode or badly split - but a broken tree

        # implementation could give us bad output from readlines() so this is

        # not a guarantee of safety. What would be better is always checking

        # the content during test suite execution. RBC 20070912

        return versionedfile.add_lines_with_ghosts(

            self._new_revision_id, parents, new_lines,

            nostore_sha=nostore_sha, random_id=self.random_revid,

            check_content=False)[0:2]

class RootCommitBuilder(CommitBuilder):

    """This commitbuilder actually records the root id"""

    # the root entry gets versioned properly by this builder.

    _versioned_root = True

    def _check_root(self, ie, parent_invs, tree):

        """Helper for record_entry_contents.

        :param ie: An entry being added.

        :param parent_invs: The inventories of the parent revisions of the

            commit.

        :param tree: The tree that is being committed.

        """

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

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

    """

    # What class to use for a CommitBuilder. Often its simpler to change this

    # in a Repository class subclass rather than to override

    # get_commit_builder.

    _commit_builder_class = CommitBuilder

    # The search regex used by xml based repositories to determine what things

    # where changed in a single commit.

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

        """

    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 validator(which is a sha1 digest, though what is sha'd is

            repository format specific) of the serialized inventory.

        """

        assert self.is_in_write_group()

        _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_lines = self._serialise_inventory_to_lines(inv)

        inv_vf = self.get_inventory_weave()

        return self._inventory_add_lines(inv_vf, revision_id, parents,

            inv_lines, check_content=False)

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

        check_content=True):

        """Store lines in inv_vf and return the sha1 of the inventory."""

        final_parents = []

        for parent in parents:

            if parent in inv_vf:

                final_parents.append(parent)

        return inv_vf.add_lines(revision_id, final_parents, lines,

            check_content=check_content)[0]

    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.

        """

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

                rev.inventory_sha1 = 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())

    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.

        """

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

        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

        # for tests

        self._reconcile_does_inventory_gc = True

        self._reconcile_fixes_text_parents = False

        self._reconcile_backsup_inventory = True

        # 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

        self.base = control_files._transport.base

    def __repr__(self):

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

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

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