← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repofmt/knitrepo.py

Merge up bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repofmt/knitrepo.py
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
16
 
 
17
 
from __future__ import absolute_import
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
16
 
19
17
from bzrlib.lazy_import import lazy_import
20
18
lazy_import(globals(), """
21
 
import itertools
22
 
 
23
 
from bzrlib import (
24
 
    controldir,
 
19
from bzrlib import (
 
20
    debug,
 
21
    )
 
22
from bzrlib.store import revision
 
23
from bzrlib.store.revision.knit import KnitRevisionStore
 
24
""")
 
25
from bzrlib import (
 
26
    bzrdir,
25
27
    errors,
26
 
    knit as _mod_knit,
 
28
    knit,
27
29
    lockable_files,
28
30
    lockdir,
29
31
    osutils,
30
 
    revision as _mod_revision,
31
 
    trace,
 
32
    symbol_versioning,
32
33
    transactions,
33
 
    versionedfile,
34
34
    xml5,
35
35
    xml6,
36
36
    xml7,
37
37
    )
38
 
""")
 
38
 
39
39
from bzrlib.decorators import needs_read_lock, needs_write_lock
40
40
from bzrlib.repository import (
41
 
    InterRepository,
42
 
    IsInWriteGroupError,
43
 
    RepositoryFormatMetaDir,
44
 
    )
45
 
from bzrlib.vf_repository import (
46
 
    InterSameDataRepository,
47
 
    MetaDirVersionedFileRepository,
48
 
    MetaDirVersionedFileRepositoryFormat,
49
 
    VersionedFileCommitBuilder,
50
 
    VersionedFileRootCommitBuilder,
51
 
    )
52
 
from bzrlib import symbol_versioning
 
41
    CommitBuilder,
 
42
    MetaDirRepository,
 
43
    MetaDirRepositoryFormat,
 
44
    RepositoryFormat,
 
45
    RootCommitBuilder,
 
46
    )
 
47
import bzrlib.revision as _mod_revision
 
48
from bzrlib.store.versioned import VersionedFileStore
 
49
from bzrlib.trace import mutter, mutter_callsite
 
50
from bzrlib.util import bencode
53
51
 
54
52
 
55
53
class _KnitParentsProvider(object):
60
58
    def __repr__(self):
61
59
        return 'KnitParentsProvider(%r)' % self._knit
62
60
 
 
61
    @symbol_versioning.deprecated_method(symbol_versioning.one_one)
 
62
    def get_parents(self, revision_ids):
 
63
        """See graph._StackedParentsProvider.get_parents"""
 
64
        parent_map = self.get_parent_map(revision_ids)
 
65
        return [parent_map.get(r, None) for r in revision_ids]
 
66
 
63
67
    def get_parent_map(self, keys):
64
 
        """See graph.StackedParentsProvider.get_parent_map"""
 
68
        """See graph._StackedParentsProvider.get_parent_map"""
65
69
        parent_map = {}
66
70
        for revision_id in keys:
67
 
            if revision_id is None:
68
 
                raise ValueError('get_parent_map(None) is not valid')
69
71
            if revision_id == _mod_revision.NULL_REVISION:
70
72
                parent_map[revision_id] = ()
71
73
            else:
81
83
        return parent_map
82
84
 
83
85
 
84
 
class _KnitsParentsProvider(object):
85
 
 
86
 
    def __init__(self, knit, prefix=()):
87
 
        """Create a parent provider for string keys mapped to tuple keys."""
88
 
        self._knit = knit
89
 
        self._prefix = prefix
90
 
 
91
 
    def __repr__(self):
92
 
        return 'KnitsParentsProvider(%r)' % self._knit
93
 
 
94
 
    def get_parent_map(self, keys):
95
 
        """See graph.StackedParentsProvider.get_parent_map"""
96
 
        parent_map = self._knit.get_parent_map(
97
 
            [self._prefix + (key,) for key in keys])
98
 
        result = {}
99
 
        for key, parents in parent_map.items():
100
 
            revid = key[-1]
101
 
            if len(parents) == 0:
102
 
                parents = (_mod_revision.NULL_REVISION,)
103
 
            else:
104
 
                parents = tuple(parent[-1] for parent in parents)
105
 
            result[revid] = parents
106
 
        for revision_id in keys:
107
 
            if revision_id == _mod_revision.NULL_REVISION:
108
 
                result[revision_id] = ()
109
 
        return result
110
 
 
111
 
 
112
 
class KnitRepository(MetaDirVersionedFileRepository):
 
86
class KnitRepository(MetaDirRepository):
113
87
    """Knit format repository."""
114
88
 
115
89
    # These attributes are inherited from the Repository base class. Setting
119
93
    _commit_builder_class = None
120
94
    _serializer = None
121
95
 
122
 
    def __init__(self, _format, a_bzrdir, control_files, _commit_builder_class,
123
 
        _serializer):
124
 
        super(KnitRepository, self).__init__(_format, a_bzrdir, control_files)
 
96
    def __init__(self, _format, a_bzrdir, control_files, _revision_store,
 
97
        control_store, text_store, _commit_builder_class, _serializer):
 
98
        MetaDirRepository.__init__(self, _format, a_bzrdir, control_files,
 
99
            _revision_store, control_store, text_store)
125
100
        self._commit_builder_class = _commit_builder_class
126
101
        self._serializer = _serializer
127
102
        self._reconcile_fixes_text_parents = True
 
103
        control_store.get_scope = self.get_transaction
 
104
        text_store.get_scope = self.get_transaction
 
105
        _revision_store.get_scope = self.get_transaction
 
106
 
 
107
    def _warn_if_deprecated(self):
 
108
        # This class isn't deprecated
 
109
        pass
 
110
 
 
111
    def _inventory_add_lines(self, inv_vf, revid, parents, lines, check_content):
 
112
        return inv_vf.add_lines_with_ghosts(revid, parents, lines,
 
113
            check_content=check_content)[0]
128
114
 
129
115
    @needs_read_lock
130
116
    def _all_revision_ids(self):
131
117
        """See Repository.all_revision_ids()."""
132
 
        return [key[0] for key in self.revisions.keys()]
133
 
 
134
 
    def _activate_new_inventory(self):
135
 
        """Put a replacement inventory.new into use as inventories."""
136
 
        # Copy the content across
137
 
        t = self._transport
138
 
        t.copy('inventory.new.kndx', 'inventory.kndx')
139
 
        try:
140
 
            t.copy('inventory.new.knit', 'inventory.knit')
141
 
        except errors.NoSuchFile:
142
 
            # empty inventories knit
143
 
            t.delete('inventory.knit')
144
 
        # delete the temp inventory
145
 
        t.delete('inventory.new.kndx')
146
 
        try:
147
 
            t.delete('inventory.new.knit')
148
 
        except errors.NoSuchFile:
149
 
            # empty inventories knit
150
 
            pass
151
 
        # Force index reload (sanity check)
152
 
        self.inventories._index._reset_cache()
153
 
        self.inventories.keys()
154
 
 
155
 
    def _backup_inventory(self):
156
 
        t = self._transport
157
 
        t.copy('inventory.kndx', 'inventory.backup.kndx')
158
 
        t.copy('inventory.knit', 'inventory.backup.knit')
159
 
 
160
 
    def _move_file_id(self, from_id, to_id):
161
 
        t = self._transport.clone('knits')
162
 
        from_rel_url = self.texts._index._mapper.map((from_id, None))
163
 
        to_rel_url = self.texts._index._mapper.map((to_id, None))
164
 
        # We expect both files to always exist in this case.
165
 
        for suffix in ('.knit', '.kndx'):
166
 
            t.rename(from_rel_url + suffix, to_rel_url + suffix)
167
 
 
168
 
    def _remove_file_id(self, file_id):
169
 
        t = self._transport.clone('knits')
170
 
        rel_url = self.texts._index._mapper.map((file_id, None))
171
 
        for suffix in ('.kndx', '.knit'):
172
 
            try:
173
 
                t.delete(rel_url + suffix)
174
 
            except errors.NoSuchFile:
175
 
                pass
176
 
 
177
 
    def _temp_inventories(self):
178
 
        result = self._format._get_inventories(self._transport, self,
179
 
            'inventory.new')
180
 
        # Reconciling when the output has no revisions would result in no
181
 
        # writes - but we want to ensure there is an inventory for
182
 
        # compatibility with older clients that don't lazy-load.
183
 
        result.get_parent_map([('A',)])
184
 
        return result
 
118
        # Knits get the revision graph from the index of the revision knit, so
 
119
        # it's always possible even if they're on an unlistable transport.
 
120
        return self._revision_store.all_revision_ids(self.get_transaction())
 
121
 
 
122
    def fileid_involved_between_revs(self, from_revid, to_revid):
 
123
        """Find file_id(s) which are involved in the changes between revisions.
 
