/brz/remove-bazaar

# Copyright (C) 2005 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.lockable_files import LockableFiles

from bzrlib.tree import EmptyTree

from bzrlib.revision import NULL_REVISION

from bzrlib.store import copy_all

from bzrlib.store.weave import WeaveStore

from bzrlib.store.text import TextStore

import bzrlib.xml5

from bzrlib.tree import RevisionTree

from bzrlib.errors import InvalidRevisionId

from bzrlib.testament import Testament

def needs_read_lock(unbound):

    """Decorate unbound to take out and release a read lock."""

    def decorated(self, *args, **kwargs):

        self.control_files.lock_read()

        try:

            return unbound(self, *args, **kwargs)

        finally:

            self.control_files.unlock()

    return decorated

def needs_write_lock(unbound):

    """Decorate unbound to take out and release a write lock."""

    def decorated(self, *args, **kwargs):

        self.control_files.lock_write()

        try:

            return unbound(self, *args, **kwargs)

        finally:

            self.control_files.unlock()

    return decorated

class Repository(object):

    def __init__(self, transport, branch_format):

        object.__init__(self)

        self.control_files = LockableFiles(transport, 'storage-lock')

        def get_weave(name, prefixed=False):

            relpath = self.control_files._rel_controlfilename(unicode(name))

            weave_transport = self.control_files.make_transport(relpath)

            ws = WeaveStore(weave_transport, prefixed=prefixed)

            if self.control_files._transport.should_cache():

                ws.enable_cache = True

            return ws

        def get_store(name, compressed=True, prefixed=False):

            # FIXME: This approach of assuming stores are all entirely compressed

            # or entirely uncompressed is tidy, but breaks upgrade from 

            # some existing branches where there's a mixture; we probably 

            # still want the option to look for both.

            name = unicode(name)

            relpath = self.control_files._rel_controlfilename(name)

            store = TextStore(self.control_files.make_transport(relpath),

                              prefixed=prefixed, compressed=compressed)

            #if self._transport.should_cache():

            #    cache_path = os.path.join(self.cache_root, name)

            #    os.mkdir(cache_path)

            #    store = bzrlib.store.CachedStore(store, cache_path)

            return store

        if branch_format == 4:

            self.inventory_store = get_store('inventory-store')

            self.text_store = get_store('text-store')

            self.revision_store = get_store('revision-store')

        elif branch_format == 5:

            self.control_weaves = get_weave('')

            self.weave_store = get_weave('weaves')

            self.revision_store = get_store('revision-store', compressed=False)

        elif branch_format == 6:

            self.control_weaves = get_weave('')

            self.weave_store = get_weave('weaves', prefixed=True)

            self.revision_store = get_store('revision-store', compressed=False,

                                            prefixed=True)

        self.revision_store.register_suffix('sig')

    def lock_write(self):

        self.control_files.lock_write()

    def lock_read(self):

        self.control_files.lock_read()

    def unlock(self):

        self.control_files.unlock()

    def copy(self, destination):

        destination.control_weaves.copy_multi(self.control_weaves, 

                ['inventory'])

        copy_all(self.weave_store, destination.weave_store)

        copy_all(self.revision_store, destination.revision_store)

    def has_revision(self, revision_id):

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

        This does not necessarily imply the revision is merge

        or on the mainline."""

        return (revision_id is None

                or self.revision_store.has_id(revision_id))

    @needs_read_lock

    def get_revision_xml_file(self, revision_id):

        """Return XML file object for revision object."""

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

            raise InvalidRevisionId(revision_id=revision_id, branch=self)

        try:

            return self.revision_store.get(revision_id)

        except (IndexError, KeyError):

            raise bzrlib.errors.NoSuchRevision(self, revision_id)

    def get_revision_xml(self, revision_id):

        return self.get_revision_xml_file(revision_id).read()

    def get_revision(self, revision_id):

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

        xml_file = self.get_revision_xml_file(revision_id)

        try:

            r = bzrlib.xml5.serializer_v5.read_revision(xml_file)

        except SyntaxError, e:

            raise bzrlib.errors.BzrError('failed to unpack revision_xml',

                                         [revision_id,

                                          str(e)])

        assert r.revision_id == revision_id

        return r

    def get_revision_sha1(self, revision_id):

        """Hash the stored value of a revision, and return it."""

        # In the future, revision entries will be signed. At that

        # point, it is probably best *not* to include the signature

        # in the revision hash. Because that lets you re-sign

        # the revision, (add signatures/remove signatures) and still

        # have all hash pointers stay consistent.

        # But for now, just hash the contents.

        return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))

    @needs_write_lock

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

        self.revision_store.add(StringIO(gpg_strategy.sign(plaintext)), 

                                revision_id, "sig")

    def get_inventory_weave(self):

        return self.control_weaves.get_weave('inventory',

            self.get_transaction())

    def get_inventory(self, revision_id):

        """Get Inventory object by hash."""

        xml = self.get_inventory_xml(revision_id)

        return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)

    def get_inventory_xml(self, revision_id):

        """Get inventory XML as a file object."""

        try:

            assert isinstance(revision_id, basestring), type(revision_id)

            iw = self.get_inventory_weave()

            return iw.get_text(iw.lookup(revision_id))

        except IndexError:

            raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)

    def get_inventory_sha1(self, revision_id):

        """Return the sha1 hash of the inventory entry

        """

        return self.get_revision(revision_id).inventory_sha1

    def get_revision_inventory(self, revision_id):

        """Return inventory of a past revision."""

        # TODO: Unify this with get_inventory()

        # bzr 0.0.6 and later imposes the constraint that the inventory_id

        # must be the same as its revision, so this is trivial.

        if revision_id == None:

            # This does not make sense: if there is no revision,

            # then it is the current tree inventory surely ?!

            # and thus get_root_id() is something that looks at the last

            # commit on the branch, and the get_root_id is an inventory check.

            raise NotImplementedError

            # return Inventory(self.get_root_id())

        else:

            return self.get_inventory(revision_id)

    def revision_tree(self, revision_id):

        """Return Tree for a revision on this branch.

        `revision_id` may be None for the null revision, in which case

        an `EmptyTree` is returned."""

        # TODO: refactor this to use an existing revision object

        # so we don't need to read it in twice.

        if revision_id == None or revision_id == NULL_REVISION:

            return EmptyTree()

        else:

            inv = self.get_revision_inventory(revision_id)

            return RevisionTree(self.weave_store, inv, revision_id)

    def get_ancestry(self, revision_id):

        """Return a list of revision-ids integrated by a revision.

        This is topologically sorted.

        """

        if revision_id is None:

            return [None]

        w = self.get_inventory_weave()

        return [None] + map(w.idx_to_name,

                            w.inclusions([w.lookup(revision_id)]))

    @needs_read_lock

    def print_file(self, file, revision_id):

        """Print `file` to stdout."""

        tree = self.revision_tree(revision_id)

        # use inventory as it was in that revision

        file_id = tree.inventory.path2id(file)

        if not file_id:

            raise BzrError("%r is not present in revision %s" % (file, revno))

            try:

                revno = self.revision_id_to_revno(revision_id)

            except errors.NoSuchRevision:

                # TODO: This should not be BzrError,

                # but NoSuchFile doesn't fit either

                raise BzrError('%r is not present in revision %s' 

                                % (file, revision_id))

            else:

                raise BzrError('%r is not present in revision %s'

                                % (file, revno))

        tree.print_file(file_id)

    def get_transaction(self):

        return self.control_files.get_transaction()

    def sign_revision(self, revision_id, gpg_strategy):

        plaintext = Testament.from_revision(self, revision_id).as_short_text()

        self.store_revision_signature(gpg_strategy, plaintext, revision_id)