← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repofmt/weaverepo.py

(jameinel) Bug #581311,
 treat WSAECONNABORTED as ConnectionReset. (John A Meinel)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repofmt/weaverepo.py
27
27
 
28
28
from bzrlib.lazy_import import lazy_import
29
29
lazy_import(globals(), """
30
 
import itertools
31
 
 
32
30
from bzrlib import (
33
31
    xml5,
34
32
    graph as _mod_graph,
36
34
    )
37
35
""")
38
36
from bzrlib import (
 
37
    bzrdir,
39
38
    debug,
40
39
    errors,
41
40
    lockable_files,
42
41
    lockdir,
43
42
    osutils,
44
 
    symbol_versioning,
45
43
    trace,
46
44
    tuned_gzip,
47
45
    urlutils,
51
49
    )
52
50
from bzrlib.decorators import needs_read_lock, needs_write_lock
53
51
from bzrlib.repository import (
 
52
    CommitBuilder,
54
53
    InterRepository,
 
54
    InterSameDataRepository,
 
55
    MetaDirVersionedFileRepository,
 
56
    MetaDirRepositoryFormat,
 
57
    Repository,
55
58
    RepositoryFormat,
56
59
    )
57
60
from bzrlib.store.text import TextStore
60
63
    FulltextContentFactory,
61
64
    VersionedFiles,
62
65
    )
63
 
from bzrlib.vf_repository import (
64
 
    InterSameDataRepository,
65
 
    VersionedFileCommitBuilder,
66
 
    VersionedFileRepository,
67
 
    VersionedFileRepositoryFormat,
68
 
    MetaDirVersionedFileRepository,
69
 
    MetaDirVersionedFileRepositoryFormat,
70
 
    )
71
 
 
72
 
from bzrlib.plugins.weave_fmt import bzrdir as weave_bzrdir
73
 
 
74
 
 
75
 
class AllInOneRepository(VersionedFileRepository):
 
66
 
 
67
 
 
68
class AllInOneRepository(Repository):
76
69
    """Legacy support - the repository behaviour for all-in-one branches."""
77
70
 
78
71
    @property
150
143
 
151
144
    def get_commit_builder(self, branch, parents, config, timestamp=None,
152
145
                           timezone=None, committer=None, revprops=None,
153
 
                           revision_id=None, lossy=False):
 
146
                           revision_id=None):
154
147
        self._check_ascii_revisionid(revision_id, self.get_commit_builder)
155
 
        result = VersionedFileCommitBuilder(self, parents, config, timestamp,
156
 
            timezone, committer, revprops, revision_id, lossy=lossy)
 
148
        result = CommitBuilder(self, parents, config, timestamp, timezone,
 
149
                              committer, revprops, revision_id)
157
150
        self.start_write_group()
158
151
        return result
159
152
 
193
186
        """Returns the policy for making working trees on new branches."""
194
187
        return True
195
188
 
 
189
    def revision_graph_can_have_wrong_parents(self):
 
190
        # XXX: This is an old format that we don't support full checking on, so
 
191
        # just claim that checking for this inconsistency is not required.
 
192
        return False
 
193
 
196
194
 
197
195
class WeaveMetaDirRepository(MetaDirVersionedFileRepository):
198
196
    """A subclass of MetaDirRepository to set weave specific policy."""
239
237
 
240
238
    def get_commit_builder(self, branch, parents, config, timestamp=None,
241
239
                           timezone=None, committer=None, revprops=None,
242
 
                           revision_id=None, lossy=False):
 
240
                           revision_id=None):
243
241
        self._check_ascii_revisionid(revision_id, self.get_commit_builder)
244
 
        result = VersionedFileCommitBuilder(self, parents, config, timestamp,
245
 
            timezone, committer, revprops, revision_id, lossy=lossy)
 
242
        result = CommitBuilder(self, parents, config, timestamp, timezone,
 
243
                              committer, revprops, revision_id)