124
 
 
125
        This determines the set of revisions which are involved, and then
 
126
        finds all file ids affected by those revisions.
 
127
        """
 
128
        vf = self._get_revision_vf()
 
129
        from_set = set(vf.get_ancestry(from_revid))
 
130
        to_set = set(vf.get_ancestry(to_revid))
 
131
        changed = to_set.difference(from_set)
 
132
        return self._fileid_involved_by_set(changed)
 
133
 
 
134
    def fileid_involved(self, last_revid=None):
 
135
        """Find all file_ids modified in the ancestry of last_revid.
 
136
 
 
137
        :param last_revid: If None, last_revision() will be used.
 
138
        """
 
139
        if not last_revid:
 
140
            changed = set(self.all_revision_ids())
 
141
        else:
 
142
            changed = set(self.get_ancestry(last_revid))
 
143
        if None in changed:
 
144
            changed.remove(None)
 
145
        return self._fileid_involved_by_set(changed)
 
146
 
 
147
    @needs_read_lock
 
148
    def get_ancestry(self, revision_id, topo_sorted=True):
 
149
        """Return a list of revision-ids integrated by a revision.
 
150
        
 
151
        This is topologically sorted, unless 'topo_sorted' is specified as
 
152
        False.
 
153
        """
 
154
        if _mod_revision.is_null(revision_id):
 
155
            return [None]
 
156
        vf = self._get_revision_vf()
 
157
        try:
 
158
            return [None] + vf.get_ancestry(revision_id, topo_sorted)
 
159
        except errors.RevisionNotPresent:
 
160
            raise errors.NoSuchRevision(self, revision_id)
 
161
 
 
162
    @symbol_versioning.deprecated_method(symbol_versioning.one_two)
 
163
    def get_data_stream(self, revision_ids):
 
164
        """See Repository.get_data_stream.
 
