/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: Vincent Ladeuil
  • Date: 2011-02-11 16:15:39 UTC
  • mto: This revision was merged to the branch mainline in revision 5661.
  • Revision ID: v.ladeuil+lp@free.fr-20110211161539-26o5a28ihyemvuzg
Fix pqm failure on python2.4.

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,
337
341
    has been removed.
338
342
    """
339
343
 
 
344
    supports_funky_characters = False
 
345
 
340
346
    _matchingbzrdir = bzrdir.BzrDirFormat4()
341
347
 
342
348
    def get_format_description(self):
386
392
 
387
393
    _versionedfile_class = weave.WeaveFile
388
394
    _matchingbzrdir = bzrdir.BzrDirFormat5()
 
395
    supports_funky_characters = False
 
396
 
389
397
    @property
390
398
    def _serializer(self):
391
399
        return xml5.serializer_v5
431
439
 
432
440
    _versionedfile_class = weave.WeaveFile
433
441
    _matchingbzrdir = bzrdir.BzrDirFormat6()
 
442
    supports_funky_characters = False
434
443
    @property
435
444
    def _serializer(self):
436
445
        return xml5.serializer_v5
480
489
    _versionedfile_class = weave.WeaveFile
481
490
    supports_ghosts = False
482
491
    supports_chks = False
 
492
    supports_funky_characters = False
483
493
 
484
494
    _fetch_order = 'topological'
485
495
    _fetch_reconcile = True
587
597
            raise ValueError('bad idea to put / in %r' % (key,))
588
598
        text = ''.join(lines)
589
599
        if self._compressed:
590
 
            text = bytes_to_gzip(text)
 
600
            text = tuned_gzip.bytes_to_gzip(text)
591
601
        path = self._map(key)
592
602
        self._transport.put_bytes_non_atomic(path, text, create_parent_dir=True)
593
603
 
635
645
            else:
636
646
                return None
637
647
        if compressed:
638
 
            text = GzipFile(mode='rb', fileobj=StringIO(text)).read()
 
648
            text = gzip.GzipFile(mode='rb', fileobj=StringIO(text)).read()
639
649
        return text
640
650
 
641
651
    def _map(self, key):
738
748
        paths = list(relpaths)
739
749
        return set([self._mapper.unmap(path) for path in paths])
740
750
 
 
751
 
 
752
class InterWeaveRepo(InterSameDataRepository):
 
753
    """Optimised code paths between Weave based repositories.
 
754
    """
 
755
 
 
756
    @classmethod
 
757
    def _get_repo_format_to_test(self):
 
758
        return RepositoryFormat7()
 
759
 
 
760
    @staticmethod
 
761
    def is_compatible(source, target):
 
762
        """Be compatible with known Weave formats.
 
763
 
 
764
        We don't test for the stores being of specific types because that
 
765
        could lead to confusing results, and there is no need to be
 
766
        overly general.
 
