/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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

from bzrlib.lazy_import import lazy_import

lazy_import(globals(), """

import cStringIO

import re

import time

from bzrlib import (

    bzrdir,

    check,

    debug,

    errors,

    fifo_cache,

    generate_ids,

    gpg,

    graph,

    lazy_regex,

    lockable_files,

    lockdir,

    lru_cache,

    osutils,

    remote,

    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

from bzrlib import registry

from bzrlib.symbol_versioning import (

        deprecated_method,

        one_one,

        one_two,

        one_six,

        )

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

    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.

        """

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

            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

            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)

        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

    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:

                lines = file_obj.readlines()

            finally:

                file_obj.close()

            try:

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

                    ie.file_id, lines, 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

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

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

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

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

        # 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

        parent_keys = tuple((file_id, parent) for parent in parents)

        return self.repository.texts.add_lines(

            (file_id, self._new_revision_id), parent_keys, 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 some byte storage facilies (the revisions,

    signatures, inventories and texts attributes) and a Transport, which

    respectively provide byte storage and a means to access the (possibly

    remote) disk.

    The byte storage facilities are addressed via tuples, which we refer to

    as 'keys' throughout the code base. Revision_keys, inventory_keys and

    signature_keys are all 1-tuples: (revision_id,). text_keys are two-tuples:

    (file_id, revision_id). We use this interface because it allows low

    friction with the underlying code that implements disk indices, network

    encoding and other parts of bzrlib.

    :ivar revisions: A bzrlib.versionedfile.VersionedFiles instance containing

        the serialised revisions for the repository. This can be used to obtain

        revision graph information or to access raw serialised revisions.

        The result of trying to insert data into the repository via this store

        is undefined: it should be considered read-only except for implementors

        of repositories.

    :ivar signatures: A bzrlib.versionedfile.VersionedFiles instance containing

        the serialised signatures for the repository. This can be used to

        obtain access to raw serialised signatures.  The result of trying to

        insert data into the repository via this store is undefined: it should

        be considered read-only except for implementors of repositories.

    :ivar inventories: A bzrlib.versionedfile.VersionedFiles instance containing

        the serialised inventories for the repository. This can be used to

        obtain unserialised inventories.  The result of trying to insert data

        into the repository via this store is undefined: it should be

        considered read-only except for implementors of repositories.

    :ivar texts: A bzrlib.versionedfile.VersionedFiles instance containing the

        texts of files and directories for the repository. This can be used to

        obtain file texts or file graphs. Note that Repository.iter_file_bytes

        is usually a better interface for accessing file texts.

        The result of trying to insert data into the repository via this store

        is undefined: it should be considered read-only except for implementors

        of repositories.

    :ivar _transport: Transport for file access to repository, typically

        pointing to .bzr/repository.

    """

    # 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, 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 ?

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

        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.

        """

        if not self._format.supports_external_lookups:

            raise errors.UnstackableRepositoryFormat(self._format, self.base)

        self._check_fallback_repository(repository)

        self._fallback_repositories.append(repository)

        self.texts.add_fallback_versioned_files(repository.texts)

        self.inventories.add_fallback_versioned_files(repository.inventories)

        self.revisions.add_fallback_versioned_files(repository.revisions)

        self.signatures.add_fallback_versioned_files(repository.signatures)

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

        """

        if not self.is_in_write_group():

            raise AssertionError("%r not in write group" % (self,))

        _mod_revision.check_not_reserved_id(revision_id)

        if not (inv.revision_id is None or inv.revision_id == revision_id):

            raise AssertionError(

                "Mismatch between inventory revision"

                " id and insertion revid (%r, %r)"

                % (inv.revision_id, revision_id))

        if inv.root is None:

            raise AssertionError()

        inv_lines = self._serialise_inventory_to_lines(inv)

        return self._inventory_add_lines(revision_id, parents,

            inv_lines, check_content=False)

    def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,

                               parents):

        """Add a new inventory expressed as a delta against another revision.

        :param basis_revision_id: The inventory id the delta was created

            against. (This does not have to be a direct parent.)

        :param delta: The inventory delta (see Inventory.apply_delta for

            details).

        :param new_revision_id: The revision id that the inventory is being

            added for.

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

            known to have and are in the repository already. These are supplied

            for repositories that depend on the inventory graph for revision

            graph access, as well as for those that pun ancestry with delta

            compression.

        :returns: (validator, new_inv)

            The validator(which is a sha1 digest, though what is sha'd is

            repository format specific) of the serialized inventory, and the

            resulting inventory.

        """

        if not self.is_in_write_group():

            raise AssertionError("%r not in write group" % (self,))

        _mod_revision.check_not_reserved_id(new_revision_id)

        basis_tree = self.revision_tree(basis_revision_id)

        basis_tree.lock_read()

        try:

            # Note that this mutates the inventory of basis_tree, which not all

            # inventory implementations may support: A better idiom would be to

            # return a new inventory, but as there is no revision tree cache in

            # repository this is safe for now - RBC 20081013

            basis_inv = basis_tree.inventory

            basis_inv.apply_delta(delta)

            basis_inv.revision_id = new_revision_id

            return (self.add_inventory(new_revision_id, basis_inv, parents),

                    basis_inv)

        finally:

            basis_tree.unlock()

    def _inventory_add_lines(self, revision_id, parents, lines,

        check_content=True):

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

        parents = [(parent,) for parent in parents]

        return self.inventories.add_lines((revision_id,), 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.