165
        
 
166
        Deprecated in 1.2 for get_data_stream_for_search.
 
167
        """
 
168
        search_result = self.revision_ids_to_search_result(set(revision_ids))
 
169
        return self.get_data_stream_for_search(search_result)
 
170
 
 
171
    def get_data_stream_for_search(self, search):
 
172
        """See Repository.get_data_stream_for_search."""
 
173
        item_keys = self.item_keys_introduced_by(search.get_keys())
 
174
        for knit_kind, file_id, versions in item_keys:
 
175
            name = (knit_kind,)
 
176
            if knit_kind == 'file':
 
177
                name = ('file', file_id)
 
178
                knit = self.weave_store.get_weave_or_empty(
 
179
                    file_id, self.get_transaction())
 
180
            elif knit_kind == 'inventory':
 
181
                knit = self.get_inventory_weave()
 
182
            elif knit_kind == 'revisions':
 
183
                knit = self._revision_store.get_revision_file(
 
184
                    self.get_transaction())
 
185
            elif knit_kind == 'signatures':
 
186
                knit = self._revision_store.get_signature_file(
 
187
                    self.get_transaction())
 
188
            else:
 
189
                raise AssertionError('Unknown knit kind %r' % (knit_kind,))
 
190
            yield name, _get_stream_as_bytes(knit, versions)
185
191
 
186
192
    @needs_read_lock
187
193
    def get_revision(self, revision_id):
189
195
        revision_id = osutils.safe_revision_id(revision_id)
190
196
        return self.get_revision_reconcile(revision_id)
191
197
 
192
 
    def _refresh_data(self):
193
 
        if not self.is_locked():
194
 
            return
195
 
        if self.is_in_write_group():
196
 
            raise IsInWriteGroupError(self)
197
 
        # Create a new transaction to force all knits to see the scope change.
198
 
        # This is safe because we're outside a write group.
199
 
        self.control_files._finish_transaction()
200
 
        if self.is_write_locked():
201
 
            self.control_files._set_write_transaction()
202
 
        else:
203
 
            self.control_files._set_read_transaction()
 
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 has_revisions(self, revision_ids):
 
204
        """See Repository.has_revisions()."""
 
205
        result = set()
 
206
        transaction = self.get_transaction()
 
207
        for revision_id in revision_ids:
 
208
            if self._revision_store.has_revision_id(revision_id, transaction):
 
209
                result.add(revision_id)
 
210
        return result
204
211
 
205
212
    @needs_write_lock
206
213
    def reconcile(self, other=None, thorough=False):
209
216
        reconciler = KnitReconciler(self, thorough=thorough)
210
217
        reconciler.reconcile()
211
218
        return reconciler
 
219
    
 
220
    @symbol_versioning.deprecated_method(symbol_versioning.one_five)
 
221
    def revision_parents(self, revision_id):
 
222
        return self._get_revision_vf().get_parents(revision_id)
212
223
 
213
224
    def _make_parents_provider(self):
214
 
        return _KnitsParentsProvider(self.revisions)
215
 
 
216
 
 
217
 
class RepositoryFormatKnit(MetaDirVersionedFileRepositoryFormat):
218
 
    """Bzr repository knit format (generalized).
 