767
        """
 
768
        try:
 
769
            return (isinstance(source._format, (RepositoryFormat5,
 
770
                                                RepositoryFormat6,
 
771
                                                RepositoryFormat7)) and
 
772
                    isinstance(target._format, (RepositoryFormat5,
 
773
                                                RepositoryFormat6,
 
774
                                                RepositoryFormat7)))
 
775
        except AttributeError:
 
776
            return False
 
777
 
 
778
    @needs_write_lock
 
779
    def copy_content(self, revision_id=None):
 
780
        """See InterRepository.copy_content()."""
 
781
        # weave specific optimised path:
 
782
        try:
 
783
            self.target.set_make_working_trees(self.source.make_working_trees())
 
784
        except (errors.RepositoryUpgradeRequired, NotImplemented):
 
785
            pass
 
786
        # FIXME do not peek!
 
787
        if self.source._transport.listable():
 
788
            pb = ui.ui_factory.nested_progress_bar()
 
789
            try:
 
790
                self.target.texts.insert_record_stream(
 
791
                    self.source.texts.get_record_stream(
 
792
                        self.source.texts.keys(), 'topological', False))
 
793
                pb.update('Copying inventory', 0, 1)
 
794
                self.target.inventories.insert_record_stream(
 
795
                    self.source.inventories.get_record_stream(
 
796
                        self.source.inventories.keys(), 'topological', False))
 
797
                self.target.signatures.insert_record_stream(
 
798
                    self.source.signatures.get_record_stream(
 
799
                        self.source.signatures.keys(),
 
800
                        'unordered', True))
 
801
                self.target.revisions.insert_record_stream(
 
802
                    self.source.revisions.get_record_stream(
 
803
                        self.source.revisions.keys(),
 
804
                        'topological', True))
 
805
            finally:
 
806
                pb.finished()
 
807
        else:
 
808
            self.target.fetch(self.source, revision_id=revision_id)
 
809
 
 
810
    @needs_read_lock
 
811
    def search_missing_revision_ids(self,
 
812
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
813
            find_ghosts=True, revision_ids=None, if_present_ids=None):
 
814
        """See InterRepository.search_missing_revision_ids()."""
 
815
        # we want all revisions to satisfy revision_id in source.
 
816
        # but we don't want to stat every file here and there.
 
817
        # we want then, all revisions other needs to satisfy revision_id
 
818
        # checked, but not those that we have locally.
 
819
        # so the first thing is to get a subset of the revisions to
 
820
        # satisfy revision_id in source, and then eliminate those that
 
821
        # we do already have.
 
822
        # this is slow on high latency connection to self, but as this
 
823
        # disk format scales terribly for push anyway due to rewriting
 
824
        # inventory.weave, this is considered acceptable.
 
825
        # - RBC 20060209
 
826
        if symbol_versioning.deprecated_passed(revision_id):
 
827
            symbol_versioning.warn(
 
828
                'search_missing_revision_ids(revision_id=...) was '
 
829
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
830
                DeprecationWarning, stacklevel=2)
 
831
            if revision_ids is not None:
 
832
                raise AssertionError(
 
833
                    'revision_ids is mutually exclusive with revision_id')
 
834
            if revision_id is not None:
 
835
                revision_ids = [revision_id]
 
836
        del revision_id
 
837
        source_ids_set = self._present_source_revisions_for(
 
838
            revision_ids, if_present_ids)
 
839
        # source_ids is the worst possible case we may need to pull.
 
840
        # now we want to filter source_ids against what we actually
 
841
        # have in target, but don't try to check for existence where we know
 
842
        # we do not have a revision as that would be pointless.
 
843
        target_ids = set(self.target._all_possible_ids())
 
844
        possibly_present_revisions = target_ids.intersection(source_ids_set)
 
845
        actually_present_revisions = set(
 
846
            self.target._eliminate_revisions_not_present(possibly_present_revisions))
 
847
        required_revisions = source_ids_set.difference(actually_present_revisions)
 
848
        if revision_ids is not None:
 
849
            # we used get_ancestry to determine source_ids then we are assured all
 
850
            # revisions referenced are present as they are installed in topological order.
 
851
            # and the tip revision was validated by get_ancestry.
 
852
            result_set = required_revisions
 
853
        else:
 
854
            # if we just grabbed the possibly available ids, then
 
855
            # we only have an estimate of whats available and need to validate
 
856
            # that against the revision records.
 
857
            result_set = set(
 
858
                self.source._eliminate_revisions_not_present(required_revisions))
 
859
        return self.source.revision_ids_to_search_result(result_set)
 
860
 
 
861
 
741
862
_legacy_formats = [RepositoryFormat4(),
742
863
                   RepositoryFormat5(),
743
864
                   RepositoryFormat6()]
 
865
 
 
866
 
 
867
InterRepository.register_optimiser(InterWeaveRepo)