← Back to branch summary

~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: 2009-06-22 17:11:20 UTC
  • mfrom: (4398.8.10 1.16-commit-fulltext)
  • Revision ID: pqm@pqm.ubuntu.com-20090622171120-fuxez9ylfqpxynqn
(jam) Add VF._add_text and reduce memory overhead during commit (see
        bug #109114)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repofmt/weaverepo.py
1
 
# Copyright (C) 2007-2011 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
20
20
ghosts.
21
21
"""
22
22
 
23
 
import gzip
24
23
import os
25
24
from cStringIO import StringIO
26
25
import urllib
27
26
 
28
27
from bzrlib.lazy_import import lazy_import
29
28
lazy_import(globals(), """
30
 
import itertools
31
 
 
32
29
from bzrlib import (
33
30
    xml5,
34
 
    graph as _mod_graph,
35
 
    ui,
36
31
    )
37
32
""")
38
33
from bzrlib import (
 
34
    bzrdir,
39
35
    debug,
40
36
    errors,
41
37
    lockable_files,
42
38
    lockdir,
43
39
    osutils,
44
 
    symbol_versioning,
45
 
    trace,
46
 
    tuned_gzip,
 
40
    revision as _mod_revision,
47
41
    urlutils,
48
42
    versionedfile,
49
43
    weave,
51
45
    )
52
46
from bzrlib.decorators import needs_read_lock, needs_write_lock
53
47
from bzrlib.repository import (
54
 
    InterRepository,
 
48
    CommitBuilder,
 
49
    MetaDirVersionedFileRepository,
 
50
    MetaDirRepositoryFormat,
 
51
    Repository,
55
52
    RepositoryFormat,
56
53
    )
57
54
from bzrlib.store.text import TextStore
 
55
from bzrlib.trace import mutter
 
56
from bzrlib.tuned_gzip import GzipFile, bytes_to_gzip
58
57
from bzrlib.versionedfile import (
59
58
    AbsentContentFactory,
60
59
    FulltextContentFactory,
61
60
    VersionedFiles,
62
61
    )
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):
 
62
 
 
63
 
 
64
class AllInOneRepository(Repository):
76
65
    """Legacy support - the repository behaviour for all-in-one branches."""
77
66
 
78
67
    @property
116
105
    def _all_possible_ids(self):
117
106
        """Return all the possible revisions that we could find."""
118
107
        if 'evil' in debug.debug_flags:
119
 
            trace.mutter_callsite(
120
 
                3, "_all_possible_ids scales with size of history.")
 
108
            mutter_callsite(3, "_all_possible_ids scales with size of history.")
121
109
        return [key[-1] for key in self.inventories.keys()]
122
110
 
123
111
    @needs_read_lock
150
138
 
151
139
    def get_commit_builder(self, branch, parents, config, timestamp=None,
152
140
                           timezone=None, committer=None, revprops=None,
153
 
                           revision_id=None, lossy=False):
 
141
                           revision_id=None):
154
142
        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)
 
143
        result = CommitBuilder(self, parents, config, timestamp, timezone,
 
144
                              committer, revprops, revision_id)
157
145
        self.start_write_group()
158
146
        return result
159
147
 
187
175
        :param new_value: True to restore the default, False to disable making
188
176
                          working trees.
189
177
        """
190
 
        raise errors.RepositoryUpgradeRequired(self.user_url)
 
178
        raise errors.RepositoryUpgradeRequired(self.bzrdir.root_transport.base)
191
179
 
192
180
    def make_working_trees(self):
193
181
        """Returns the policy for making working trees on new branches."""
194
182
        return True
195
183
 
 
184
    def revision_graph_can_have_wrong_parents(self):
 
185
        # XXX: This is an old format that we don't support full checking on, so
 
186
        # just claim that checking for this inconsistency is not required.
 
187
        return False
 
188
 
196
189
 
197
190
class WeaveMetaDirRepository(MetaDirVersionedFileRepository):
198
191
    """A subclass of MetaDirRepository to set weave specific policy."""
205
198
    def _all_possible_ids(self):
206
199
        """Return all the possible revisions that we could find."""
207
200
        if 'evil' in debug.debug_flags:
208
 
            trace.mutter_callsite(
209
 
                3, "_all_possible_ids scales with size of history.")
 
201
            mutter_callsite(3, "_all_possible_ids scales with size of history.")
210
202
        return [key[-1] for key in self.inventories.keys()]
211
203
 
212
204
    @needs_read_lock
239
231
 
240
232
    def get_commit_builder(self, branch, parents, config, timestamp=None,
241
233
                           timezone=None, committer=None, revprops=None,
242
 
                           revision_id=None, lossy=False):
 
234
                           revision_id=None):