246
244
        self.start_write_group()
247
245
        return result
248
246
 
263
261
        return self.inventories.add_lines((revision_id,), final_parents, lines,
264
262
            check_content=check_content)[0]
265
263
 
266
 
 
267
 
class PreSplitOutRepositoryFormat(VersionedFileRepositoryFormat):
 
264
    def revision_graph_can_have_wrong_parents(self):
 
265
        return False
 
266
 
 
267
 
 
268
class PreSplitOutRepositoryFormat(RepositoryFormat):
268
269
    """Base class for the pre split out repository formats."""
269
270
 
270
271
    rich_root_data = False
275
276
    _fetch_order = 'topological'
276
277
    _fetch_reconcile = True
277
278
    fast_deltas = False
278
 
    supports_leaving_lock = False
279
 
    # XXX: This is an old format that we don't support full checking on, so
280
 
    # just claim that checking for this inconsistency is not required.
281
 
    revision_graph_can_have_wrong_parents = False
282
279
 
283
280
    def initialize(self, a_bzrdir, shared=False, _internal=False):
284
281
        """Create a weave repository."""
330
327
        result.chk_bytes = None
331
328
        return result
332
329
 
333
 
    def is_deprecated(self):
334
 
        return True
335
 
 
336
330
 
337
331
class RepositoryFormat4(PreSplitOutRepositoryFormat):
338
332
    """Bzr repository format 4.
346
340
    has been removed.
347
341
    """
348
342
 
349
 
    supports_funky_characters = False
350
 
 
351
 
    _matchingbzrdir = weave_bzrdir.BzrDirFormat4()
 
343
    _matchingbzrdir = bzrdir.BzrDirFormat4()
352
344
 
353
345
    def get_format_description(self):
354
346
        """See RepositoryFormat.get_format_description()."""
372
364
        return None
373
365
 
374
366
    def _get_revisions(self, repo_transport, repo):
375
 
        from bzrlib.plugins.weave_fmt.xml4 import serializer_v4
 
367
        from bzrlib.xml4 import serializer_v4
376
368
        return RevisionTextStore(repo_transport.clone('revision-store'),
377
369
            serializer_v4, True, versionedfile.PrefixMapper(),
378
370
            repo.is_locked, repo.is_write_locked)
396
388
    """
397
389
 
398
390
    _versionedfile_class = weave.WeaveFile
399
 
    _matchingbzrdir = weave_bzrdir.BzrDirFormat5()
400
 
    supports_funky_characters = False
401
 
 
 
391
    _matchingbzrdir = bzrdir.BzrDirFormat5()
402
392
    @property
403
393
    def _serializer(self):
404
394
        return xml5.serializer_v5
443
433
    """
444
434
 
445
435
    _versionedfile_class = weave.WeaveFile
446
 
    _matchingbzrdir = weave_bzrdir.BzrDirFormat6()
447
 
    supports_funky_characters = False
 
436
    _matchingbzrdir = bzrdir.BzrDirFormat6()
448
437
    @property
449
438
    def _serializer(self):
450
439
        return xml5.serializer_v5
479
468
            weave.WeaveFile, mapper, repo.is_locked)
480
469
 
481
470
 
482
 
class RepositoryFormat7(MetaDirVersionedFileRepositoryFormat):
 
