~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005, 2006 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 copy import deepcopy

from cStringIO import StringIO

from unittest import TestSuite

import xml.sax.saxutils

import bzrlib.bzrdir as bzrdir

from bzrlib.decorators import needs_read_lock, needs_write_lock

from bzrlib.errors import InvalidRevisionId

from bzrlib.lockable_files import LockableFiles, TransportLock

from bzrlib.lockdir import LockDir

from bzrlib.osutils import safe_unicode

from bzrlib.revision import NULL_REVISION

import bzrlib.errors as errors

import bzrlib.gpg as gpg

from bzrlib.store import copy_all

from bzrlib.store.weave import WeaveStore

from bzrlib.store.text import TextStore

from bzrlib.symbol_versioning import *

from bzrlib.trace import mutter

from bzrlib.tree import RevisionTree

from bzrlib.testament import Testament

from bzrlib.tree import EmptyTree

import bzrlib.ui

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.

    """

    @needs_write_lock

    def add_inventory(self, revid, inv, parents):

        """Add the inventory inv to the repository as revid.

        :param parents: The revision ids of the parents that revid

                        is known to have and are in the repository already.

        returns the sha1 of the serialized inventory.

        """

        inv_text = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)

        inv_sha1 = bzrlib.osutils.sha_string(inv_text)

        self.control_weaves.add_text('inventory', revid,

                   bzrlib.osutils.split_lines(inv_text), parents,

                   self.get_transaction())

        return inv_sha1

    @needs_write_lock

    def add_revision(self, rev_id, rev, inv=None, config=None):

        """Add rev to the revision store as rev_id.

        :param rev_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.

        """

        if config is not None and config.signature_needed():

            if inv is None:

                inv = self.get_inventory(rev_id)

            plaintext = Testament(rev, inv).as_short_text()

            self.store_revision_signature(

                gpg.GPGStrategy(config), plaintext, rev_id)

        if not rev_id in self.get_inventory_weave():

            if inv is None:

                raise errors.WeaveRevisionNotPresent(rev_id,

                                                     self.get_inventory_weave())

            else:

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

                self.add_inventory(rev_id, inv, rev.parent_ids)

        rev_tmp = StringIO()

        bzrlib.xml5.serializer_v5.write_revision(rev, rev_tmp)

        rev_tmp.seek(0)

        self.revision_store.add(rev_tmp, rev_id)

        mutter('added revision_id {%s}', rev_id)

    @needs_read_lock

    def _all_possible_ids(self):

        """Return all the possible revisions that we could find."""

        return self.get_inventory_weave().names()

    @needs_read_lock

    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: for weaves ghosts may lead to a lack of correctness until

        the reweave updates the parents list.

        """

        result = self._all_possible_ids()

        return self._eliminate_revisions_not_present(result)

    @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 = []

        for id in revision_ids:

            if self.has_revision(id):

               result.append(id)

        return result

    @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, revision_store):

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

        """

        object.__init__(self)

        self._format = _format

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

        self.bzrdir = a_bzrdir

        self.control_files = control_files

        self.revision_store = revision_store

    def lock_write(self):

        self.control_files.lock_write()

    def lock_read(self):

        self.control_files.lock_read()

    def is_locked(self):

        return self.control_files.is_locked()

    @needs_read_lock

    def missing_revision_ids(self, other, revision_id=None):

        """Return the revision ids that other has that this does not.

        These are returned in topological order.

        revision_id: only return revision ids included by revision_id.

        """

        return InterRepository.get(other, self).missing_revision_ids(revision_id)

    @staticmethod

    def open(base):

        """Open the repository rooted at base.

        For instance, if the repository is at URL/.bzr/repository,

        Repository.open(URL) -> a Repository instance.

        """

        control = bzrlib.bzrdir.BzrDir.open(base)

        return control.open_repository()

    def copy_content_into(self, destination, revision_id=None, basis=None):

        """Make a complete copy of the content in self into destination.

        This is a destructive operation! Do not use it on existing 

        repositories.

        """

        return InterRepository.get(self, destination).copy_content(revision_id, basis)

    def fetch(self, source, revision_id=None, pb=None):

        """Fetch the content required to construct revision_id from source.

        If revision_id is None all content is copied.

        """

        return InterRepository.get(source, self).fetch(revision_id=revision_id,

                                                       pb=pb)

    def unlock(self):

        self.control_files.unlock()

    @needs_read_lock

    def clone(self, a_bzrdir, revision_id=None, basis=None):

        """Clone this repository into a_bzrdir using the current format.

        Currently no check is made that the format of this repository and

        the bzrdir format are compatible. FIXME RBC 20060201.

        """

        if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):

            # use target default format.

            result = a_bzrdir.create_repository()

        # FIXME RBC 20060209 split out the repository type to avoid this check ?

        elif isinstance(a_bzrdir._format,

                      (bzrlib.bzrdir.BzrDirFormat4,

                       bzrlib.bzrdir.BzrDirFormat5,

                       bzrlib.bzrdir.BzrDirFormat6)):

            result = a_bzrdir.open_repository()

        else:

            result = self._format.initialize(a_bzrdir, shared=self.is_shared())

        self.copy_content_into(result, revision_id, basis)

        return result

    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_reconcile(self, revision_id):

        """'reconcile' helper routine that allows access to a revision always.

        This variant of get_revision does not cross check the weave graph

        against the revision one as get_revision does: but it should only

        be used by reconcile, or reconcile-alike commands that are correcting

        or testing the revision graph.

        """

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

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

        r = self.get_revision_reconcile(revision_id)

        # weave corruption can lead to absent revision markers that should be

        # present.

        # the following test is reasonably cheap (it needs a single weave read)

        # and the weave is cached in read transactions. In write transactions

        # it is not cached but typically we only read a small number of

        # revisions. For knits when they are introduced we will probably want

        # to ensure that caching write transactions are in use.

        inv = self.get_inventory_weave()

        self._check_revision_parents(r, inv)

        return r

    def _check_revision_parents(self, revision, inventory):

        """Private to Repository and Fetch.

        This checks the parentage of revision in an inventory weave for 

        consistency and is only applicable to inventory-weave-for-ancestry

        using repository formats & fetchers.

        """

        weave_parents = inventory.parent_names(revision.revision_id)

        weave_names = inventory.names()

        for parent_id in revision.parent_ids:

            if parent_id in weave_names:

                # this parent must not be a ghost.

                if not parent_id in weave_parents:

                    # but it is a ghost

                    raise errors.CorruptRepository(self)

    @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")

    def fileid_involved_between_revs(self, from_revid, to_revid):

        """Find file_id(s) which are involved in the changes between revisions.

        This determines the set of revisions which are involved, and then

        finds all file ids affected by those revisions.

        """

        # TODO: jam 20060119 This code assumes that w.inclusions will

        #       always be correct. But because of the presence of ghosts

        #       it is possible to be wrong.

        #       One specific example from Robert Collins:

        #       Two branches, with revisions ABC, and AD

        #       C is a ghost merge of D.

        #       Inclusions doesn't recognize D as an ancestor.

        #       If D is ever merged in the future, the weave

        #       won't be fixed, because AD never saw revision C

        #       to cause a conflict which would force a reweave.

        w = self.get_inventory_weave()

        from_set = set(w.inclusions([w.lookup(from_revid)]))

        to_set = set(w.inclusions([w.lookup(to_revid)]))

        included = to_set.difference(from_set)

        changed = map(w.idx_to_name, included)

        return self._fileid_involved_by_set(changed)

    def fileid_involved(self, last_revid=None):

        """Find all file_ids modified in the ancestry of last_revid.

        :param last_revid: If None, last_revision() will be used.

        """

        w = self.get_inventory_weave()

        if not last_revid:

            changed = set(w._names)

        else:

            included = w.inclusions([w.lookup(last_revid)])

            changed = map(w.idx_to_name, included)

        return self._fileid_involved_by_set(changed)

    def fileid_involved_by_set(self, changes):

        """Find all file_ids modified by the set of revisions passed in.

        :param changes: A set() of revision ids

        """

        # TODO: jam 20060119 This line does *nothing*, remove it.

        #       or better yet, change _fileid_involved_by_set so

        #       that it takes the inventory weave, rather than

        #       pulling it out by itself.

        return self._fileid_involved_by_set(changes)

    def _fileid_involved_by_set(self, changes):

        """Find the set of file-ids affected by the set of revisions.

        :param changes: A set() of revision ids.

        :return: A set() of file ids.

        This peaks at the Weave, interpreting each line, looking to

        see if it mentions one of the revisions. And if so, includes

        the file id mentioned.

        This expects both the Weave format, and the serialization

        to have a single line per file/directory, and to have

        fileid="" and revision="" on that line.

        """

        assert isinstance(self._format, (RepositoryFormat5,

                                         RepositoryFormat6,

                                         RepositoryFormat7,

                                         RepositoryFormatKnit1)), \

            "fileid_involved only supported for branches which store inventory as unnested xml"

        w = self.get_inventory_weave()

        file_ids = set()

        for line in w._weave:

            # it is ugly, but it is due to the weave structure

            if not isinstance(line, basestring): continue

            start = line.find('file_id="')+9

            if start < 9: continue

            end = line.find('"', start)

            assert end>= 0

            file_id = xml.sax.saxutils.unescape(line[start:end])

            # check if file_id is already present

            if file_id in file_ids: continue

            start = line.find('revision="')+10

            if start < 10: continue

            end = line.find('"', start)

            assert end>= 0

            revision_id = xml.sax.saxutils.unescape(line[start:end])

            if revision_id in changes:

                file_ids.add(file_id)

        return file_ids

    @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_graph(self, revision_id=None):

        """Return a dictionary containing the revision graph.

        :return: a dictionary of revision_id->revision_parents_list.

        """

        weave = self.get_inventory_weave()

        all_revisions = self._eliminate_revisions_not_present(weave.names())

        entire_graph = dict([(node, weave.parent_names(node)) for 

                             node in all_revisions])

        if revision_id is None:

            return entire_graph

        elif revision_id not in entire_graph:

            raise errors.NoSuchRevision(self, revision_id)

        else:

            # add what can be reached from revision_id

            result = {}

            pending = set([revision_id])

            while len(pending) > 0:

                node = pending.pop()

                result[node] = entire_graph[node]

                for revision_id in result[node]:

                    if revision_id not in result:

                        pending.add(revision_id)

            return result

    @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 is_shared(self):

        """Return True if this repository is flagged as a shared repository."""

        # FIXME format 4-6 cannot be shared, this is technically faulty.

        return self.control_files._transport.has('shared-storage')

    @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]

        if not self.has_revision(revision_id):

            raise errors.NoSuchRevision(self, revision_id)

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

    def revision_parents(self, revid):

        return self.get_inventory_weave().parent_names(revid)

    @needs_write_lock

    def set_make_working_trees(self, new_value):

        """Set the policy flag for making working trees when creating branches.

        This only applies to branches that use this repository.

        The default is 'True'.

        :param new_value: True to restore the default, False to disable making

                          working trees.

        """

        # FIXME: split out into a new class/strategy ?

        if isinstance(self._format, (RepositoryFormat4,

                                     RepositoryFormat5,

                                     RepositoryFormat6)):

            raise NotImplementedError(self.set_make_working_trees)

        if new_value:

            try:

                self.control_files._transport.delete('no-working-trees')

            except errors.NoSuchFile:

                pass

        else:

            self.control_files.put_utf8('no-working-trees', '')

    def make_working_trees(self):

        """Returns the policy for making working trees on new branches."""

        # FIXME: split out into a new class/strategy ?

        if isinstance(self._format, (RepositoryFormat4,

                                     RepositoryFormat5,

                                     RepositoryFormat6)):

            return True

        return not self.control_files._transport.has('no-working-trees')

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

class AllInOneRepository(Repository):

    """Legacy support - the repository behaviour for all-in-one branches."""

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

        # we reuse one control files instance.

        dir_mode = a_bzrdir._control_files._dir_mode

        file_mode = a_bzrdir._control_files._file_mode

        def get_weave(name, prefixed=False):

            if name:

                name = safe_unicode(name)

            else:

                name = ''

            relpath = a_bzrdir._control_files._escape(name)

            weave_transport = a_bzrdir._control_files._transport.clone(relpath)

            ws = WeaveStore(weave_transport, prefixed=prefixed,

                            dir_mode=dir_mode,

                            file_mode=file_mode)

            if a_bzrdir._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.

            relpath = a_bzrdir._control_files._escape(name)

            store = TextStore(a_bzrdir._control_files._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

        # not broken out yet because the controlweaves|inventory_store

        # and text_store | weave_store bits are still different.

        if isinstance(_format, RepositoryFormat4):

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

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

        elif isinstance(_format, RepositoryFormat5):

            self.control_weaves = get_weave('')

            self.weave_store = get_weave('weaves')

        elif isinstance(_format, RepositoryFormat6):

            self.control_weaves = get_weave('')

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

        else:

            raise errors.BzrError('unreachable code: unexpected repository'

                                  ' format.')

        revision_store.register_suffix('sig')

        super(AllInOneRepository, self).__init__(_format, a_bzrdir, a_bzrdir._control_files, revision_store)

class MetaDirRepository(Repository):

    """Repositories in the new meta-dir layout."""

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

        super(MetaDirRepository, self).__init__(_format,

                                                a_bzrdir,

                                                control_files,

                                                revision_store)

        dir_mode = self.control_files._dir_mode

        file_mode = self.control_files._file_mode

        def get_weave(name, prefixed=False):

            if name:

                name = safe_unicode(name)

            else:

                name = ''

            relpath = self.control_files._escape(name)

            weave_transport = self.control_files._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

        if isinstance(self._format, RepositoryFormat7):

            self.control_weaves = get_weave('')

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

        elif isinstance(self._format, RepositoryFormatKnit1):

            self.control_weaves = get_weave('')

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

        else:

            raise errors.BzrError('unreachable code: unexpected repository'

                                  ' format.')

class RepositoryFormat(object):

    """A repository format.

    Formats provide three things:

     * An initialization routine to construct repository data on disk.

     * a format string which is used when the BzrDir supports versioned

       children.

     * an open routine which returns a Repository instance.

    Formats are placed in an dict by their format string for reference 

    during opening. These should be subclasses of RepositoryFormat

    for consistency.

    Once a format is deprecated, just deprecate the initialize and open

    methods on the format class. Do not deprecate the object, as the 

    object will be created every system load.

    Common instance attributes:

    _matchingbzrdir - the bzrdir format that the repository format was

    originally written to work with. This can be used if manually

    constructing a bzrdir and repository, or more commonly for test suite

    parameterisation.

    """

    _default_format = None

    """The default format used for new repositories."""

    _formats = {}

    """The known formats."""

    @classmethod

    def find_format(klass, a_bzrdir):

        """Return the format for the repository object in a_bzrdir."""

        try:

            transport = a_bzrdir.get_repository_transport(None)

            format_string = transport.get("format").read()

            return klass._formats[format_string]

        except errors.NoSuchFile:

            raise errors.NoRepositoryPresent(a_bzrdir)

        except KeyError:

            raise errors.UnknownFormatError(format_string)

    @classmethod

    def get_default_format(klass):

        """Return the current default format."""

        return klass._default_format

    def get_format_string(self):

        """Return the ASCII format string that identifies this format.

        Note that in pre format ?? repositories the format string is 

        not permitted nor written to disk.

        """

        raise NotImplementedError(self.get_format_string)

    def _get_revision_store(self, repo_transport, control_files):

        """Return the revision store object for this a_bzrdir."""

        raise NotImplementedError(self._get_revision_store)

    def _get_rev_store(self,

                   transport,

                   control_files,

                   name,

                   compressed=True,

                   prefixed=False):

        """Common logic for getting a revision store for a repository.

        see self._get_revision_store for the method to 

        get the store for a repository.

        """

        if name:

            name = safe_unicode(name)

        else:

            name = ''

        dir_mode = control_files._dir_mode

        file_mode = control_files._file_mode

        revision_store =TextStore(transport.clone(name),

                                  prefixed=prefixed,

                                  compressed=compressed,

                                  dir_mode=dir_mode,

                                  file_mode=file_mode)

        revision_store.register_suffix('sig')

        return revision_store