243
235
        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)
 
236
        result = CommitBuilder(self, parents, config, timestamp, timezone,
 
237
                              committer, revprops, revision_id)
246
238
        self.start_write_group()
247
239
        return result
248
240
 
263
255
        return self.inventories.add_lines((revision_id,), final_parents, lines,
264
256
            check_content=check_content)[0]
265
257
 
266
 
 
267
 
class PreSplitOutRepositoryFormat(VersionedFileRepositoryFormat):
 
258
    def revision_graph_can_have_wrong_parents(self):
 
259
        return False
 
260
 
 
261
 
 
262
class PreSplitOutRepositoryFormat(RepositoryFormat):
268
263
    """Base class for the pre split out repository formats."""
269
264
 
270
265
    rich_root_data = False
275
270
    _fetch_order = 'topological'
276
271
    _fetch_reconcile = True
277
272
    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
273
 
283
274
    def initialize(self, a_bzrdir, shared=False, _internal=False):
284
275
        """Create a weave repository."""
294
285
        weavefile.write_weave_v5(weave.Weave(), sio)
295
286
        empty_weave = sio.getvalue()
296
287
 
297
 
        trace.mutter('creating repository in %s.', a_bzrdir.transport.base)
 
288
        mutter('creating repository in %s.', a_bzrdir.transport.base)
298
289
 
299
290
        # FIXME: RBC 20060125 don't peek under the covers
300
291
        # NB: no need to escape relative paths that are url safe.
310
301
                mode=a_bzrdir._get_file_mode())
311
302
        finally:
312
303
            control_files.unlock()
313
 
        repository = self.open(a_bzrdir, _found=True)
314
 
        self._run_post_repo_init_hooks(repository, a_bzrdir, shared)
315
 
        return repository
 
304
        return self.open(a_bzrdir, _found=True)
316
305
 
317
306
    def open(self, a_bzrdir, _found=False):
318
307
        """See RepositoryFormat.open()."""
330
319
        result.chk_bytes = None
331
320
        return result
332
321
 
333
 
    def is_deprecated(self):
334
 
        return True
 
322
    def check_conversion_target(self, target_format):
 
323
        pass
335
324
 
336
325
 
337
326
class RepositoryFormat4(PreSplitOutRepositoryFormat):
346
335
    has been removed.
347
336
    """
348
337
 
349
 
    supports_funky_characters = False
350
 
 
351
 
    _matchingbzrdir = weave_bzrdir.BzrDirFormat4()
 
338
    _matchingbzrdir = bzrdir.BzrDirFormat4()
352
339
 
353
340
    def get_format_description(self):
354
341
        """See RepositoryFormat.get_format_description()."""
372
359
        return None
373
360
 
374
361
    def _get_revisions(self, repo_transport, repo):
375
 
        from bzrlib.plugins.weave_fmt.xml4 import serializer_v4
 
362
        from bzrlib.xml4 import serializer_v4
376
363
        return RevisionTextStore(repo_transport.clone('revision-store'),
377
364
            serializer_v4, True, versionedfile.PrefixMapper(),
378
365
            repo.is_locked, repo.is_write_locked)
396
383
    """
397
384
 
398
385
    _versionedfile_class = weave.WeaveFile
399
 
    _matchingbzrdir = weave_bzrdir.BzrDirFormat5()
400
 
    supports_funky_characters = False
401
 
 
 
386
    _matchingbzrdir = bzrdir.BzrDirFormat5()
402
387
    @property
403
388
    def _serializer(self):
404
389
        return xml5.serializer_v5
