~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: Robert Collins
  • Date: 2006-03-06 09:38:37 UTC
  • mto: (1594.2.4 integration)
  • mto: This revision was merged to the branch mainline in revision 1596.
  • Revision ID: robertc@robertcollins.net-20060306093837-b151989e9572895e
Remove all but fetch references to repository.revision_store.

Show diffs side-by-side

added added

removed removed

Lines of Context:
95
95
            else:
96
96
                # yes, this is not suitable for adding with ghosts.
97
97
                self.add_inventory(rev_id, inv, rev.parent_ids)
98
 
            
99
 
        rev_tmp = StringIO()
100
 
        bzrlib.xml5.serializer_v5.write_revision(rev, rev_tmp)
101
 
        rev_tmp.seek(0)
102
 
        self.revision_store.add(rev_tmp, rev_id)
103
 
        mutter('added revision_id {%s}', rev_id)
 
98
        self._revision_store.add_revision(rev, self.get_transaction())   
104
99
 
105
100
    @needs_read_lock
106
101
    def _all_possible_ids(self):
115
110
        present: for weaves ghosts may lead to a lack of correctness until
116
111
        the reweave updates the parents list.
117
112
        """
118
 
        if self.revision_store.listable():
119
 
            # yes this is slow, but its complete.
120
 
            result_graph = {}
121
 
            for rev_id in self.revision_store:
122
 
                rev = self.get_revision(rev_id)
123
 
                result_graph[rev_id] = rev.parent_ids
124
 
            # remove ghosts
125
 
            for rev_id, parents in result_graph.items():
126
 
                for parent in parents:
127
 
                    if not parent in result_graph:
128
 
                        del parents[parents.index(parent)]
129
 
            return topo_sort(result_graph.items())
 
113
        if self._revision_store.text_store.listable():
 
114
            return self._revision_store.all_revision_ids(self.get_transaction())
130
115
        result = self._all_possible_ids()
131
116
        return self._eliminate_revisions_not_present(result)
132
117
 
147
132
        """Construct the current default format repository in a_bzrdir."""
148
133
        return RepositoryFormat.get_default_format().initialize(a_bzrdir)
149
134
 
150
 
    def __init__(self, _format, a_bzrdir, control_files, revision_store, control_store, text_store):
 
135
    def __init__(self, _format, a_bzrdir, control_files, _revision_store, control_store, text_store):
151
136
        """instantiate a Repository.
152
137
 
153
138
        :param _format: The format of the repository on disk.
163
148
        self.bzrdir = a_bzrdir
164
149
        self.control_files = control_files
165
150
        # backwards compatible until we fully transition
166
 
        self.revision_store = revision_store.text_store
167
 
        self._revision_store = revision_store
 
151
        self.revision_store = _revision_store.text_store
 
152
        self._revision_store = _revision_store
168
153
        self.text_store = text_store
169
154
        # backwards compatability
170
155
        self.weave_store = text_store
246
231
                                                    self.get_transaction())
247
232
 
248
233
    @needs_read_lock
249
 
    def get_revision_xml_file(self, revision_id):
250
 
        """Return XML file object for revision object."""
251
 
        if not revision_id or not isinstance(revision_id, basestring):
252
 
            raise InvalidRevisionId(revision_id=revision_id, branch=self)
253
 
        try:
254
 
            return self.revision_store.get(revision_id)
255
 
        except (IndexError, KeyError):
256
 
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
257
 
 
258
 
    @needs_read_lock
259
 
    def get_revision_xml(self, revision_id):
260
 
        return self.get_revision_xml_file(revision_id).read()
261
 
 
262
 
    @needs_read_lock
263
234
    def get_revision_reconcile(self, revision_id):
264
235
        """'reconcile' helper routine that allows access to a revision always.
265
236
        
274
245
                                                 self.get_transaction())
275
246
 
276
247
    @needs_read_lock
 
248
    def get_revision_xml(self, revision_id):
 
249
        rev = self.get_revision(revision_id) 
 
250
        rev_tmp = StringIO()
 
251
        # the current serializer..
 
252
        self._revision_store._serializer.write_revision(rev, rev_tmp)
 
253
        rev_tmp.seek(0)
 
254
        return rev_tmp.getvalue()
 
255
 
 
256
    @needs_read_lock
277
257
    def get_revision(self, revision_id):
278
258
        """Return the Revision object for a named revision"""
279
259
        r = self.get_revision_reconcile(revision_id)
306
286
 
307
287
    @needs_write_lock
308
288
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
309
 
        self.revision_store.add(StringIO(gpg_strategy.sign(plaintext)), 
310
 
                                revision_id, "sig")
 
289
        signature = gpg_strategy.sign(plaintext)
 
290
        self._revision_store.add_revision_signature_text(revision_id,
 
291
                                                         signature,
 
292
                                                         self.get_transaction())
311
293
 
312
294
    def fileid_involved_between_revs(self, from_revid, to_revid):
313
295
        """Find file_id(s) which are involved in the changes between revisions.
569
551
        plaintext = Testament.from_revision(self, revision_id).as_short_text()
570
552
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
571
553
 
 
554
    @needs_read_lock
 
555
    def has_signature_for_revision_id(self, revision_id):
 
556
        """Query for a revision signature for revision_id in the repository."""
 
557
        return self._revision_store.has_signature(revision_id,
 
558
                                                  self.get_transaction())
 
559
 
572
560
 
