~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repofmt/weaverepo.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-11-08 13:45:51 UTC
  • mfrom: (5532.1.1 trunk)
  • Revision ID: pqm@pqm.ubuntu.com-20101108134551-sxvk77ehmegkrwmm
(vila) Fix news entry

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2007-2011 Canonical Ltd
 
1
# Copyright (C) 2007-2010 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
24
23
import os
25
24
from cStringIO import StringIO
26
25
import urllib
30
29
from bzrlib import (
31
30
    xml5,
32
31
    graph as _mod_graph,
33
 
    ui,
34
32
    )
35
33
""")
36
34
from bzrlib import (
40
38
    lockable_files,
41
39
    lockdir,
42
40
    osutils,
43
 
    symbol_versioning,
 
41
    revision as _mod_revision,
44
42
    trace,
45
 
    tuned_gzip,
46
43
    urlutils,
47
44
    versionedfile,
48
45
    weave,
51
48
from bzrlib.decorators import needs_read_lock, needs_write_lock
52
49
from bzrlib.repository import (
53
50
    CommitBuilder,
54
 
    InterRepository,
55
 
    InterSameDataRepository,
56
51
    MetaDirVersionedFileRepository,
57
52
    MetaDirRepositoryFormat,
58
53
    Repository,
59
54
    RepositoryFormat,
60
55
    )
61
56
from bzrlib.store.text import TextStore
 
57
from bzrlib.tuned_gzip import GzipFile, bytes_to_gzip
62
58
from bzrlib.versionedfile import (
63
59
    AbsentContentFactory,
64
60
    FulltextContentFactory,
341
337
    has been removed.
342
338
    """
343
339
 
344
 
    supports_funky_characters = False
345
 
 
346
340
    _matchingbzrdir = bzrdir.BzrDirFormat4()
347
341
 
348
342
    def get_format_description(self):
392
386
 
393
387
    _versionedfile_class = weave.WeaveFile
394
388
    _matchingbzrdir = bzrdir.BzrDirFormat5()
395
 
    supports_funky_characters = False
396
 
 
397
389
    @property
398
390
    def _serializer(self):
399
391
        return xml5.serializer_v5
439
431
 
440
432
    _versionedfile_class = weave.WeaveFile
441
433
    _matchingbzrdir = bzrdir.BzrDirFormat6()
442
 
    supports_funky_characters = False
443
434
    @property
444
435
    def _serializer(self):
445
436
        return xml5.serializer_v5
489
480
    _versionedfile_class = weave.WeaveFile
490
481
    supports_ghosts = False
491
482
    supports_chks = False
492
 
    supports_funky_characters = False
493
483
 
494
484
    _fetch_order = 'topological'
495
485
    _fetch_reconcile = True
597
587
            raise ValueError('bad idea to put / in %r' % (key,))
598
588
        text = ''.join(lines)
599
589
        if self._compressed:
600
 
            text = tuned_gzip.bytes_to_gzip(text)
 
590
            text = bytes_to_gzip(text)
601
591
        path = self._map(key)
602
592
        self._transport.put_bytes_non_atomic(path, text, create_parent_dir=True)
603
593
 
645
635
            else:
646
636
                return None
647
637
        if compressed:
648
 
            text = gzip.GzipFile(mode='rb', fileobj=StringIO(text)).read()
 
638
            text = GzipFile(mode='rb', fileobj=StringIO(text)).read()
649
639
        return text
650
640
 
651
641
    def _map(self, key):
748
738
        paths = list(relpaths)
749
739
        return set([self._mapper.unmap(path) for path in paths])
750
740
 
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
 
 
862
 
InterRepository.register_optimiser(InterWeaveRepo)
 
741
_legacy_formats = [RepositoryFormat4(),
 
742
                   RepositoryFormat5(),
 
743
                   RepositoryFormat6()]