443
428
    """
444
429
 
445
430
    _versionedfile_class = weave.WeaveFile
446
 
    _matchingbzrdir = weave_bzrdir.BzrDirFormat6()
447
 
    supports_funky_characters = False
 
431
    _matchingbzrdir = bzrdir.BzrDirFormat6()
448
432
    @property
449
433
    def _serializer(self):
450
434
        return xml5.serializer_v5
479
463
            weave.WeaveFile, mapper, repo.is_locked)
480
464
 
481
465
 
482
 
class RepositoryFormat7(MetaDirVersionedFileRepositoryFormat):
 
466
class RepositoryFormat7(MetaDirRepositoryFormat):
483
467
    """Bzr repository 7.
484
468
 
485
469
    This repository format has:
494
478
    _versionedfile_class = weave.WeaveFile
495
479
    supports_ghosts = False
496
480
    supports_chks = False
497
 
    supports_funky_characters = False
498
 
    revision_graph_can_have_wrong_parents = False
499
481
 
500
482
    _fetch_order = 'topological'
501
483
    _fetch_reconcile = True
512
494
        """See RepositoryFormat.get_format_description()."""
513
495
        return "Weave repository format 7"
514
496
 
 
497
    def check_conversion_target(self, target_format):
 
498
        pass
 
499
 
515
500
    def _get_inventories(self, repo_transport, repo, name='inventory'):
516
501
        mapper = versionedfile.ConstantMapper(name)
517
502
        return versionedfile.ThunkedVersionedFiles(repo_transport,
544
529
        weavefile.write_weave_v5(weave.Weave(), sio)
545
530
        empty_weave = sio.getvalue()
546
531
 
547
 
        trace.mutter('creating repository in %s.', a_bzrdir.transport.base)
 
532
        mutter('creating repository in %s.', a_bzrdir.transport.base)
548
533
        dirs = ['revision-store', 'weaves']
549
534
        files = [('inventory.weave', StringIO(empty_weave)),
550
535
                 ]
578
563
        result._transport = repo_transport
579
564
        return result
580
565
 
581
 
    def is_deprecated(self):
582
 
        return True
583
 
 
584
566
 
585
567
class TextVersionedFiles(VersionedFiles):
586
568
    """Just-a-bunch-of-files based VersionedFile stores."""
606
588
            raise ValueError('bad idea to put / in %r' % (key,))
607
589
        text = ''.join(lines)
608
590
        if self._compressed:
609
 
            text = tuned_gzip.bytes_to_gzip(text)
 
591
            text = bytes_to_gzip(text)
610
592
        path = self._map(key)
611
593
        self._transport.put_bytes_non_atomic(path, text, create_parent_dir=True)
612
594
 
632
614
                    record, record.get_bytes_as(record.storage_kind)))
633
615
                try:
634
616
                    self.add_lines(record.key, None, lines)
635
 
                except errors.RevisionAlreadyPresent:
 
617
                except RevisionAlreadyPresent:
636
618
                    pass
637
619
 
638
620
    def _load_text(self, key):
654
636
            else:
655
637
                return None
656
638
        if compressed:
657
 
            text = gzip.GzipFile(mode='rb', fileobj=StringIO(text)).read()
 
639
            text = GzipFile(mode='rb', fileobj=StringIO(text)).read()
658
640
        return text
659
641
 
660
642
    def _map(self, key):
687
669
            result[key] = parents
688
670
        return result
689
671
 
690
 
    def get_known_graph_ancestry(self, keys):
691
 
        """Get a KnownGraph instance with the ancestry of keys."""
692
 
        keys = self.keys()
693
 
        parent_map = self.get_parent_map(keys)
694
 
        kg = _mod_graph.KnownGraph(parent_map)
695
 
        return kg
696
 
 
697
672
    def get_record_stream(self, keys, sort_order, include_delta_closure):
698
673
        for key in keys:
699
674
            text, parents = self._load_text_parents(key)
711
686
            path, ext = os.path.splitext(relpath)
712
687
            if ext == '.gz':
713
688
                relpath = path
714
 
            if not relpath.endswith('.sig'):
 
689
            if '.sig' not in relpath:
715
690
                relpaths.add(relpath)
716
691
        paths = list(relpaths)
717
692
        return set([self._mapper.unmap(path) for path in paths])
757
732
        paths = list(relpaths)
758
733
        return set([self._mapper.unmap(path) for path in paths])
759
734
 
760
 
 
761
 
class InterWeaveRepo(InterSameDataRepository):
762
 
    """Optimised code paths between Weave based repositories.
763
 
    """
764
 
 
765
 
    @classmethod