225
        return _KnitParentsProvider(self._get_revision_vf())
 
226
 
 
227
    def _find_inconsistent_revision_parents(self):
 
228
        """Find revisions with different parent lists in the revision object
 
229
        and in the index graph.
 
230
 
 
231
        :returns: an iterator yielding tuples of (revison-id, parents-in-index,
 
232
            parents-in-revision).
 
233
        """
 
234
        if not self.is_locked():
 
235
            raise AssertionError()
 
236
        vf = self._get_revision_vf()
 
237
        for index_version in vf.versions():
 
238
            parents_according_to_index = tuple(vf.get_parents_with_ghosts(
 
239
                index_version))
 
240
            revision = self.get_revision(index_version)
 
241
            parents_according_to_revision = tuple(revision.parent_ids)
 
242
            if parents_according_to_index != parents_according_to_revision:
 
243
                yield (index_version, parents_according_to_index,
 
244
                    parents_according_to_revision)
 
245
 
 
246
    def _check_for_inconsistent_revision_parents(self):
 
247
        inconsistencies = list(self._find_inconsistent_revision_parents())
 
248
        if inconsistencies:
 
249
            raise errors.BzrCheckError(
 
250
                "Revision knit has inconsistent parents.")
 
251
 
 
252
    def revision_graph_can_have_wrong_parents(self):
 
253
        # The revision.kndx could potentially claim a revision has a different
 
254
        # parent to the revision text.
 
255
        return True
 
256
 
 
257
 
 
258
class RepositoryFormatKnit(MetaDirRepositoryFormat):
 
