/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/weaverepo.py

  • Committer: Andrew Bennetts
  • Date: 2009-02-20 06:16:22 UTC
  • mfrom: (4023 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4027.
  • Revision ID: andrew.bennetts@canonical.com-20090220061622-te9miq29rlfqiwwv
Merge bzr.dev.

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, 2008 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
17
"""Deprecated weave-based repository formats.
18
18
 
28
28
lazy_import(globals(), """
29
29
from bzrlib import (
30
30
    xml5,
31
 
    graph as _mod_graph,
32
31
    )
33
32
""")
34
33
from bzrlib import (
39
38
    lockdir,
40
39
    osutils,
41
40
    revision as _mod_revision,
42
 
    trace,
43
41
    urlutils,
44
42
    versionedfile,
45
43
    weave,
54
52
    RepositoryFormat,
55
53
    )
56
54
from bzrlib.store.text import TextStore
 
55
from bzrlib.trace import mutter
57
56
from bzrlib.tuned_gzip import GzipFile, bytes_to_gzip
58
57
from bzrlib.versionedfile import (
59
58
    AbsentContentFactory,
83
82
 
84
83
        def get_store(name, compressed=True, prefixed=False):
85
84
            # FIXME: This approach of assuming stores are all entirely compressed
86
 
            # or entirely uncompressed is tidy, but breaks upgrade from
87
 
            # some existing branches where there's a mixture; we probably
 
85
            # or entirely uncompressed is tidy, but breaks upgrade from 
 
86
            # some existing branches where there's a mixture; we probably 
88
87
            # still want the option to look for both.
89
88
            relpath = self._escape(name)
90
89
            store = TextStore(a_bzrdir.transport.clone(relpath),
96
95
        # not broken out yet because the controlweaves|inventory_store
97
96
        # and texts bits are still different.
98
97
        if isinstance(_format, RepositoryFormat4):
99
 
            # cannot remove these - there is still no consistent api
 
98
            # cannot remove these - there is still no consistent api 
100
99
            # which allows access to this old info.
101
100
            self.inventory_store = get_store('inventory-store')
102
101
            self._text_store = get_store('text-store')
103
102
        super(AllInOneRepository, self).__init__(_format, a_bzrdir, a_bzrdir._control_files)
 
103
        self._fetch_order = 'topological'
 
104
        self._fetch_reconcile = True
104
105
 
105
106
    @needs_read_lock
106
107
    def _all_possible_ids(self):
107
108
        """Return all the possible revisions that we could find."""
108
109
        if 'evil' in debug.debug_flags:
109
 
            trace.mutter_callsite(
110
 
                3, "_all_possible_ids scales with size of history.")
 
110
            mutter_callsite(3, "_all_possible_ids scales with size of history.")
111
111
        return [key[-1] for key in self.inventories.keys()]
112
112
 
113
113
    @needs_read_lock
114
114
    def _all_revision_ids(self):
115
 
        """Returns a list of all the revision ids in the repository.
 
115
        """Returns a list of all the revision ids in the repository. 
116
116
 
117
 
        These are in as much topological order as the underlying store can
 
117
        These are in as much topological order as the underlying store can 
118
118
        present: for weaves ghosts may lead to a lack of correctness until
119
119
        the reweave updates the parents list.
120
120
        """
177
177
        :param new_value: True to restore the default, False to disable making
178
178
                          working trees.
179
179
        """
180
 
        raise errors.RepositoryUpgradeRequired(self.user_url)
 
180
        raise errors.RepositoryUpgradeRequired(self.bzrdir.root_transport.base)
181
181
 
182
182
    def make_working_trees(self):
183
183
        """Returns the policy for making working trees on new branches."""
192
192
class WeaveMetaDirRepository(MetaDirVersionedFileRepository):
193
193
    """A subclass of MetaDirRepository to set weave specific policy."""
194
194
 
 
195
    @property
 
196
    def _serializer(self):
 
197
        return xml5.serializer_v5
 
198
 
195
199
    def __init__(self, _format, a_bzrdir, control_files):
196
200
        super(WeaveMetaDirRepository, self).__init__(_format, a_bzrdir, control_files)
197
 
        self._serializer = _format._serializer
 
201
        self._fetch_order = 'topological'
 
202
        self._fetch_reconcile = True
198
203
 
199
204
    @needs_read_lock
200
205
    def _all_possible_ids(self):
201
206
        """Return all the possible revisions that we could find."""
202
207
        if 'evil' in debug.debug_flags:
203
 
            trace.mutter_callsite(
204
 
                3, "_all_possible_ids scales with size of history.")
 
208
            mutter_callsite(3, "_all_possible_ids scales with size of history.")
205
209
        return [key[-1] for key in self.inventories.keys()]
206
210
 
207
211
    @needs_read_lock
208
212
    def _all_revision_ids(self):
209
 
        """Returns a list of all the revision ids in the repository.
 
213
        """Returns a list of all the revision ids in the repository. 
210
214
 
211
 
        These are in as much topological order as the underlying store can
 
215
        These are in as much topological order as the underlying store can 
212
216
        present: for weaves ghosts may lead to a lack of correctness until
213
217
        the reweave updates the parents list.
214
218
        """
269
273
    supports_tree_reference = False
270
274
    supports_ghosts = False
271
275
    supports_external_lookups = False
272
 
    supports_chks = False
273
 
    _fetch_order = 'topological'
274
 
    _fetch_reconcile = True
275
 
    fast_deltas = False
276
276
 
277
277
    def initialize(self, a_bzrdir, shared=False, _internal=False):
278
278
        """Create a weave repository."""
282
282
        if not _internal:
283
283
            # always initialized when the bzrdir is.
284
284
            return self.open(a_bzrdir, _found=True)
285
 
 
 
285
        
286
286
        # Create an empty weave
287
287
        sio = StringIO()
288
288
        weavefile.write_weave_v5(weave.Weave(), sio)
289
289
        empty_weave = sio.getvalue()
290
290
 
291
 
        trace.mutter('creating repository in %s.', a_bzrdir.transport.base)
292
 
 
 
291
        mutter('creating repository in %s.', a_bzrdir.transport.base)
 
292
        
293
293
        # FIXME: RBC 20060125 don't peek under the covers
294
294
        # NB: no need to escape relative paths that are url safe.
295
295
        control_files = lockable_files.LockableFiles(a_bzrdir.transport,
300
300
        try:
301
301
            transport.mkdir_multi(['revision-store', 'weaves'],
302
302
                mode=a_bzrdir._get_dir_mode())
303
 
            transport.put_bytes_non_atomic('inventory.weave', empty_weave,
304
 
                mode=a_bzrdir._get_file_mode())
 
303
            transport.put_bytes_non_atomic('inventory.weave', empty_weave)
305
304
        finally:
306
305
            control_files.unlock()
307
 
        repository = self.open(a_bzrdir, _found=True)
308
 
        self._run_post_repo_init_hooks(repository, a_bzrdir, shared)
309
 
        return repository
 
306
        return self.open(a_bzrdir, _found=True)
310
307
 
311
308
    def open(self, a_bzrdir, _found=False):
312
309
        """See RepositoryFormat.open()."""
321
318
        result.signatures = self._get_signatures(repo_transport, result)
322
319
        result.inventories = self._get_inventories(repo_transport, result)
323
320
        result.texts = self._get_texts(repo_transport, result)
324
 
        result.chk_bytes = None
325
321
        return result
326
322
 
 
323
    def check_conversion_target(self, target_format):
 
324
        pass
 
325
 
327
326
 
328
327
class RepositoryFormat4(PreSplitOutRepositoryFormat):
329
328
    """Bzr repository format 4.
339
338
 
340
339
    _matchingbzrdir = bzrdir.BzrDirFormat4()
341
340
 
 
341
    def __init__(self):
 
342
        super(RepositoryFormat4, self).__init__()
 
343
        self._fetch_order = 'topological'
 
344
        self._fetch_reconcile = True
 
345
 
342
346
    def get_format_description(self):
343
347
        """See RepositoryFormat.get_format_description()."""
344
348
        return "Repository format 4"
351
355
        """Format 4 is not supported.
352
356
 
353
357
        It is not supported because the model changed from 4 to 5 and the
354
 
        conversion logic is expensive - so doing it on the fly was not
 
358
        conversion logic is expensive - so doing it on the fly was not 
355
359
        feasible.
356
360
        """
357
361
        return False
386
390
 
387
391
    _versionedfile_class = weave.WeaveFile
388
392
    _matchingbzrdir = bzrdir.BzrDirFormat5()
389
 
    @property
390
 
    def _serializer(self):
391
 
        return xml5.serializer_v5
 
393
 
 
394
    def __init__(self):
 
395
        super(RepositoryFormat5, self).__init__()
 
396
        self._fetch_order = 'topological'
 
397
        self._fetch_reconcile = True
392
398
 
393
399
    def get_format_description(self):
394
400
        """See RepositoryFormat.get_format_description()."""
395
401
        return "Weave repository format 5"
396
 
 
 
402
    
397
403
    def network_name(self):
398
404
        """The network name for this format is the control dirs disk label."""
399
405
        return self._matchingbzrdir.get_format_string()
404
410
            weave.WeaveFile, mapper, repo.is_locked)
405
411
 
406
412
    def _get_revisions(self, repo_transport, repo):
 
413
        from bzrlib.xml5 import serializer_v5
407
414
        return RevisionTextStore(repo_transport.clone('revision-store'),
408
 
            xml5.serializer_v5, False, versionedfile.PrefixMapper(),
 
415
            serializer_v5, False, versionedfile.PrefixMapper(),
409
416
            repo.is_locked, repo.is_write_locked)
410
417
 
411
418
    def _get_signatures(self, repo_transport, repo):
431
438
 
432
439
    _versionedfile_class = weave.WeaveFile
433
440
    _matchingbzrdir = bzrdir.BzrDirFormat6()
434
 
    @property
435
 
    def _serializer(self):
436
 
        return xml5.serializer_v5
 
441
 
 
442
    def __init__(self):
 
443
        super(RepositoryFormat6, self).__init__()
 
444
        self._fetch_order = 'topological'
 
445
        self._fetch_reconcile = True
437
446
 
438
447
    def get_format_description(self):
439
448
        """See RepositoryFormat.get_format_description()."""
449
458
            weave.WeaveFile, mapper, repo.is_locked)
450
459
 
451
460
    def _get_revisions(self, repo_transport, repo):
 
461
        from bzrlib.xml5 import serializer_v5
452
462
        return RevisionTextStore(repo_transport.clone('revision-store'),
453
 
            xml5.serializer_v5, False, versionedfile.HashPrefixMapper(),
 
463
            serializer_v5, False, versionedfile.HashPrefixMapper(),
454
464
            repo.is_locked, repo.is_write_locked)
455
465
 
456
466
    def _get_signatures(self, repo_transport, repo):
479
489
 
480
490
    _versionedfile_class = weave.WeaveFile
481
491
    supports_ghosts = False
482
 
    supports_chks = False
483
 
 
484
 
    _fetch_order = 'topological'
485
 
    _fetch_reconcile = True
486
 
    fast_deltas = False
487
 
    @property
488
 
    def _serializer(self):
489
 
        return xml5.serializer_v5
490
492
 
491
493
    def get_format_string(self):
492
494
        """See RepositoryFormat.get_format_string()."""
496
498
        """See RepositoryFormat.get_format_description()."""
497
499
        return "Weave repository format 7"
498
500
 
 
501
    def check_conversion_target(self, target_format):
 
502
        pass
 
503
 
499
504
    def _get_inventories(self, repo_transport, repo, name='inventory'):
500
505
        mapper = versionedfile.ConstantMapper(name)
501
506
        return versionedfile.ThunkedVersionedFiles(repo_transport,
502
507
            weave.WeaveFile, mapper, repo.is_locked)
503
508
 
504
509
    def _get_revisions(self, repo_transport, repo):
 
510
        from bzrlib.xml5 import serializer_v5
505
511
        return RevisionTextStore(repo_transport.clone('revision-store'),
506
 
            xml5.serializer_v5, True, versionedfile.HashPrefixMapper(),
 
512
            serializer_v5, True, versionedfile.HashPrefixMapper(),
507
513
            repo.is_locked, repo.is_write_locked)
508
514
 
509
515
    def _get_signatures(self, repo_transport, repo):
528
534
        weavefile.write_weave_v5(weave.Weave(), sio)
529
535
        empty_weave = sio.getvalue()
530
536
 
531
 
        trace.mutter('creating repository in %s.', a_bzrdir.transport.base)
 
537
        mutter('creating repository in %s.', a_bzrdir.transport.base)
532
538
        dirs = ['revision-store', 'weaves']
533
 
        files = [('inventory.weave', StringIO(empty_weave)),
 
539
        files = [('inventory.weave', StringIO(empty_weave)), 
534
540
                 ]
535
541
        utf8_files = [('format', self.get_format_string())]
536
 
 
 
542
 
537
543
        self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
538
544
        return self.open(a_bzrdir=a_bzrdir, _found=True)
539
545
 
540
546
    def open(self, a_bzrdir, _found=False, _override_transport=None):
541
547
        """See RepositoryFormat.open().
542
 
 
 
548
        
543
549
        :param _override_transport: INTERNAL USE ONLY. Allows opening the
544
550
                                    repository at a slightly different url
545
551
                                    than normal. I.e. during 'upgrade'.
558
564
        result.signatures = self._get_signatures(repo_transport, result)
559
565
        result.inventories = self._get_inventories(repo_transport, result)
560
566
        result.texts = self._get_texts(repo_transport, result)
561
 
        result.chk_bytes = None
562
567
        result._transport = repo_transport
563
568
        return result
564
569
 
667
672
                continue
668
673
            result[key] = parents
669
674
        return result
670
 
 
671
 
    def get_known_graph_ancestry(self, keys):
672
 
        """Get a KnownGraph instance with the ancestry of keys."""
673
 
        keys = self.keys()
674
 
        parent_map = self.get_parent_map(keys)
675
 
        kg = _mod_graph.KnownGraph(parent_map)
676
 
        return kg
677
 
 
 
675
    
678
676
    def get_record_stream(self, keys, sort_order, include_delta_closure):
679
677
        for key in keys:
680
678
            text, parents = self._load_text_parents(key)
692
690
            path, ext = os.path.splitext(relpath)
693
691
            if ext == '.gz':
694
692
                relpath = path
695
 
            if not relpath.endswith('.sig'):
 
693
            if '.sig' not in relpath:
696
694
                relpaths.add(relpath)
697
695
        paths = list(relpaths)
698
696
        return set([self._mapper.unmap(path) for path in paths])
714
712
                continue
715
713
            result[key] = None
716
714
        return result
717
 
 
 
715
    
718
716
    def get_record_stream(self, keys, sort_order, include_delta_closure):
719
717
        for key in keys:
720
718
            text = self._load_text(key)