/brz/remove-bazaar

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

import re

import time

from bzrlib import (

    bzrdir,

    check,

    chk_map,

    debug,

    errors,

    fifo_cache,

    generate_ids,

    gpg,

    graph,

    inventory,

    lazy_regex,

    lockable_files,

    lockdir,

    lru_cache,

    osutils,

    revision as _mod_revision,

    symbol_versioning,

    tsort,

    ui,

    versionedfile,

    )

from bzrlib.bundle import serializer

from bzrlib.revisiontree import RevisionTree

from bzrlib.store.versioned import VersionedFileStore

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,

    entry_factory,

    )

from bzrlib import registry

from bzrlib.symbol_versioning import (

        deprecated_method,

        )

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

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

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

        self._basis_delta = []

        # API compatibility, older code that used CommitBuilder did not call

        # .record_delete(), which means the delta that is computed would not be

        # valid. Callers that will call record_delete() should call

        # .will_record_deletes() to indicate that.

        self._recording_deletes = False

        # memo'd check for no-op commits.

        self._any_changes = False

    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.

        """

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

        """

        self._validate_unicode_text(message, 'commit message')

        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.

        """

        if self.new_inventory is None:

            self.new_inventory = self.repository.get_inventory(

                self._new_revision_id)

        return RevisionTree(self.repository, self.new_inventory,

            self._new_revision_id)

    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.

        """

        if self.new_inventory is None:

            # an inventory delta was accumulated without creating a new

            # inventory.

            basis_id = self.basis_delta_revision

            self.inv_sha1 = self.repository.add_inventory_by_delta(

                basis_id, self._basis_delta, self._new_revision_id,

                self.parents)

        else:

            if self.new_inventory.root is None:

                raise AssertionError('Root entry should be supplied to'

                    ' record_entry_contents, as of bzr 0.10.')

                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

                )

        return self._new_revision_id

    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 _require_root_change(self, tree):

        """Enforce an appropriate root object change.

        This is called once when record_iter_changes is called, if and only if

        the root was not in the delta calculated by record_iter_changes.

        :param tree: The tree which is being committed.

        """

        # NB: if there are no parents then this method is not called, so no

        # need to guard on parents having length.

        entry = entry_factory['directory'](tree.path2id(''), '',

            None)

        entry.revision = self._new_revision_id

        self._basis_delta.append(('', '', entry.file_id, entry))

    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

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

            self._basis_delta.append(result)

            return result

        elif ie != basis_inv[ie.file_id]:

            # common but altered

            # TODO: avoid tis id2path call.

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

            self._basis_delta.append(result)

            return result

        else:

            # common, unaltered

            return None

    def get_basis_delta(self):

        """Return the complete inventory delta versus the basis inventory.

        This has been built up with the calls to record_delete and

        record_entry_contents. The client must have already called

        will_record_deletes() to indicate that they will be generating a

        complete delta.

        :return: An inventory delta, suitable for use with apply_delta, or

            Repository.add_inventory_by_delta, etc.

        """

        if not self._recording_deletes:

            raise AssertionError("recording deletes not activated.")

        return self._basis_delta

    def record_delete(self, path, file_id):

        """Record that a delete occured against a basis tree.

        This is an optional API - when used it adds items to the basis_delta

        being accumulated by the commit builder. It cannot be called unless the

        method will_record_deletes() has been called to inform the builder that

        a delta is being supplied.

        :param path: The path of the thing deleted.

        :param file_id: The file id that was deleted.

        """

        if not self._recording_deletes:

            raise AssertionError("recording deletes not activated.")

        delta = (path, None, file_id, None)

        self._basis_delta.append(delta)

        self._any_changes = True

        return delta

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

        """

        self._recording_deletes = True

        try:

            basis_id = self.parents[0]

        except IndexError:

            basis_id = _mod_revision.NULL_REVISION

        self.basis_delta_revision = basis_id

    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, fs_hash).

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

            fs_hash is either None, or the hash details for the path (currently

            a tuple of the contents sha1 and the statvalue returned by

            tree.get_file_with_stat()).

        """

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

                # specifically, they do not record a revision on the root; and

                # the rev id is assigned to the root during deserialisation -

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

                # To match this we always issue a delta, because the revision

                # of the root will always be changing.

                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)

                self._basis_delta.append(delta)

                return delta, False, None

            else:

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

                # determined that an existing revision of this file is

                # appropriate. If its not being considered for committing then

                # it and all its parents to the root must be unaltered so

                # no-change against the basis.

                if ie.revision == self._new_revision_id:

                    raise AssertionError("Impossible situation, a skipped "

                        "inventory entry (%r) claims to be modified in this "

                        "commit (%r).", (ie, self._new_revision_id))

                return None, False, None

        # 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

        # Stat cache fingerprint feedback for the caller - None as we usually

        # don't generate one.

        fingerprint = None

        if kind == 'file':

            if content_summary[2] is None:

                raise ValueError("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, None

                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]

            file_obj, stat_value = tree.get_file_with_stat(ie.file_id, path)

            try:

                text = file_obj.read()

            finally:

                file_obj.close()

            try:

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

                    ie.file_id, text, heads, nostore_sha)

                # Let the caller know we generated a stat fingerprint.

                fingerprint = (ie.text_sha1, stat_value)

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

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

            self._add_text_to_weave(ie.file_id, '', 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, None

            ie.symlink_target = current_link_target

            self._add_text_to_weave(ie.file_id, '', 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, None

            ie.reference_revision = content_summary[3]

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

        else:

            raise NotImplementedError('unknown kind')

        ie.revision = self._new_revision_id

        self._any_changes = True

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

    def record_iter_changes(self, tree, basis_revision_id, iter_changes,

        _entry_factory=entry_factory):

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

        :param _entry_factory: Private method to bind entry_factory locally for

            performance.

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

            tree._observed_sha1.

        """

        # Create an inventory delta based on deltas between all the parents and

        # deltas between all the parent inventories. We use inventory delta's 

        # between the inventory objects because iter_changes masks

        # last-changed-field only changes.

        # Working data:

        # file_id -> change map, change is fileid, paths, changed, versioneds,

        # parents, names, kinds, executables

        merged_ids = {}

        # {file_id -> revision_id -> inventory entry, for entries in parent

        # trees that are not parents[0]

        parent_entries = {}

        ghost_basis = False

        try:

            revtrees = list(self.repository.revision_trees(self.parents))

        except errors.NoSuchRevision:

            # one or more ghosts, slow path.

            revtrees = []

            for revision_id in self.parents:

                try:

                    revtrees.append(self.repository.revision_tree(revision_id))

                except errors.NoSuchRevision:

                    if not revtrees:

                        basis_revision_id = _mod_revision.NULL_REVISION

                        ghost_basis = True

                    revtrees.append(self.repository.revision_tree(

                        _mod_revision.NULL_REVISION))

        # The basis inventory from a repository 

        if revtrees:

            basis_inv = revtrees[0].inventory

        else:

            basis_inv = self.repository.revision_tree(

                _mod_revision.NULL_REVISION).inventory

        if len(self.parents) > 0:

            if basis_revision_id != self.parents[0] and not ghost_basis:

                raise Exception(

                    "arbitrary basis parents not yet supported with merges")

            for revtree in revtrees[1:]:

                for change in revtree.inventory._make_delta(basis_inv):

                    if change[1] is None:

                        # Not present in this parent.

                        continue

                    if change[2] not in merged_ids:

                        if change[0] is not None:

                            basis_entry = basis_inv[change[2]]

                            merged_ids[change[2]] = [

                                # basis revid

                                basis_entry.revision,

                                # new tree revid

                                change[3].revision]

                            parent_entries[change[2]] = {

                                # basis parent

                                basis_entry.revision:basis_entry,

                                # this parent 

                                change[3].revision:change[3],

                                }

                        else:

                            merged_ids[change[2]] = [change[3].revision]

                            parent_entries[change[2]] = {change[3].revision:change[3]}

                    else:

                        merged_ids[change[2]].append(change[3].revision)

                        parent_entries[change[2]][change[3].revision] = change[3]

        else:

            merged_ids = {}

        # Setup the changes from the tree:

        # changes maps file_id -> (change, [parent revision_ids])

        changes= {}

        for change in iter_changes:

            # This probably looks up in basis_inv way to much.

            if change[1][0] is not None:

                head_candidate = [basis_inv[change[0]].revision]

            else:

                head_candidate = []

            changes[change[0]] = change, merged_ids.get(change[0],

                head_candidate)

        unchanged_merged = set(merged_ids) - set(changes)

        # Extend the changes dict with synthetic changes to record merges of

        # texts.

        for file_id in unchanged_merged:

            # Record a merged version of these items that did not change vs the

            # basis. This can be either identical parallel changes, or a revert

            # of a specific file after a merge. The recorded content will be

            # that of the current tree (which is the same as the basis), but

            # the per-file graph will reflect a merge.

            # NB:XXX: We are reconstructing path information we had, this

            # should be preserved instead.

            # inv delta  change: (file_id, (path_in_source, path_in_target),

            #   changed_content, versioned, parent, name, kind,

            #   executable)

            try:

                basis_entry = basis_inv[file_id]

            except errors.NoSuchId:

                # a change from basis->some_parents but file_id isn't in basis

                # so was new in the merge, which means it must have changed

                # from basis -> current, and as it hasn't the add was reverted

                # by the user. So we discard this change.

                pass

            else:

                change = (file_id,

                    (basis_inv.id2path(file_id), tree.id2path(file_id)),

                    False, (True, True),

                    (basis_entry.parent_id, basis_entry.parent_id),

                    (basis_entry.name, basis_entry.name),

                    (basis_entry.kind, basis_entry.kind),

                    (basis_entry.executable, basis_entry.executable))

                changes[file_id] = (change, merged_ids[file_id])

        # changes contains tuples with the change and a set of inventory

        # candidates for the file.

        # inv delta is:

        # old_path, new_path, file_id, new_inventory_entry

        seen_root = False # Is the root in the basis delta?

        inv_delta = self._basis_delta

        modified_rev = self._new_revision_id

        for change, head_candidates in changes.values():

            if change[3][1]: # versioned in target.

                # Several things may be happening here:

                # We may have a fork in the per-file graph

                #  - record a change with the content from tree

                # We may have a change against < all trees  

                #  - carry over the tree that hasn't changed

                # We may have a change against all trees

                #  - record the change with the content from tree

                kind = change[6][1]