259
    """Bzr repository knit format (generalized). 
219
260
 
220
261
    This repository format has:
221
262
     - knits for file texts and inventory
237
278
    _commit_builder_class = None
238
279
    # Set this attribute in derived clases to control the _serializer that the
239
280
    # repository objects will have passed to their constructor.
240
 
    @property
241
 
    def _serializer(self):
242
 
        return xml5.serializer_v5
 
281
    _serializer = xml5.serializer_v5
243
282
    # Knit based repositories handle ghosts reasonably well.
244
283
    supports_ghosts = True
245
284
    # External lookups are not supported in this format.
246
285
    supports_external_lookups = False
247
 
    # No CHK support.
248
 
    supports_chks = False
249
 
    _fetch_order = 'topological'
250
 
    _fetch_uses_deltas = True
251
 
    fast_deltas = False
252
 
    supports_funky_characters = True
253
 
    # The revision.kndx could potentially claim a revision has a different
254
 
    # parent to the revision text.
255
 
    revision_graph_can_have_wrong_parents = True
256
 
 
257
 
    def _get_inventories(self, repo_transport, repo, name='inventory'):
258
 
        mapper = versionedfile.ConstantMapper(name)
259
 
        index = _mod_knit._KndxIndex(repo_transport, mapper,
260
 
            repo.get_transaction, repo.is_write_locked, repo.is_locked)
261
 
        access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
262
 
        return _mod_knit.KnitVersionedFiles(index, access, annotated=False)
263
 
 
264
 
    def _get_revisions(self, repo_transport, repo):
265
 
        mapper = versionedfile.ConstantMapper('revisions')
266
 
        index = _mod_knit._KndxIndex(repo_transport, mapper,
267
 
            repo.get_transaction, repo.is_write_locked, repo.is_locked)
268
 
        access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
269
 
        return _mod_knit.KnitVersionedFiles(index, access, max_delta_chain=0,
270
 
            annotated=False)
271
 
 
272
 
    def _get_signatures(self, repo_transport, repo):
273
 
        mapper = versionedfile.ConstantMapper('signatures')
274
 
        index = _mod_knit._KndxIndex(repo_transport, mapper,
275
 
            repo.get_transaction, repo.is_write_locked, repo.is_locked)
276
 
        access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
277
 
        return _mod_knit.KnitVersionedFiles(index, access, max_delta_chain=0,
278
 
            annotated=False)
279
 
 
280
 
    def _get_texts(self, repo_transport, repo):
281
 
        mapper = versionedfile.HashEscapedPrefixMapper()
282
 
        base_transport = repo_transport.clone('knits')
283
 
        index = _mod_knit._KndxIndex(base_transport, mapper,
284
 
            repo.get_transaction, repo.is_write_locked, repo.is_locked)
285
 
        access = _mod_knit._KnitKeyAccess(base_transport, mapper)
286
 
        return _mod_knit.KnitVersionedFiles(index, access, max_delta_chain=200,
287
 
            annotated=True)
 
286
 
 
287
    def _get_control_store(self, repo_transport, control_files):
 
288
        """Return the control store for this repository."""
 
289
        return VersionedFileStore(
 
290
            repo_transport,
 
291
            prefixed=False,
 
292
            file_mode=control_files._file_mode,
 
293
            versionedfile_class=knit.make_file_knit,
 
294
            versionedfile_kwargs={'factory':knit.KnitPlainFactory()},
 
295
            )
 
296
 
 
297
    def _get_revision_store(self, repo_transport, control_files):
 
298
        """See RepositoryFormat._get_revision_store()."""
 
299
        versioned_file_store = VersionedFileStore(
 
300
            repo_transport,
 
301
            file_mode=control_files._file_mode,
 
302
            prefixed=False,
 
303
            precious=True,
 
304
            versionedfile_class=knit.make_file_knit,
 
305
            versionedfile_kwargs={'delta':False,
 
306
                                  'factory':knit.KnitPlainFactory(),
 
307
                                 },
 
308
            escaped=False,
 
309
            )
 
310
        return KnitRevisionStore(versioned_file_store)
 
311
 
 
312
    def _get_text_store(self, transport, control_files):
 
313
        """See RepositoryFormat._get_text_store()."""
 
314
        return self._get_versioned_file_store('knits',
 
315
                                  transport,
 
316
                                  control_files,
 
317
                                  versionedfile_class=knit.make_file_knit,
 
318
                                  versionedfile_kwargs={
 
319
                                      'create_parent_dir':True,
 
320
                                      'delay_create':True,
 
321
                                      'dir_mode':control_files._dir_mode,
 
322
                                  },
 
323
                                  escaped=True)
288
324
 
289
325
    def initialize(self, a_bzrdir, shared=False):
290
326
        """Create a knit format 1 repository.
