/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: Martin
  • Date: 2011-03-20 18:58:43 UTC
  • mto: This revision was merged to the branch mainline in revision 5731.
  • Revision ID: gzlist@googlemail.com-20110320185843-qn8g96slbc33yw9h
Non-code fixes noticed looking at full diff

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2007-2010 Canonical Ltd
 
1
# Copyright (C) 2007-2011 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
20
20
ghosts.
21
21
"""
22
22
 
 
23
import gzip
23
24
import os
24
25
from cStringIO import StringIO
25
26
import urllib
29
30
from bzrlib import (
30
31
    xml5,
31
32
    graph as _mod_graph,
 
33
    ui,
32
34
    )
33
35
""")
34
36
from bzrlib import (
38
40
    lockable_files,
39
41
    lockdir,
40
42
    osutils,
41
 
    revision as _mod_revision,
 
43
    symbol_versioning,
42
44
    trace,
 
45
    tuned_gzip,
43
46
    urlutils,
44
47
    versionedfile,
45
48
    weave,
48
51
from bzrlib.decorators import needs_read_lock, needs_write_lock
49
52
from bzrlib.repository import (
50
53
    CommitBuilder,
 
54
    InterRepository,
 
55
    InterSameDataRepository,
51
56
    MetaDirVersionedFileRepository,
52
57
    MetaDirRepositoryFormat,
53
58
    Repository,
54
59
    RepositoryFormat,
55
60
    )
56
61
from bzrlib.store.text import TextStore
57
 
from bzrlib.tuned_gzip import GzipFile, bytes_to_gzip
58
62
from bzrlib.versionedfile import (
59
63
    AbsentContentFactory,
60
64
    FulltextContentFactory,
273
277
    _fetch_order = 'topological'
274
278
    _fetch_reconcile = True
275
279
    fast_deltas = False
 
280
    supports_leaving_lock = False
276
281
 
277
282
    def initialize(self, a_bzrdir, shared=False, _internal=False):
278
283
        """Create a weave repository."""
324
329
        result.chk_bytes = None
325
330
        return result
326
331
 
 
332
    def is_deprecated(self):
 
333
        return True
 
334
 
327
335
 
328
336
class RepositoryFormat4(PreSplitOutRepositoryFormat):
329
337
    """Bzr repository format 4.
337
345
    has been removed.
338
346
    """
339
347
 
 
348
    supports_funky_characters = False
 
349
 
340
350
    _matchingbzrdir = bzrdir.BzrDirFormat4()
341
351
 
342
352
    def get_format_description(self):
386
396
 
387
397
    _versionedfile_class = weave.WeaveFile
388
398
    _matchingbzrdir = bzrdir.BzrDirFormat5()
 
399
    supports_funky_characters = False
 
400
 
389
401
    @property
390
402
    def _serializer(self):
391
403
        return xml5.serializer_v5
431
443
 
432
444
    _versionedfile_class = weave.WeaveFile
433
445
    _matchingbzrdir = bzrdir.BzrDirFormat6()
 
446
    supports_funky_characters = False
434
447
    @property
435
448
    def _serializer(self):
436
449
        return xml5.serializer_v5
480
493
    _versionedfile_class = weave.WeaveFile
481
494
    supports_ghosts = False
482
495
    supports_chks = False
 
496
    supports_funky_characters = False
483
497
 
484
498
    _fetch_order = 'topological'
485
499
    _fetch_reconcile = True
562
576
        result._transport = repo_transport
563
577
        return result
564
578
 
 
579
    def is_deprecated(self):
 
580
        return True
 
581
 
565
582
 
566
583
class TextVersionedFiles(VersionedFiles):
567
584
    """Just-a-bunch-of-files based VersionedFile stores."""
587
604
            raise ValueError('bad idea to put / in %r' % (key,))
588
605
        text = ''.join(lines)
589
606
        if self._compressed:
590
 
            text = bytes_to_gzip(text)
 
607
            text = tuned_gzip.bytes_to_gzip(text)
591
608
        path = self._map(key)
592
609
        self._transport.put_bytes_non_atomic(path, text, create_parent_dir=True)
593
610
 
635
652
            else:
636
653
                return None
637
654
        if compressed:
638
 
            text = GzipFile(mode='rb', fileobj=StringIO(text)).read()
 
655
            text = gzip.GzipFile(mode='rb', fileobj=StringIO(text)).read()
639
656
        return text
640
657
 
641
658
    def _map(self, key):
738
755
        paths = list(relpaths)
739
756
        return set([self._mapper.unmap(path) for path in paths])
740
757
 
741
 
_legacy_formats = [RepositoryFormat4(),
742
 
                   RepositoryFormat5(),
743
 
                   RepositoryFormat6()]
 
758
 
 
759
class InterWeaveRepo(InterSameDataRepository):
 
760
    """Optimised code paths between Weave based repositories.
 
761
    """
 
762
 
 
763
    @classmethod
 
764
    def _get_repo_format_to_test(self):
 
765
        return RepositoryFormat7()
 
766
 
 
767
    @staticmethod
 
768
    def is_compatible(source, target):
 
769
        """Be compatible with known Weave formats.
 
770
 
 
771
        We don't test for the stores being of specific types because that
 
772
        could lead to confusing results, and there is no need to be
 
773
        overly general.
 
774
        """
 
775
        try:
 
776
            return (isinstance(source._format, (RepositoryFormat5,
 
777
                                                RepositoryFormat6,
 
778
                                                RepositoryFormat7)) and
 
779
                    isinstance(target._format, (RepositoryFormat5,
 
780
                                                RepositoryFormat6,
 
781
                                                RepositoryFormat7)))
 
782
        except AttributeError:
 
783
            return False
 
784
 
 
785
    @needs_write_lock
 
786
    def copy_content(self, revision_id=None):
 
787
        """See InterRepository.copy_content()."""
 
788
        # weave specific optimised path:
 
789
        try:
 
790
            self.target.set_make_working_trees(self.source.make_working_trees())
 
791
        except (errors.RepositoryUpgradeRequired, NotImplemented):
 
792
            pass
 
793
        # FIXME do not peek!
 
794
        if self.source._transport.listable():
 
795
            pb = ui.ui_factory.nested_progress_bar()
 
796
            try:
 
797
                self.target.texts.insert_record_stream(
 
798
                    self.source.texts.get_record_stream(
 
799
                        self.source.texts.keys(), 'topological', False))
 
800
                pb.update('Copying inventory', 0, 1)
 
801
                self.target.inventories.insert_record_stream(
 
802
                    self.source.inventories.get_record_stream(
 
803
                        self.source.inventories.keys(), 'topological', False))
 
804
                self.target.signatures.insert_record_stream(
 
805
                    self.source.signatures.get_record_stream(
 
806
                        self.source.signatures.keys(),
 
807
                        'unordered', True))
 
808
                self.target.revisions.insert_record_stream(
 
809
                    self.source.revisions.get_record_stream(
 
810
                        self.source.revisions.keys(),
 
811
                        'topological', True))
 
812
            finally:
 
813
                pb.finished()
 
814
        else:
 
815
            self.target.fetch(self.source, revision_id=revision_id)
 
816
 
 
817
    @needs_read_lock
 
818
    def search_missing_revision_ids(self,
 
819
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
820
            find_ghosts=True, revision_ids=None, if_present_ids=None):
 
821
        """See InterRepository.search_missing_revision_ids()."""
 
822
        # we want all revisions to satisfy revision_id in source.
 
823
        # but we don't want to stat every file here and there.
 
824
        # we want then, all revisions other needs to satisfy revision_id
 
825
        # checked, but not those that we have locally.
 
826
        # so the first thing is to get a subset of the revisions to
 
827
        # satisfy revision_id in source, and then eliminate those that
 
828
        # we do already have.
 
829
        # this is slow on high latency connection to self, but as this
 
830
        # disk format scales terribly for push anyway due to rewriting
 
831
        # inventory.weave, this is considered acceptable.
 
832
        # - RBC 20060209
 
833
        if symbol_versioning.deprecated_passed(revision_id):
 
834
            symbol_versioning.warn(
 
835
                'search_missing_revision_ids(revision_id=...) was '
 
836
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
837
                DeprecationWarning, stacklevel=2)
 
838
            if revision_ids is not None:
 
839
                raise AssertionError(
 
840
                    'revision_ids is mutually exclusive with revision_id')
 
841
            if revision_id is not None:
 
842
                revision_ids = [revision_id]
 
843
        del revision_id
 
844
        source_ids_set = self._present_source_revisions_for(
 
845
            revision_ids, if_present_ids)
 
846
        # source_ids is the worst possible case we may need to pull.
 
847
        # now we want to filter source_ids against what we actually
 
848
        # have in target, but don't try to check for existence where we know
 
849
        # we do not have a revision as that would be pointless.
 
850
        target_ids = set(self.target._all_possible_ids())
 
851
        possibly_present_revisions = target_ids.intersection(source_ids_set)
 
852
        actually_present_revisions = set(
 
853
            self.target._eliminate_revisions_not_present(possibly_present_revisions))
 
854
        required_revisions = source_ids_set.difference(actually_present_revisions)
 
855
        if revision_ids is not None:
 
856
            # we used get_ancestry to determine source_ids then we are assured all
 
857
            # revisions referenced are present as they are installed in topological order.
 
858
            # and the tip revision was validated by get_ancestry.
 
859
            result_set = required_revisions
 
860
        else:
 
861
            # if we just grabbed the possibly available ids, then
 
862
            # we only have an estimate of whats available and need to validate
 
863
            # that against the revision records.
 
864
            result_set = set(
 
865
                self.source._eliminate_revisions_not_present(required_revisions))
 
866
        return self.source.revision_ids_to_search_result(result_set)
 
867
 
 
868
 
 
869
InterRepository.register_optimiser(InterWeaveRepo)
 
870
 
 
871
 
 
872
def get_extra_interrepo_test_combinations():
 
873
    from bzrlib.repofmt import knitrepo
 
874
    return [(InterRepository, RepositoryFormat5(),
 
875
        knitrepo.RepositoryFormatKnit3())]