/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/repofmt/knitrepo.py

  • Committer: Ian Clatworthy
  • Date: 2007-08-13 14:33:10 UTC
  • mto: (2733.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 2734.
  • Revision ID: ian.clatworthy@internode.on.net-20070813143310-twhj4la0qnupvze8
Added Quick Start Summary

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2007-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
from bzrlib.lazy_import import lazy_import
18
 
lazy_import(globals(), """
19
17
from bzrlib import (
20
18
    bzrdir,
 
19
    deprecated_graph,
21
20
    errors,
22
 
    knit as _mod_knit,
 
21
    knit,
23
22
    lockable_files,
24
23
    lockdir,
25
24
    osutils,
26
 
    revision as _mod_revision,
27
 
    trace,
28
25
    transactions,
29
 
    versionedfile,
30
26
    xml5,
31
 
    xml6,
32
27
    xml7,
33
28
    )
34
 
""")
35
 
from bzrlib import (
36
 
    symbol_versioning,
37
 
    )
 
29
 
38
30
from bzrlib.decorators import needs_read_lock, needs_write_lock
39
31
from bzrlib.repository import (
40
 
    CommitBuilder,
41
 
    IsInWriteGroupError,
42
32
    MetaDirRepository,
43
33
    MetaDirRepositoryFormat,
44
34
    RepositoryFormat,
45
35
    RootCommitBuilder,
46
36
    )
 
37
import bzrlib.revision as _mod_revision
 
38
from bzrlib.store.versioned import VersionedFileStore
 
39
from bzrlib.trace import mutter, note, warning
47
40
 
48
41
 
49
42
class _KnitParentsProvider(object):
54
47
    def __repr__(self):
55
48
        return 'KnitParentsProvider(%r)' % self._knit
56
49
 
57
 
    def get_parent_map(self, keys):
58
 
        """See graph.StackedParentsProvider.get_parent_map"""
59
 
        parent_map = {}
60
 
        for revision_id in keys:
61
 
            if revision_id is None:
62
 
                raise ValueError('get_parent_map(None) is not valid')
 
50
    def get_parents(self, revision_ids):
 
51
        parents_list = []
 
52
        for revision_id in revision_ids:
63
53
            if revision_id == _mod_revision.NULL_REVISION:
64
 
                parent_map[revision_id] = ()
 
54
                parents = []
65
55
            else:
66
56
                try:
67
 
                    parents = tuple(
68
 
                        self._knit.get_parents_with_ghosts(revision_id))
 
57
                    parents = self._knit.get_parents_with_ghosts(revision_id)
69
58
                except errors.RevisionNotPresent:
70
 
                    continue
 
59
                    parents = None
71
60
                else:
72
61
                    if len(parents) == 0:
73
 
                        parents = (_mod_revision.NULL_REVISION,)
74
 
                parent_map[revision_id] = parents
75
 
        return parent_map
76
 
 
77
 
 
78
 
class _KnitsParentsProvider(object):
79
 
 
80
 
    def __init__(self, knit, prefix=()):
81
 
        """Create a parent provider for string keys mapped to tuple keys."""
82
 
        self._knit = knit
83
 
        self._prefix = prefix
84
 
 
85
 
    def __repr__(self):
86
 
        return 'KnitsParentsProvider(%r)' % self._knit
87
 
 
88
 
    def get_parent_map(self, keys):
89
 
        """See graph.StackedParentsProvider.get_parent_map"""
90
 
        parent_map = self._knit.get_parent_map(
91
 
            [self._prefix + (key,) for key in keys])
92
 
        result = {}
93
 
        for key, parents in parent_map.items():
94
 
            revid = key[-1]
95
 
            if len(parents) == 0:
96
 
                parents = (_mod_revision.NULL_REVISION,)
97
 
            else:
98
 
                parents = tuple(parent[-1] for parent in parents)
99
 
            result[revid] = parents
100
 
        for revision_id in keys:
101
 
            if revision_id == _mod_revision.NULL_REVISION:
102
 
                result[revision_id] = ()
103
 
        return result
 
62
                        parents = [_mod_revision.NULL_REVISION]
 
63
            parents_list.append(parents)
 
64
        return parents_list
104
65
 
105
66
 
106
67
class KnitRepository(MetaDirRepository):
107
68
    """Knit format repository."""
108
69
 
109
 
    # These attributes are inherited from the Repository base class. Setting
110
 
    # them to None ensures that if the constructor is changed to not initialize
111
 
    # them, or a subclass fails to call the constructor, that an error will
112
 
    # occur rather than the system working but generating incorrect data.
113
 
    _commit_builder_class = None
114
 
    _serializer = None
115
 
 
116
 
    def __init__(self, _format, a_bzrdir, control_files, _commit_builder_class,
117
 
        _serializer):
118
 
        MetaDirRepository.__init__(self, _format, a_bzrdir, control_files)
119
 
        self._commit_builder_class = _commit_builder_class
120
 
        self._serializer = _serializer
121
 
        self._reconcile_fixes_text_parents = True
 
70
    _serializer = xml5.serializer_v5
 
71
 
 
72
    def _warn_if_deprecated(self):
 
73
        # This class isn't deprecated
 
74
        pass
 
75
 
 
76
    def _inventory_add_lines(self, inv_vf, revid, parents, lines):
 
77
        inv_vf.add_lines_with_ghosts(revid, parents, lines)
122
78
 
123
79
    @needs_read_lock
124
80
    def _all_revision_ids(self):
125
81
        """See Repository.all_revision_ids()."""
126
 
        return [key[0] for key in self.revisions.keys()]
127
 
 
128
 
    def _activate_new_inventory(self):
129
 
        """Put a replacement inventory.new into use as inventories."""
130
 
        # Copy the content across
131
 
        t = self._transport
132
 
        t.copy('inventory.new.kndx', 'inventory.kndx')
133
 
        try:
134
 
            t.copy('inventory.new.knit', 'inventory.knit')
135
 
        except errors.NoSuchFile:
136
 
            # empty inventories knit
137
 
            t.delete('inventory.knit')
138
 
        # delete the temp inventory
139
 
        t.delete('inventory.new.kndx')
140
 
        try:
141
 
            t.delete('inventory.new.knit')
142
 
        except errors.NoSuchFile:
143
 
            # empty inventories knit
144
 
            pass
145
 
        # Force index reload (sanity check)
146
 
        self.inventories._index._reset_cache()
147
 
        self.inventories.keys()
148
 
 
149
 
    def _backup_inventory(self):
150
 
        t = self._transport
151
 
        t.copy('inventory.kndx', 'inventory.backup.kndx')
152
 
        t.copy('inventory.knit', 'inventory.backup.knit')
153
 
 
154
 
    def _move_file_id(self, from_id, to_id):
155
 
        t = self._transport.clone('knits')
156
 
        from_rel_url = self.texts._index._mapper.map((from_id, None))
157
 
        to_rel_url = self.texts._index._mapper.map((to_id, None))
158
 
        # We expect both files to always exist in this case.
159
 
        for suffix in ('.knit', '.kndx'):
160
 
            t.rename(from_rel_url + suffix, to_rel_url + suffix)
161
 
 
162
 
    def _remove_file_id(self, file_id):
163
 
        t = self._transport.clone('knits')
164
 
        rel_url = self.texts._index._mapper.map((file_id, None))
165
 
        for suffix in ('.kndx', '.knit'):
166
 
            try:
167
 
                t.delete(rel_url + suffix)
168
 
            except errors.NoSuchFile:
169
 
                pass
170
 
 
171
 
    def _temp_inventories(self):
172
 
        result = self._format._get_inventories(self._transport, self,
173
 
            'inventory.new')
174
 
        # Reconciling when the output has no revisions would result in no
175
 
        # writes - but we want to ensure there is an inventory for
176
 
        # compatibility with older clients that don't lazy-load.
177
 
        result.get_parent_map([('A',)])
178
 
        return result
 
82
        # Knits get the revision graph from the index of the revision knit, so
 
83
        # it's always possible even if they're on an unlistable transport.
 
84
        return self._revision_store.all_revision_ids(self.get_transaction())
179
85
 
180
86
    def fileid_involved_between_revs(self, from_revid, to_revid):
181
87
        """Find file_id(s) which are involved in the changes between revisions.
183
89
        This determines the set of revisions which are involved, and then
184
90
        finds all file ids affected by those revisions.
185
91
        """
 
92
        from_revid = osutils.safe_revision_id(from_revid)
 
93
        to_revid = osutils.safe_revision_id(to_revid)
186
94
        vf = self._get_revision_vf()
187
95
        from_set = set(vf.get_ancestry(from_revid))
188
96
        to_set = set(vf.get_ancestry(to_revid))
203
111
        return self._fileid_involved_by_set(changed)
204
112
 
205
113
    @needs_read_lock
 
114
    def get_ancestry(self, revision_id, topo_sorted=True):
 
115
        """Return a list of revision-ids integrated by a revision.
 
116
        
 
117
        This is topologically sorted, unless 'topo_sorted' is specified as
 
118
        False.
 
119
        """
 
120
        if _mod_revision.is_null(revision_id):
 
121
            return [None]
 
122
        revision_id = osutils.safe_revision_id(revision_id)
 
123
        vf = self._get_revision_vf()
 
124
        try:
 
125
            return [None] + vf.get_ancestry(revision_id, topo_sorted)
 
126
        except errors.RevisionNotPresent:
 
127
            raise errors.NoSuchRevision(self, revision_id)
 
128
 
 
129
    @needs_read_lock
206
130
    def get_revision(self, revision_id):
207
131
        """Return the Revision object for a named revision"""
208
132
        revision_id = osutils.safe_revision_id(revision_id)
209
133
        return self.get_revision_reconcile(revision_id)
210
134
 
211
 
    def _refresh_data(self):
212
 
        if not self.is_locked():
213
 
            return
214
 
        if self.is_in_write_group():
215
 
            raise IsInWriteGroupError(self)
216
 
        # Create a new transaction to force all knits to see the scope change.
217
 
        # This is safe because we're outside a write group.
218
 
        self.control_files._finish_transaction()
219
 
        if self.is_write_locked():
220
 
            self.control_files._set_write_transaction()
221
 
        else:
222
 
            self.control_files._set_read_transaction()
 
135
    @needs_read_lock
 
136
    def get_revision_graph(self, revision_id=None):
 
137
        """Return a dictionary containing the revision graph.
 
138
 
 
139
        :param revision_id: The revision_id to get a graph from. If None, then
 
140
        the entire revision graph is returned. This is a deprecated mode of
 
141
        operation and will be removed in the future.
 
142
        :return: a dictionary of revision_id->revision_parents_list.
 
143
        """
 
144
        # special case NULL_REVISION
 
145
        if revision_id == _mod_revision.NULL_REVISION:
 
146
            return {}
 
147
        revision_id = osutils.safe_revision_id(revision_id)
 
148
        a_weave = self._get_revision_vf()
 
149
        if revision_id is None:
 
150
            return a_weave.get_graph()
 
151
        elif revision_id not in a_weave:
 
152
            raise errors.NoSuchRevision(self, revision_id)
 
153
        else:
 
154
            # add what can be reached from revision_id
 
155
            return a_weave.get_graph([revision_id])
 
156
 
 
157
    @needs_read_lock
 
158
    def get_revision_graph_with_ghosts(self, revision_ids=None):
 
159
        """Return a graph of the revisions with ghosts marked as applicable.
 
160
 
 
161
        :param revision_ids: an iterable of revisions to graph or None for all.
 
162
        :return: a Graph object with the graph reachable from revision_ids.
 
163
        """
 
164
        result = deprecated_graph.Graph()
 
165
        vf = self._get_revision_vf()
 
166
        versions = set(vf.versions())
 
167
        if not revision_ids:
 
168
            pending = set(self.all_revision_ids())
 
169
            required = set([])
 
170
        else:
 
171
            pending = set(osutils.safe_revision_id(r) for r in revision_ids)
 
172
            # special case NULL_REVISION
 
173
            if _mod_revision.NULL_REVISION in pending:
 
174
                pending.remove(_mod_revision.NULL_REVISION)
 
175
            required = set(pending)
 
176
        done = set([])
 
177
        while len(pending):
 
178
            revision_id = pending.pop()
 
179
            if not revision_id in versions:
 
180
                if revision_id in required:
 
181
                    raise errors.NoSuchRevision(self, revision_id)
 
182
                # a ghost
 
183
                result.add_ghost(revision_id)
 
184
                # mark it as done so we don't try for it again.
 
185
                done.add(revision_id)
 
186
                continue
 
187
            parent_ids = vf.get_parents_with_ghosts(revision_id)
 
188
            for parent_id in parent_ids:
 
189
                # is this queued or done ?
 
190
                if (parent_id not in pending and
 
191
                    parent_id not in done):
 
192
                    # no, queue it.
 
193
                    pending.add(parent_id)
 
194
            result.add_node(revision_id, parent_ids)
 
195
            done.add(revision_id)
 
196
        return result
 
197
 
 
198
    def _get_revision_vf(self):
 
199
        """:return: a versioned file containing the revisions."""
 
200
        vf = self._revision_store.get_revision_file(self.get_transaction())
 
201
        return vf
 
202
 
 
203
    def _get_history_vf(self):
 
204
        """Get a versionedfile whose history graph reflects all revisions.
 
205
 
 
206
        For knit repositories, this is the revision knit.
 
207
        """
 
208
        return self._get_revision_vf()
223
209
 
224
210
    @needs_write_lock
225
211
    def reconcile(self, other=None, thorough=False):
228
214
        reconciler = KnitReconciler(self, thorough=thorough)
229
215
        reconciler.reconcile()
230
216
        return reconciler
 
217
    
 
218
    def revision_parents(self, revision_id):
 
219
        revision_id = osutils.safe_revision_id(revision_id)
 
220
        return self._get_revision_vf().get_parents(revision_id)
231
221
 
232
222
    def _make_parents_provider(self):
233
 
        return _KnitsParentsProvider(self.revisions)
234
 
 
235
 
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
236
 
        """Find revisions with different parent lists in the revision object
237
 
        and in the index graph.
238
 
 
239
 
        :param revisions_iterator: None, or an iterator of (revid,
240
 
            Revision-or-None). This iterator controls the revisions checked.
241
 
        :returns: an iterator yielding tuples of (revison-id, parents-in-index,
242
 
            parents-in-revision).
243
 
        """
244
 
        if not self.is_locked():
245
 
            raise AssertionError()
246
 
        vf = self.revisions
247
 
        if revisions_iterator is None:
248
 
            revisions_iterator = self._iter_revisions(None)
249
 
        for revid, revision in revisions_iterator:
250
 
            if revision is None:
251
 
                pass
252
 
            parent_map = vf.get_parent_map([(revid,)])
253
 
            parents_according_to_index = tuple(parent[-1] for parent in
254
 
                parent_map[(revid,)])
255
 
            parents_according_to_revision = tuple(revision.parent_ids)
256
 
            if parents_according_to_index != parents_according_to_revision:
257
 
                yield (revid, parents_according_to_index,
258
 
                    parents_according_to_revision)
259
 
 
260
 
    def _check_for_inconsistent_revision_parents(self):
261
 
        inconsistencies = list(self._find_inconsistent_revision_parents())
262
 
        if inconsistencies:
263
 
            raise errors.BzrCheckError(
264
 
                "Revision knit has inconsistent parents.")
265
 
 
266
 
    def revision_graph_can_have_wrong_parents(self):
267
 
        # The revision.kndx could potentially claim a revision has a different
268
 
        # parent to the revision text.
269
 
        return True
 
223
        return _KnitParentsProvider(self._get_revision_vf())
 
224
 
 
225
 
 
226
class KnitRepository3(KnitRepository):
 
227
 
 
228
    def __init__(self, _format, a_bzrdir, control_files, _revision_store,
 
229
                 control_store, text_store):
 
230
        KnitRepository.__init__(self, _format, a_bzrdir, control_files,
 
231
                              _revision_store, control_store, text_store)
 
232
        self._serializer = xml7.serializer_v7
 
233
 
 
234
    def deserialise_inventory(self, revision_id, xml):
 
235
        """Transform the xml into an inventory object. 
 
236
 
 
237
        :param revision_id: The expected revision id of the inventory.
 
238
        :param xml: A serialised inventory.
 
239
        """
 
240
        result = self._serializer.read_inventory_from_string(xml)
 
241
        assert result.root.revision is not None
 
242
        return result
 
243
 
 
244
    def serialise_inventory(self, inv):
 
245
        """Transform the inventory object into XML text.
 
246
 
 
247
        :param revision_id: The expected revision id of the inventory.
 
248
        :param xml: A serialised inventory.
 
249
        """
 
250
        assert inv.revision_id is not None
 
251
        assert inv.root.revision is not None
 
252
        return KnitRepository.serialise_inventory(self, inv)
 
253
 
 
254
    def get_commit_builder(self, branch, parents, config, timestamp=None,
 
255
                           timezone=None, committer=None, revprops=None,
 
256
                           revision_id=None):
 
257
        """Obtain a CommitBuilder for this repository.
 
258
        
 
259
        :param branch: Branch to commit to.
 
260
        :param parents: Revision ids of the parents of the new revision.
 
261
        :param config: Configuration to use.
 
262
        :param timestamp: Optional timestamp recorded for commit.
 
263
        :param timezone: Optional timezone for timestamp.
 
264
        :param committer: Optional committer to set for commit.
 
265
        :param revprops: Optional dictionary of revision properties.
 
266
        :param revision_id: Optional revision id.
 
267
        """
 
268
        revision_id = osutils.safe_revision_id(revision_id)
 
269
        result = RootCommitBuilder(self, parents, config, timestamp, timezone,
 
270
                                 committer, revprops, revision_id)
 
271
        self.start_write_group()
 
272
        return result
270
273
 
271
274
 
272
275
class RepositoryFormatKnit(MetaDirRepositoryFormat):
273
 
    """Bzr repository knit format (generalized).
 
276
    """Bzr repository knit format (generalized). 
274
277
 
275
278
    This repository format has:
276
279
     - knits for file texts and inventory
283
286
     - a LockDir lock
284
287
    """
285
288
 
286
 
    # Set this attribute in derived classes to control the repository class
287
 
    # created by open and initialize.
288
 
    repository_class = None
289
 
    # Set this attribute in derived classes to control the
290
 
    # _commit_builder_class that the repository objects will have passed to
291
 
    # their constructor.
292
 
    _commit_builder_class = None
293
 
    # Set this attribute in derived clases to control the _serializer that the
294
 
    # repository objects will have passed to their constructor.
295
 
    @property
296
 
    def _serializer(self):
297
 
        return xml5.serializer_v5
298
 
    # Knit based repositories handle ghosts reasonably well.
299
 
    supports_ghosts = True
300
 
    # External lookups are not supported in this format.
301
 
    supports_external_lookups = False
302
 
    # No CHK support.
303
 
    supports_chks = False
304
 
    _fetch_order = 'topological'
305
 
    _fetch_uses_deltas = True
306
 
    fast_deltas = False
307
 
 
308
 
    def _get_inventories(self, repo_transport, repo, name='inventory'):
309
 
        mapper = versionedfile.ConstantMapper(name)
310
 
        index = _mod_knit._KndxIndex(repo_transport, mapper,
311
 
            repo.get_transaction, repo.is_write_locked, repo.is_locked)
312
 
        access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
313
 
        return _mod_knit.KnitVersionedFiles(index, access, annotated=False)
314
 
 
315
 
    def _get_revisions(self, repo_transport, repo):
316
 
        mapper = versionedfile.ConstantMapper('revisions')
317
 
        index = _mod_knit._KndxIndex(repo_transport, mapper,
318
 
            repo.get_transaction, repo.is_write_locked, repo.is_locked)
319
 
        access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
320
 
        return _mod_knit.KnitVersionedFiles(index, access, max_delta_chain=0,
321
 
            annotated=False)
322
 
 
323
 
    def _get_signatures(self, repo_transport, repo):
324
 
        mapper = versionedfile.ConstantMapper('signatures')
325
 
        index = _mod_knit._KndxIndex(repo_transport, mapper,
326
 
            repo.get_transaction, repo.is_write_locked, repo.is_locked)
327
 
        access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
328
 
        return _mod_knit.KnitVersionedFiles(index, access, max_delta_chain=0,
329
 
            annotated=False)
330
 
 
331
 
    def _get_texts(self, repo_transport, repo):
332
 
        mapper = versionedfile.HashEscapedPrefixMapper()
333
 
        base_transport = repo_transport.clone('knits')
334
 
        index = _mod_knit._KndxIndex(base_transport, mapper,
335
 
            repo.get_transaction, repo.is_write_locked, repo.is_locked)
336
 
        access = _mod_knit._KnitKeyAccess(base_transport, mapper)
337
 
        return _mod_knit.KnitVersionedFiles(index, access, max_delta_chain=200,
338
 
            annotated=True)
 
289
    def _get_control_store(self, repo_transport, control_files):
 
290
        """Return the control store for this repository."""
 
291
        return VersionedFileStore(
 
292
            repo_transport,
 
293
            prefixed=False,
 
294
            file_mode=control_files._file_mode,
 
295
            versionedfile_class=knit.KnitVersionedFile,
 
296
            versionedfile_kwargs={'factory':knit.KnitPlainFactory()},
 
297
            )
 
298
 
 
299
    def _get_revision_store(self, repo_transport, control_files):
 
300
        """See RepositoryFormat._get_revision_store()."""
 
301
        from bzrlib.store.revision.knit import KnitRevisionStore
 
302
        versioned_file_store = VersionedFileStore(
 
303
            repo_transport,
 
304
            file_mode=control_files._file_mode,
 
305
            prefixed=False,
 
306
            precious=True,
 
307
            versionedfile_class=knit.KnitVersionedFile,
 
308
            versionedfile_kwargs={'delta':False,
 
309
                                  'factory':knit.KnitPlainFactory(),
 
310
                                 },
 
311
            escaped=True,
 
312
            )
 
313
        return KnitRevisionStore(versioned_file_store)
 
314
 
 
315
    def _get_text_store(self, transport, control_files):
 
316
        """See RepositoryFormat._get_text_store()."""
 
317
        return self._get_versioned_file_store('knits',
 
318
                                  transport,
 
319
                                  control_files,
 
320
                                  versionedfile_class=knit.KnitVersionedFile,
 
321
                                  versionedfile_kwargs={
 
322
                                      'create_parent_dir':True,
 
323
                                      'delay_create':True,
 
324
                                      'dir_mode':control_files._dir_mode,
 
325
                                  },
 
326
                                  escaped=True)
339
327
 
340
328
    def initialize(self, a_bzrdir, shared=False):
341
329
        """Create a knit format 1 repository.
345
333
        :param shared: If true the repository will be initialized as a shared
346
334
                       repository.
347
335
        """
348
 
        trace.mutter('creating repository in %s.', a_bzrdir.transport.base)
349
 
        dirs = ['knits']
 
336
        mutter('creating repository in %s.', a_bzrdir.transport.base)
 
337
        dirs = ['revision-store', 'knits']
350
338
        files = []
351
339
        utf8_files = [('format', self.get_format_string())]
352
 
 
 
340
        
353
341
        self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
354
342
        repo_transport = a_bzrdir.get_repository_transport(None)
355
343
        control_files = lockable_files.LockableFiles(repo_transport,
356
344
                                'lock', lockdir.LockDir)
 
345
        control_store = self._get_control_store(repo_transport, control_files)
357
346
        transaction = transactions.WriteTransaction()
358
 
        result = self.open(a_bzrdir=a_bzrdir, _found=True)
359
 
        result.lock_write()
 
347
        # trigger a write of the inventory store.
 
348
        control_store.get_weave_or_empty('inventory', transaction)
 
349
        _revision_store = self._get_revision_store(repo_transport, control_files)
360
350
        # the revision id here is irrelevant: it will not be stored, and cannot
361
 
        # already exist, we do this to create files on disk for older clients.
362
 
        result.inventories.get_parent_map([('A',)])
363
 
        result.revisions.get_parent_map([('A',)])
364
 
        result.signatures.get_parent_map([('A',)])
365
 
        result.unlock()
366
 
        self._run_post_repo_init_hooks(result, a_bzrdir, shared)
367
 
        return result
 
351
        # already exist.
 
352
        _revision_store.has_revision_id('A', transaction)
 
353
        _revision_store.get_signature_file(transaction)
 
354
        return self.open(a_bzrdir=a_bzrdir, _found=True)
368
355
 
369
356
    def open(self, a_bzrdir, _found=False, _override_transport=None):
370
357
        """See RepositoryFormat.open().
371
 
 
 
358
        
372
359
        :param _override_transport: INTERNAL USE ONLY. Allows opening the
373
360
                                    repository at a slightly different url
374
361
                                    than normal. I.e. during 'upgrade'.
375
362
        """
376
363
        if not _found:
377
364
            format = RepositoryFormat.find_format(a_bzrdir)
 
365
            assert format.__class__ ==  self.__class__
378
366
        if _override_transport is not None:
379
367
            repo_transport = _override_transport
380
368
        else:
381
369
            repo_transport = a_bzrdir.get_repository_transport(None)
382
370
        control_files = lockable_files.LockableFiles(repo_transport,
383
371
                                'lock', lockdir.LockDir)
384
 
        repo = self.repository_class(_format=self,
 
372
        text_store = self._get_text_store(repo_transport, control_files)
 
373
        control_store = self._get_control_store(repo_transport, control_files)
 
374
        _revision_store = self._get_revision_store(repo_transport, control_files)
 
375
        return KnitRepository(_format=self,
385
376
                              a_bzrdir=a_bzrdir,
386
377
                              control_files=control_files,
387
 
                              _commit_builder_class=self._commit_builder_class,
388
 
                              _serializer=self._serializer)
389
 
        repo.revisions = self._get_revisions(repo_transport, repo)
390
 
        repo.signatures = self._get_signatures(repo_transport, repo)
391
 
        repo.inventories = self._get_inventories(repo_transport, repo)
392
 
        repo.texts = self._get_texts(repo_transport, repo)
393
 
        repo.chk_bytes = None
394
 
        repo._transport = repo_transport
395
 
        return repo
 
378
                              _revision_store=_revision_store,
 
379
                              control_store=control_store,
 
380
                              text_store=text_store)
396
381
 
397
382
 
398
383
class RepositoryFormatKnit1(RepositoryFormatKnit):
411
396
    This format was introduced in bzr 0.8.
412
397
    """
413
398
 
414
 
    repository_class = KnitRepository
415
 
    _commit_builder_class = CommitBuilder
416
 
    @property
417
 
    def _serializer(self):
418
 
        return xml5.serializer_v5
419
 
 
420
399
    def __ne__(self, other):
421
400
        return self.__class__ is not other.__class__
422
401
 
428
407
        """See RepositoryFormat.get_format_description()."""
429
408
        return "Knit repository format 1"
430
409
 
 
410
    def check_conversion_target(self, target_format):
 
411
        pass
 
412
 
431
413
 
432
414
class RepositoryFormatKnit3(RepositoryFormatKnit):
433
 
    """Bzr repository knit format 3.
 
415
    """Bzr repository knit format 2.
434
416
 
435
417
    This repository format has:
436
418
     - knits for file texts and inventory
445
427
     - support for recording tree-references
446
428
    """
447
429
 
448
 
    repository_class = KnitRepository
449
 
    _commit_builder_class = RootCommitBuilder
 
430
    repository_class = KnitRepository3
450
431
    rich_root_data = True
451
 
    experimental = True
452
432
    supports_tree_reference = True
453
 
    @property
454
 
    def _serializer(self):
455
 
        return xml7.serializer_v7
456
433
 
457
434
    def _get_matching_bzrdir(self):
458
435
        return bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
462
439
 
463
440
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
464
441
 
 
442
    def check_conversion_target(self, target_format):
 
443
        if not target_format.rich_root_data:
 
444
            raise errors.BadConversionTarget(
 
445
                'Does not support rich root data.', target_format)
 
446
        if not getattr(target_format, 'supports_tree_reference', False):
 
447
            raise errors.BadConversionTarget(
 
448
                'Does not support nested trees', target_format)
 
449
            
465
450
    def get_format_string(self):
466
451
        """See RepositoryFormat.get_format_string()."""
467
452
        return "Bazaar Knit Repository Format 3 (bzr 0.15)\n"
470
455
        """See RepositoryFormat.get_format_description()."""
471
456
        return "Knit repository format 3"
472
457
 
473
 
 
474
 
class RepositoryFormatKnit4(RepositoryFormatKnit):
475
 
    """Bzr repository knit format 4.
476
 
 
477
 
    This repository format has everything in format 3, except for
478
 
    tree-references:
479
 
     - knits for file texts and inventory
480
 
     - hash subdirectory based stores.
481
 
     - knits for revisions and signatures
482
 
     - TextStores for revisions and signatures.
483
 
     - a format marker of its own
484
 
     - an optional 'shared-storage' flag
485
 
     - an optional 'no-working-trees' flag
486
 
     - a LockDir lock
487
 
     - support for recording full info about the tree root
488
 
    """
489
 
 
490
 
    repository_class = KnitRepository
491
 
    _commit_builder_class = RootCommitBuilder
492
 
    rich_root_data = True
493
 
    supports_tree_reference = False
494
 
    @property
495
 
    def _serializer(self):
496
 
        return xml6.serializer_v6
497
 
 
498
 
    def _get_matching_bzrdir(self):
499
 
        return bzrdir.format_registry.make_bzrdir('rich-root')
500
 
 
501
 
    def _ignore_setting_bzrdir(self, format):
502
 
        pass
503
 
 
504
 
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
505
 
 
506
 
    def get_format_string(self):
507
 
        """See RepositoryFormat.get_format_string()."""
508
 
        return 'Bazaar Knit Repository Format 4 (bzr 1.0)\n'
509
 
 
510
 
    def get_format_description(self):
511
 
        """See RepositoryFormat.get_format_description()."""
512
 
        return "Knit repository format 4"
 
458
    def open(self, a_bzrdir, _found=False, _override_transport=None):
 
459
        """See RepositoryFormat.open().
 
460
        
 
461
        :param _override_transport: INTERNAL USE ONLY. Allows opening the
 
462
                                    repository at a slightly different url
 
463
                                    than normal. I.e. during 'upgrade'.
 
464
        """
 
465
        if not _found:
 
466
            format = RepositoryFormat.find_format(a_bzrdir)
 
467
            assert format.__class__ ==  self.__class__
 
468
        if _override_transport is not None:
 
469
            repo_transport = _override_transport
 
470
        else:
 
471
            repo_transport = a_bzrdir.get_repository_transport(None)
 
472
        control_files = lockable_files.LockableFiles(repo_transport, 'lock',
 
473
                                                     lockdir.LockDir)
 
474
        text_store = self._get_text_store(repo_transport, control_files)
 
475
        control_store = self._get_control_store(repo_transport, control_files)
 
476
        _revision_store = self._get_revision_store(repo_transport, control_files)
 
477
        return self.repository_class(_format=self,
 
478
                                     a_bzrdir=a_bzrdir,
 
479
                                     control_files=control_files,
 
480
                                     _revision_store=_revision_store,
 
481
                                     control_store=control_store,
 
482
                                     text_store=text_store)