294
330
        :param shared: If true the repository will be initialized as a shared
295
331
                       repository.
296
332
        """
297
 
        trace.mutter('creating repository in %s.', a_bzrdir.transport.base)
 
333
        mutter('creating repository in %s.', a_bzrdir.transport.base)
298
334
        dirs = ['knits']
299
335
        files = []
300
336
        utf8_files = [('format', self.get_format_string())]
301
 
 
 
337
        
302
338
        self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
303
339
        repo_transport = a_bzrdir.get_repository_transport(None)
304
340
        control_files = lockable_files.LockableFiles(repo_transport,
305
341
                                'lock', lockdir.LockDir)
 
342
        control_store = self._get_control_store(repo_transport, control_files)
306
343
        transaction = transactions.WriteTransaction()
307
 
        result = self.open(a_bzrdir=a_bzrdir, _found=True)
308
 
        result.lock_write()
 
344
        # trigger a write of the inventory store.
 
345
        control_store.get_weave_or_empty('inventory', transaction)
 
346
        _revision_store = self._get_revision_store(repo_transport, control_files)
309
347
        # the revision id here is irrelevant: it will not be stored, and cannot
310
 
        # already exist, we do this to create files on disk for older clients.
311
 
        result.inventories.get_parent_map([('A',)])
312
 
        result.revisions.get_parent_map([('A',)])
313
 
        result.signatures.get_parent_map([('A',)])
314
 
        result.unlock()
315
 
        self._run_post_repo_init_hooks(result, a_bzrdir, shared)
316
 
        return result
 
348
        # already exist.
 
349
        _revision_store.has_revision_id('A', transaction)
 
350
        _revision_store.get_signature_file(transaction)
 
351
        return self.open(a_bzrdir=a_bzrdir, _found=True)
317
352
 
318
353
    def open(self, a_bzrdir, _found=False, _override_transport=None):
319
354
        """See RepositoryFormat.open().
320
 
 
 
355
        
321
356
        :param _override_transport: INTERNAL USE ONLY. Allows opening the
322
357
                                    repository at a slightly different url
323
358
                                    than normal. I.e. during 'upgrade'.
324
359
        """
325
360
        if not _found:
326
 
            format = RepositoryFormatMetaDir.find_format(a_bzrdir)
 
361
            format = RepositoryFormat.find_format(a_bzrdir)
327
362
        if _override_transport is not None:
328
363
            repo_transport = _override_transport
329
364
        else:
330
365
            repo_transport = a_bzrdir.get_repository_transport(None)
331
366
        control_files = lockable_files.LockableFiles(repo_transport,
332
367
                                'lock', lockdir.LockDir)
333
 
        repo = self.repository_class(_format=self,
 
368
        text_store = self._get_text_store(repo_transport, control_files)
 
369
        control_store = self._get_control_store(repo_transport, control_files)
 
370
        _revision_store = self._get_revision_store(repo_transport, control_files)
 
371
        return self.repository_class(_format=self,
334
372
                              a_bzrdir=a_bzrdir,
335
373
                              control_files=control_files,
 
374
                              _revision_store=_revision_store,
 
375
                              control_store=control_store,
 
376
                              text_store=text_store,
336
377
                              _commit_builder_class=self._commit_builder_class,
337
378
                              _serializer=self._serializer)
338
 
        repo.revisions = self._get_revisions(repo_transport, repo)
339
 
        repo.signatures = self._get_signatures(repo_transport, repo)
340
 
        repo.inventories = self._get_inventories(repo_transport, repo)
341
 
        repo.texts = self._get_texts(repo_transport, repo)
342
 
        repo.chk_bytes = None
343
 
        repo._transport = repo_transport
344
 
        return repo
345
379
 
346
380
 
347
381
class RepositoryFormatKnit1(RepositoryFormatKnit):
361
395
    """
