# 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.decorators import needs_read_lock, needs_write_lock from bzrlib.errors import InvalidRevisionId from bzrlib.lockable_files import LockableFiles from bzrlib.osutils import safe_unicode from bzrlib.revision import NULL_REVISION from bzrlib.store import copy_all from bzrlib.store.weave import WeaveStore from bzrlib.store.text import TextStore from bzrlib.tree import RevisionTree from bzrlib.testament import Testament from bzrlib.tree import EmptyTree import bzrlib.xml5 class Repository(object): """Repository holding history for one or more branches. The repository holds and retrieves historical information including revisions and file history. It's normally accessed only by the Branch, which views a particular line of development through that history. The Repository builds on top of Stores and a Transport, which respectively describe the disk data format and the way of accessing the (possibly remote) disk. """ def __init__(self, transport, branch_format): # circular dependencies: from bzrlib.branch import (BzrBranchFormat4, BzrBranchFormat5, BzrBranchFormat6, ) object.__init__(self) self.control_files = LockableFiles(transport.clone(bzrlib.BZRDIR), 'README') dir_mode = self.control_files._dir_mode file_mode = self.control_files._file_mode def get_weave(name, prefixed=False): if name: name = bzrlib.BZRDIR + '/' + safe_unicode(name) else: name = bzrlib.BZRDIR relpath = self.control_files._escape(name) weave_transport = transport.clone(relpath) ws = WeaveStore(weave_transport, prefixed=prefixed, dir_mode=dir_mode, file_mode=file_mode) 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. if name: name = bzrlib.BZRDIR + '/' + safe_unicode(name) else: name = bzrlib.BZRDIR relpath = self.control_files._escape(name) store = TextStore(transport.clone(relpath), prefixed=prefixed, compressed=compressed, dir_mode=dir_mode, file_mode=file_mode) #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 isinstance(branch_format, BzrBranchFormat4): self.inventory_store = get_store('inventory-store') self.text_store = get_store('text-store') self.revision_store = get_store('revision-store') elif isinstance(branch_format, BzrBranchFormat5): self.control_weaves = get_weave('') self.weave_store = get_weave('weaves') self.revision_store = get_store('revision-store', compressed=False) elif isinstance(branch_format, BzrBranchFormat6): 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() @needs_read_lock def copy(self, destination): destination.lock_write() try: 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) finally: destination.unlock() 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) @needs_read_lock def get_revision_xml(self, revision_id): return self.get_revision_xml_file(revision_id).read() @needs_read_lock 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 @needs_read_lock 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") @needs_read_lock def get_inventory_weave(self): return self.control_weaves.get_weave('inventory', self.get_transaction()) @needs_read_lock 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) @needs_read_lock 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) @needs_read_lock def get_inventory_sha1(self, revision_id): """Return the sha1 hash of the inventory entry """ return self.get_revision(revision_id).inventory_sha1 @needs_read_lock 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 is 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) @needs_read_lock 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 is None or revision_id == NULL_REVISION: return EmptyTree() else: inv = self.get_revision_inventory(revision_id) return RevisionTree(self, inv, revision_id) @needs_read_lock 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. FIXME RBC 20060125 as John Meinel points out this is a bad api - it writes to stdout, it assumes that that is valid etc. Fix by creating a new more flexible convenience function. """ 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() @needs_write_lock 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)