573
561
class AllInOneRepository(Repository):
574
562
    """Legacy support - the repository behaviour for all-in-one branches."""
575
563
 
576
 
    def __init__(self, _format, a_bzrdir, revision_store, control_store, text_store):
 
564
    def __init__(self, _format, a_bzrdir, _revision_store, control_store, text_store):
577
565
        # we reuse one control files instance.
578
566
        dir_mode = a_bzrdir._control_files._dir_mode
579
567
        file_mode = a_bzrdir._control_files._file_mode
615
603
            # which allows access to this old info.
616
604
            self.inventory_store = get_store('inventory-store')
617
605
            text_store = get_store('text-store')
618
 
        super(AllInOneRepository, self).__init__(_format, a_bzrdir, a_bzrdir._control_files, revision_store, control_store, text_store)
 
606
        super(AllInOneRepository, self).__init__(_format, a_bzrdir, a_bzrdir._control_files, _revision_store, control_store, text_store)
619
607
 
620
608
 
621
609
class MetaDirRepository(Repository):
622
610
    """Repositories in the new meta-dir layout."""
623
611
 
624
 
    def __init__(self, _format, a_bzrdir, control_files, revision_store, control_store, text_store):
 
612
    def __init__(self, _format, a_bzrdir, control_files, _revision_store, control_store, text_store):
625
613
        super(MetaDirRepository, self).__init__(_format,
626
614
                                                a_bzrdir,
627
615
                                                control_files,
628
 
                                                revision_store,
 
616
                                                _revision_store,
629
617
                                                control_store,
630
618
                                                text_store)
631
619
 
647
635
            return ws
648
636
 
649
637
 
 
638
class KnitRepository(MetaDirRepository):
 
639
    """Knit format repository."""
 
640
 
 
641
    @needs_read_lock
 
642
    def all_revision_ids(self):
 
643
        """See Repository.all_revision_ids()."""
 
644
        return self._revision_store.all_revision_ids(self.get_transaction())
 
645
 
 
646
 
650
647
class RepositoryFormat(object):
651
648
    """A repository format.
652
649
 
730
727
                              compressed=compressed,
731
728
                              dir_mode=dir_mode,
732
729
                              file_mode=file_mode)
733
 
        revision_store = TextRevisionStore(text_store, serializer)
734
 
        return revision_store
 
730
        _revision_store = TextRevisionStore(text_store, serializer)
 
731
        return _revision_store
735
732
 
736
733
    def _get_versioned_file_store(self,
737
734
                                  name,
851
848
        control_files = a_bzrdir._control_files
852
849
        text_store = self._get_text_store(repo_transport, control_files)
853
850
        control_store = self._get_control_store(repo_transport, control_files)
854
 
        revision_store = self._get_revision_store(repo_transport, control_files)
 
851
        _revision_store = self._get_revision_store(repo_transport, control_files)
855
852
        return AllInOneRepository(_format=self,
856
853
                                  a_bzrdir=a_bzrdir,
857
 
                                  revision_store=revision_store,
 
854
                                  _revision_store=_revision_store,
858
855
                                  control_store=control_store,
859
856
                                  text_store=text_store)
860
857
 
1009
1006
        control_files = LockableFiles(repo_transport, 'lock')
1010
1007
        text_store = self._get_text_store(repo_transport, control_files)
1011
1008
        control_store = self._get_control_store(repo_transport, control_files)
1012
 
        revision_store = self._get_revision_store(repo_transport, control_files)
 
1009
        _revision_store = self._get_revision_store(repo_transport, control_files)
1013
1010
        return MetaDirRepository(_format=self,
1014
1011
                                 a_bzrdir=a_bzrdir,
1015
1012
                                 control_files=control_files,
1016
 
                                 revision_store=revision_store,
 
1013
                                 _revision_store=_revision_store,
1017
1014
                                 control_store=control_store,
1018
1015
                                 text_store=text_store)
1019
1016
 
1079
1076
        self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
1080
1077
        return self.open(a_bzrdir=a_bzrdir, _found=True)
1081
1078
 
 
1079
    def open(self, a_bzrdir, _found=False, _override_transport=None):
 
1080
        """See RepositoryFormat.open().
 
1081
        
 
1082
        :param _override_transport: INTERNAL USE ONLY. Allows opening the
 
1083
                                    repository at a slightly different url
 
1084
                                    than normal. I.e. during 'upgrade'.
 
1085
        """
 
1086
        if not _found:
 
1087
            format = RepositoryFormat.find_format(a_bzrdir)
 
1088
            assert format.__class__ ==  self.__class__
 
1089
        if _override_transport is not None:
 
1090
            repo_transport = _override_transport
 
1091
        else:
 
1092
            repo_transport = a_bzrdir.get_repository_transport(None)
 
1093
        control_files = LockableFiles(repo_transport, 'lock')
 
1094
        text_store = self._get_text_store(repo_transport, control_files)
 
1095
        control_store = self._get_control_store(repo_transport, control_files)
 
1096
        _revision_store = self._get_revision_store(repo_transport, control_files)
 
1097
        return KnitRepository(_format=self,
 
1098
                              a_bzrdir=a_bzrdir,
 
1099
                              control_files=control_files,
 
1100
                              _revision_store=_revision_store,
 
1101
                              control_store=control_store,
 
1102
                              text_store=text_store)
 
1103
 
1082
1104
 
1083
1105
class RepositoryFormatKnit1(MetaDirRepositoryFormat):
1084
1106
    """Bzr repository knit format 1.