362
396
 
363
397
    repository_class = KnitRepository
364
 
    _commit_builder_class = VersionedFileCommitBuilder
365
 
    @property
366
 
    def _serializer(self):
367
 
        return xml5.serializer_v5
 
398
    _commit_builder_class = CommitBuilder
 
399
    _serializer = xml5.serializer_v5
368
400
 
369
401
    def __ne__(self, other):
370
402
        return self.__class__ is not other.__class__
371
403
 
372
 
    @classmethod
373
 
    def get_format_string(cls):
 
404
    def get_format_string(self):
374
405
        """See RepositoryFormat.get_format_string()."""
375
406
        return "Bazaar-NG Knit Repository Format 1"
376
407
 
378
409
        """See RepositoryFormat.get_format_description()."""
379
410
        return "Knit repository format 1"
380
411
 
 
412
    def check_conversion_target(self, target_format):
 
413
        pass
 
414
 
381
415
 
382
416
class RepositoryFormatKnit3(RepositoryFormatKnit):
383
417
    """Bzr repository knit format 3.
396
430
    """
397
431
 
398
432
    repository_class = KnitRepository
399
 
    _commit_builder_class = VersionedFileRootCommitBuilder
 
433
    _commit_builder_class = RootCommitBuilder
400
434
    rich_root_data = True
401
 
    experimental = True
402
435
    supports_tree_reference = True
403
 
    @property
404
 
    def _serializer(self):
405
 
        return xml7.serializer_v7
 
436
    _serializer = xml7.serializer_v7
406
437
 
407
438
    def _get_matching_bzrdir(self):
408
 
        return controldir.format_registry.make_bzrdir('dirstate-with-subtree')
 
439
        return bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
409
440
 
410
441
    def _ignore_setting_bzrdir(self, format):
411
442
        pass
412
443
 
413
444
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
414
445
 
415
 
    @classmethod
416
 
    def get_format_string(cls):
 
446
    def check_conversion_target(self, target_format):
 
447
        if not target_format.rich_root_data:
 
448
            raise errors.BadConversionTarget(
 
449
                'Does not support rich root data.', target_format)
 
450
        if not getattr(target_format, 'supports_tree_reference', False):
 
451
            raise errors.BadConversionTarget(
 
452
                'Does not support nested trees', target_format)
 
453
            
 
454
    def get_format_string(self):
417
455
        """See RepositoryFormat.get_format_string()."""
418
456
        return "Bazaar Knit Repository Format 3 (bzr 0.15)\n"
419
457
 
439
477
    """
440
478
 
441
479
    repository_class = KnitRepository
442
 
    _commit_builder_class = VersionedFileRootCommitBuilder
 
480
    _commit_builder_class = RootCommitBuilder
443
481
    rich_root_data = True
444
482
    supports_tree_reference = False
445
 
    @property
446
 
    def _serializer(self):
447
 
        return xml6.serializer_v6
 
483
    _serializer = xml6.serializer_v6
448
484
 
449
485
    def _get_matching_bzrdir(self):
450
 
        return controldir.format_registry.make_bzrdir('rich-root')
 
486
        return bzrdir.format_registry.make_bzrdir('rich-root')
451
487
 
452
488
    def _ignore_setting_bzrdir(self, format):
453
489
        pass
454
490
 
455
491
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
456
492
 
457
 
    @classmethod
458
 
    def get_format_string(cls):
 
493
    def check_conversion_target(self, target_format):
 
494
        if not target_format.rich_root_data:
 
495
            raise errors.BadConversionTarget(
 
496
                'Does not support rich root data.', target_format)
 
497
 
 
498
    def get_format_string(self):
459
499
        """See RepositoryFormat.get_format_string()."""
460
500
        return 'Bazaar Knit Repository Format 4 (bzr 1.0)\n'
461
501
 
464
504
        return "Knit repository format 4"
465
505
 
466
506
 
467
 
class InterKnitRepo(InterSameDataRepository):
468
 
    """Optimised code paths between Knit based repositories."""
469
 
 
470
 
    @classmethod
471
 
    def _get_repo_format_to_test(self):
472
 
        return RepositoryFormatKnit1()
473
 
 
474
 
    @staticmethod
475
 
    def is_compatible(source, target):
476
 
        """Be compatible with known Knit formats.
