/brz/remove-bazaar

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

    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,

        one_one,

        one_two,

        one_three,

        one_six,

        )

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:

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

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

            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

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

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

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

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

        # check inventory present

        if not self.inventories.get_parent_map([(revision_id,)]):

            if inv is None:

                raise errors.WeaveRevisionNotPresent(revision_id,

                                                     self.inventories)

            else:

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

                rev.inventory_sha1 = self.add_inventory(revision_id, inv,

                                                        rev.parent_ids)

        else:

            key = (revision_id,)

            rev.inventory_sha1 = self.inventories.get_sha1s([key])[key]

        self._add_revision(rev)

    def _add_revision(self, revision):

        text = self._serializer.write_revision_to_string(revision)

        key = (revision.revision_id,)

        parents = tuple((parent,) for parent in revision.parent_ids)

        self.revisions.add_lines(key, parents, osutils.split_lines(text))

    def all_revision_ids(self):

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

        This is conceptually deprecated because code should generally work on

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

        revisions that might be present.  There is no direct replacement

        method.

        """

        if 'evil' in debug.debug_flags:

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

        return self._all_revision_ids()

    def _all_revision_ids(self):

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

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

        present.

        """

        raise NotImplementedError(self._all_revision_ids)

    def break_lock(self):

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

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

        an active process.

        """

        self.control_files.break_lock()

    @needs_read_lock

    def _eliminate_revisions_not_present(self, revision_ids):

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

        Returns a set of the present revisions.

        """

        result = []

        graph = self.get_graph()

        parent_map = graph.get_parent_map(revision_ids)

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

        return parent_map.keys()

    @staticmethod

    def create(a_bzrdir):

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

        return RepositoryFormat.get_default_format().initialize(a_bzrdir)

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

        """instantiate a Repository.

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

        :param a_bzrdir: The BzrDir of the repository.

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

        getting file texts, inventories and revisions, then

        this construct will accept instances of those things.

        """

        super(Repository, self).__init__()

        self._format = _format

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

        self.bzrdir = a_bzrdir

        self.control_files = control_files

        self._transport = control_files._transport

        self.base = self._transport.base

        # for tests

        self._reconcile_does_inventory_gc = True

        self._reconcile_fixes_text_parents = False

        self._reconcile_backsup_inventory = True

        # not right yet - should be more semantically clear ? 

        # 

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

        # on whether escaping is required.

        self._warn_if_deprecated()

        self._write_group = None

        # Additional places to query for data.

        self._fallback_repositories = []

        # What order should fetch operations request streams in?

        # The default is unsorted as that is the cheapest for an origin to

        # provide.

        self._fetch_order = 'unsorted'

        # Does this repository use deltas that can be fetched as-deltas ?

        # (E.g. knits, where the knit deltas can be transplanted intact.

        # We default to False, which will ensure that enough data to get

        # a full text out of any fetch stream will be grabbed.

        self._fetch_uses_deltas = False

        # Should fetch trigger a reconcile after the fetch? Only needed for

        # some repository formats that can suffer internal inconsistencies.

        self._fetch_reconcile = False

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