471
class RepositoryFormat7(MetaDirRepositoryFormat):
483
472
    """Bzr repository 7.
484
473
 
485
474
    This repository format has:
494
483
    _versionedfile_class = weave.WeaveFile
495
484
    supports_ghosts = False
496
485
    supports_chks = False
497
 
    supports_funky_characters = False
498
 
    revision_graph_can_have_wrong_parents = False
499
486
 
500
487
    _fetch_order = 'topological'
501
488
    _fetch_reconcile = True
578
565
        result._transport = repo_transport
579
566
        return result
580
567
 
581
 
    def is_deprecated(self):
582
 
        return True
583
 
 
584
568
 
585
569
class TextVersionedFiles(VersionedFiles):
586
570
    """Just-a-bunch-of-files based VersionedFile stores."""
632
616
                    record, record.get_bytes_as(record.storage_kind)))
633
617
                try:
634
618
                    self.add_lines(record.key, None, lines)
635
 
                except errors.RevisionAlreadyPresent:
 
619
                except RevisionAlreadyPresent:
636
620
                    pass
637
621
 
638
622
    def _load_text(self, key):
817
801
            self.target.fetch(self.source, revision_id=revision_id)
818
802
 
819
803
    @needs_read_lock
820
 
    def search_missing_revision_ids(self,
821
 
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
822
 
            find_ghosts=True, revision_ids=None, if_present_ids=None,
823
 
            limit=None):
824
 
        """See InterRepository.search_missing_revision_ids()."""
 
804
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
 
805
        """See InterRepository.missing_revision_ids()."""
825
806
        # we want all revisions to satisfy revision_id in source.
826
807
        # but we don't want to stat every file here and there.
827
808
        # we want then, all revisions other needs to satisfy revision_id
833
814
        # disk format scales terribly for push anyway due to rewriting
834
815
        # inventory.weave, this is considered acceptable.
835
816
        # - RBC 20060209
836
 
        if symbol_versioning.deprecated_passed(revision_id):
837
 
            symbol_versioning.warn(
838
 
                'search_missing_revision_ids(revision_id=...) was '
839
 
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
840
 
                DeprecationWarning, stacklevel=2)
841
 
            if revision_ids is not None:
842
 
                raise AssertionError(
843
 
                    'revision_ids is mutually exclusive with revision_id')
844
 
            if revision_id is not None:
845
 
                revision_ids = [revision_id]
846
 
        del revision_id
847
 
        source_ids_set = self._present_source_revisions_for(
848
 
            revision_ids, if_present_ids)
 
817
        if revision_id is not None:
 
818
            source_ids = self.source.get_ancestry(revision_id)
 
819
            if source_ids[0] is not None:
 
820
                raise AssertionError()
 
821
            source_ids.pop(0)
 
822
        else:
 
823
            source_ids = self.source._all_possible_ids()
 
824
        source_ids_set = set(source_ids)
849
825
        # source_ids is the worst possible case we may need to pull.
850
826
        # now we want to filter source_ids against what we actually
851
827
        # have in target, but don't try to check for existence where we know
855
831
        actually_present_revisions = set(
856
832
            self.target._eliminate_revisions_not_present(possibly_present_revisions))
857
833
        required_revisions = source_ids_set.difference(actually_present_revisions)
858
 
        if revision_ids is not None:
 
834
        if revision_id is not None:
859
835
            # we used get_ancestry to determine source_ids then we are assured all
860
836
            # revisions referenced are present as they are installed in topological order.
861
837
            # and the tip revision was validated by get_ancestry.
866
842
            # that against the revision records.
867
843
            result_set = set(
868
844
                self.source._eliminate_revisions_not_present(required_revisions))
869
 
        if limit is not None:
870
 
            topo_ordered = self.get_graph().iter_topo_order(result_set)
871
 
            result_set = set(itertools.islice(topo_ordered, limit))
872
845
        return self.source.revision_ids_to_search_result(result_set)
873
846
 
874
847
 
 
848
_legacy_formats = [RepositoryFormat4(),
 
849
                   RepositoryFormat5(),
 
850
                   RepositoryFormat6()]
 
851
 
 
852
 
875
853
InterRepository.register_optimiser(InterWeaveRepo)
876
 
 
877
 
 
878
 
def get_extra_interrepo_test_combinations():
879
 
    from bzrlib.repofmt import knitrepo
880
 
    return [(InterRepository, RepositoryFormat5(),
881
 
        knitrepo.RepositoryFormatKnit3())]