477
 
 
478
 
        We don't test for the stores being of specific types because that
479
 
        could lead to confusing results, and there is no need to be
480
 
        overly general.
481
 
        """
482
 
        try:
483
 
            are_knits = (isinstance(source._format, RepositoryFormatKnit) and
484
 
                isinstance(target._format, RepositoryFormatKnit))
485
 
        except AttributeError:
486
 
            return False
487
 
        return are_knits and InterRepository._same_model(source, target)
488
 
 
489
 
    @needs_read_lock
490
 
    def search_missing_revision_ids(self,
491
 
            find_ghosts=True, revision_ids=None, if_present_ids=None,
492
 
            limit=None):
493
 
        """See InterRepository.search_missing_revision_ids()."""
494
 
        source_ids_set = self._present_source_revisions_for(
495
 
            revision_ids, if_present_ids)
496
 
        # source_ids is the worst possible case we may need to pull.
497
 
        # now we want to filter source_ids against what we actually
498
 
        # have in target, but don't try to check for existence where we know
499
 
        # we do not have a revision as that would be pointless.
500
 
        target_ids = set(self.target.all_revision_ids())
501
 
        possibly_present_revisions = target_ids.intersection(source_ids_set)
502
 
        actually_present_revisions = set(
503
 
            self.target._eliminate_revisions_not_present(possibly_present_revisions))
504
 
        required_revisions = source_ids_set.difference(actually_present_revisions)
505
 
        if revision_ids is not None:
506
 
            # we used get_ancestry to determine source_ids then we are assured all
507
 
            # revisions referenced are present as they are installed in topological order.
508
 
            # and the tip revision was validated by get_ancestry.
509
 
            result_set = required_revisions
510
 
        else:
511
 
            # if we just grabbed the possibly available ids, then
512
 
            # we only have an estimate of whats available and need to validate
513
 
            # that against the revision records.
514
 
            result_set = set(
515
 
                self.source._eliminate_revisions_not_present(required_revisions))
516
 
        if limit is not None:
517
 
            topo_ordered = self.source.get_graph().iter_topo_order(result_set)
518
 
            result_set = set(itertools.islice(topo_ordered, limit))
519
 
        return self.source.revision_ids_to_search_result(result_set)
520
 
 
521
 
 
522
 
InterRepository.register_optimiser(InterKnitRepo)
 
507
def _get_stream_as_bytes(knit, required_versions):
 
508
    """Generate a serialised data stream.
 
509
 
 
510
    The format is a bencoding of a list.  The first element of the list is a
 
511
    string of the format signature, then each subsequent element is a list
 
512
    corresponding to a record.  Those lists contain:
 
513
 
 
514
      * a version id
 
515
      * a list of options
 
516
      * a list of parents
 
517
      * the bytes
 
518
 
 
519
    :returns: a bencoded list.
 
520
    """
 
521
    knit_stream = knit.get_data_stream(required_versions)
 
522
    format_signature, data_list, callable = knit_stream
 
523
    data = []
 
524
    data.append(format_signature)
 
525
    for version, options, length, parents in data_list:
 
526
        data.append([version, options, parents, callable(length)])
 
527
    return bencode.bencode(data)