766
 
    def _get_repo_format_to_test(self):
767
 
        return RepositoryFormat7()
768
 
 
769
 
    @staticmethod
770
 
    def is_compatible(source, target):
771
 
        """Be compatible with known Weave formats.
772
 
 
773
 
        We don't test for the stores being of specific types because that
774
 
        could lead to confusing results, and there is no need to be
775
 
        overly general.
776
 
        """
777
 
        try:
778
 
            return (isinstance(source._format, (RepositoryFormat5,
779
 
                                                RepositoryFormat6,
780
 
                                                RepositoryFormat7)) and
781
 
                    isinstance(target._format, (RepositoryFormat5,
782
 
                                                RepositoryFormat6,
783
 
                                                RepositoryFormat7)))
784
 
        except AttributeError:
785
 
            return False
786
 
 
787
 
    @needs_write_lock
788
 
    def copy_content(self, revision_id=None):
789
 
        """See InterRepository.copy_content()."""
790
 
        # weave specific optimised path:
791
 
        try:
792
 
            self.target.set_make_working_trees(self.source.make_working_trees())
793
 
        except (errors.RepositoryUpgradeRequired, NotImplemented):
794
 
            pass
795
 
        # FIXME do not peek!
796
 
        if self.source._transport.listable():
797
 
            pb = ui.ui_factory.nested_progress_bar()
798
 
            try:
799
 
                self.target.texts.insert_record_stream(
800
 
                    self.source.texts.get_record_stream(
801
 
                        self.source.texts.keys(), 'topological', False))
802
 
                pb.update('Copying inventory', 0, 1)
803
 
                self.target.inventories.insert_record_stream(
804
 
                    self.source.inventories.get_record_stream(
805
 
                        self.source.inventories.keys(), 'topological', False))
806
 
                self.target.signatures.insert_record_stream(
807
 
                    self.source.signatures.get_record_stream(
808
 
                        self.source.signatures.keys(),
809
 
                        'unordered', True))
810
 
                self.target.revisions.insert_record_stream(
811
 
                    self.source.revisions.get_record_stream(
812
 
                        self.source.revisions.keys(),
813
 
                        'topological', True))
814
 
            finally:
815
 
                pb.finished()
816
 
        else:
817
 
            self.target.fetch(self.source, revision_id=revision_id)
818
 
 
819
 
    @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()."""
825
 
        # we want all revisions to satisfy revision_id in source.
826
 
        # but we don't want to stat every file here and there.
827
 
        # we want then, all revisions other needs to satisfy revision_id
828
 
        # checked, but not those that we have locally.
829
 
        # so the first thing is to get a subset of the revisions to
830
 
        # satisfy revision_id in source, and then eliminate those that
831
 
        # we do already have.
832
 
        # this is slow on high latency connection to self, but as this
833
 
        # disk format scales terribly for push anyway due to rewriting
834
 
        # inventory.weave, this is considered acceptable.
835
 
        # - 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)
849
 
        # source_ids is the worst possible case we may need to pull.
850
 
        # now we want to filter source_ids against what we actually
851
 
        # have in target, but don't try to check for existence where we know
852
 
        # we do not have a revision as that would be pointless.
853
 
        target_ids = set(self.target._all_possible_ids())
854
 
        possibly_present_revisions = target_ids.intersection(source_ids_set)
855
 
        actually_present_revisions = set(
856
 
            self.target._eliminate_revisions_not_present(possibly_present_revisions))
857
 
        required_revisions = source_ids_set.difference(actually_present_revisions)
858
 
        if revision_ids is not None:
859
 
            # we used get_ancestry to determine source_ids then we are assured all
860
 
            # revisions referenced are present as they are installed in topological order.
861
 
            # and the tip revision was validated by get_ancestry.
862
 
            result_set = required_revisions
863
 
        else:
864
 
            # if we just grabbed the possibly available ids, then
865
 
            # we only have an estimate of whats available and need to validate
866
 
            # that against the revision records.
867
 
            result_set = set(
868
 
                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
 
        return self.source.revision_ids_to_search_result(result_set)
873
 
 
874
 
 
875
 
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())]
 
735
_legacy_formats = [RepositoryFormat4(),
 
736
                   RepositoryFormat5(),
 
737
                   RepositoryFormat6()]