~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repofmt/knitrepo.py

  • Committer: Martin Pool
  • Date: 2010-01-29 10:36:23 UTC
  • mto: This revision was merged to the branch mainline in revision 4992.
  • Revision ID: mbp@sourcefrog.net-20100129103623-hywka5hymo5z13jw
Change url to canonical.com or wiki, plus some doc improvements in passing

Show diffs side-by-side

added added

removed removed

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