/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/repository.py

  • Committer: John Arbash Meinel
  • Date: 2011-01-10 22:20:12 UTC
  • mfrom: (5582 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5599.
  • Revision ID: john@arbash-meinel.com-20110110222012-mtcqudkvmzwiufuc
Merge in the bzr.dev 5582

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repository.py
25
25
    check,
26
26
    chk_map,
27
27
    config,
 
28
    controldir,
28
29
    debug,
29
 
    errors,
30
30
    fetch as _mod_fetch,
31
31
    fifo_cache,
32
32
    generate_ids,
39
39
    lockdir,
40
40
    lru_cache,
41
41
    osutils,
 
42
    pyutils,
42
43
    revision as _mod_revision,
43
44
    static_tuple,
44
45
    symbol_versioning,
45
46
    trace,
46
47
    tsort,
47
 
    ui,
48
48
    versionedfile,
49
49
    )
50
50
from bzrlib.bundle import serializer
53
53
from bzrlib.testament import Testament
54
54
""")
55
55
 
 
56
import sys
 
57
from bzrlib import (
 
58
    errors,
 
59
    registry,
 
60
    ui,
 
61
    )
56
62
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
57
63
from bzrlib.inter import InterObject
58
64
from bzrlib.inventory import (
61
67
    ROOT_ID,
62
68
    entry_factory,
63
69
    )
64
 
from bzrlib.lock import _RelockDebugMixin
65
 
from bzrlib import registry
 
70
from bzrlib.recordcounter import RecordCounter
 
71
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
66
72
from bzrlib.trace import (
67
73
    log_exception_quietly, note, mutter, mutter_callsite, warning)
68
74
 
71
77
_deprecation_warning_done = False
72
78
 
73
79
 
 
80
class IsInWriteGroupError(errors.InternalBzrError):
 
81
 
 
82
    _fmt = "May not refresh_data of repo %(repo)s while in a write group."
 
83
 
 
84
    def __init__(self, repo):
 
85
        errors.InternalBzrError.__init__(self, repo=repo)
 
86
 
 
87
 
74
88
class CommitBuilder(object):
75
89
    """Provides an interface to build up a commit.
76
90
 
101
115
 
102
116
        if committer is None:
103
117
            self._committer = self._config.username()
 
118
        elif not isinstance(committer, unicode):
 
119
            self._committer = committer.decode() # throw if non-ascii
104
120
        else:
105
121
            self._committer = committer
106
122
 
160
176
            self._validate_unicode_text(value,
161
177
                                        'revision property (%s)' % (key,))
162
178
 
 
179
    def _ensure_fallback_inventories(self):
 
180
        """Ensure that appropriate inventories are available.
 
181
 
 
182
        This only applies to repositories that are stacked, and is about
 
183
        enusring the stacking invariants. Namely, that for any revision that is
 
184
        present, we either have all of the file content, or we have the parent
 
185
        inventory and the delta file content.
 
186
        """
 
187
        if not self.repository._fallback_repositories:
 
188
            return
 
189
        # This is a stacked repo, we need to make sure we have the parent
 
190
        # inventories for the parents.
 
191
        parent_keys = [(p,) for p in self.parents]
 
192
        parent_map = self.repository.inventories._index.get_parent_map(parent_keys)
 
193
        missing_parent_keys = set([pk for pk in parent_keys
 
194
                                       if pk not in parent_map])
 
195
        fallback_repos = list(reversed(self.repository._fallback_repositories))
 
196
        # Right now, we are already in a write group, and insert_stream needs
 
197
        # its own write group. Ideally we would just share it, but the current
 
198
        # mechanism is suspend+resume.
 
199
        # However, we don't want to immediately resume the write group,
 
200
        # because, insert_stream finalizes the commit.
 
201
        saved_resume_tokens = self.repository.suspend_write_group()
 
202
 
 
203
        missing_keys = [('inventories', pk[0])
 
204
                        for pk in missing_parent_keys]
 
205
        resume_tokens = []
 
206
        while missing_keys and fallback_repos:
 
207
            fallback_repo = fallback_repos.pop()
 
208
            source = fallback_repo._get_source(self.repository._format)
 
209
            sink = self.repository._get_sink()
 
210
            stream = source.get_stream_for_missing_keys(missing_keys)
 
211
            resume_tokens, missing_keys = sink.insert_stream(
 
212
                stream, self.repository._format, resume_tokens)
 
213
        if resume_tokens or missing_keys:
 
214
            raise RuntimeError('failure will robinson')
 
215
        self.repository.resume_write_group(saved_resume_tokens)
 
216
 
163
217
    def commit(self, message):
164
218
        """Make the actual commit.
165
219
 
166
220
        :return: The revision id of the recorded revision.
167
221
        """
 
222
        self._ensure_fallback_inventories()
168
223
        self._validate_unicode_text(message, 'commit message')
169
224
        rev = _mod_revision.Revision(
170
225
                       timestamp=self._timestamp,
231
286
 
232
287
    def _gen_revision_id(self):
233
288
        """Return new revision-id."""
234
 
        return generate_ids.gen_revision_id(self._config.username(),
235
 
                                            self._timestamp)
 
289
        return generate_ids.gen_revision_id(self._committer, self._timestamp)
236
290
 
237
291
    def _generate_revision_if_needed(self):
238
292
        """Create a revision id if None was supplied.
278
332
 
279
333
        :param tree: The tree which is being committed.
280
334
        """
281
 
        # NB: if there are no parents then this method is not called, so no
282
 
        # need to guard on parents having length.
 
335
        if len(self.parents) == 0:
 
336
            raise errors.RootMissing()
283
337
        entry = entry_factory['directory'](tree.path2id(''), '',
284
338
            None)
285
339
        entry.revision = self._new_revision_id
423
477
            else:
424
478
                # we don't need to commit this, because the caller already
425
479
                # determined that an existing revision of this file is
426
 
                # appropriate. If its not being considered for committing then
 
480
                # appropriate. If it's not being considered for committing then
427
481
                # it and all its parents to the root must be unaltered so
428
482
                # no-change against the basis.
429
483
                if ie.revision == self._new_revision_id:
745
799
                    # after iter_changes examines and decides it has changed,
746
800
                    # we will unconditionally record a new version even if some
747
801
                    # other process reverts it while commit is running (with
748
 
                    # the revert happening after iter_changes did it's
 
802
                    # the revert happening after iter_changes did its
749
803
                    # examination).
750
804
                    if change[7][1]:
751
805
                        entry.executable = True
860
914
        # versioned roots do not change unless the tree found a change.
861
915
 
862
916
 
 
917
class RepositoryWriteLockResult(LogicalLockResult):
 
918
    """The result of write locking a repository.
 
919
 
 
920
    :ivar repository_token: The token obtained from the underlying lock, or
 
921
        None.
 
922
    :ivar unlock: A callable which will unlock the lock.
 
923
    """
 
924
 
 
925
    def __init__(self, unlock, repository_token):
 
926
        LogicalLockResult.__init__(self, unlock)
 
927
        self.repository_token = repository_token
 
928
 
 
929
    def __repr__(self):
 
930
        return "RepositoryWriteLockResult(%s, %s)" % (self.repository_token,
 
931
            self.unlock)
 
932
 
 
933
 
863
934
######################################################################
864
935
# Repositories
865
936
 
866
937
 
867
 
class Repository(_RelockDebugMixin, bzrdir.ControlComponent):
 
938
class Repository(_RelockDebugMixin, controldir.ControlComponent):
868
939
    """Repository holding history for one or more branches.
869
940
 
870
941
    The repository holds and retrieves historical information including
917
988
        pointing to .bzr/repository.
918
989
    """
919
990
 
920
 
    # What class to use for a CommitBuilder. Often its simpler to change this
 
991
    # What class to use for a CommitBuilder. Often it's simpler to change this
921
992
    # in a Repository class subclass rather than to override
922
993
    # get_commit_builder.
923
994
    _commit_builder_class = CommitBuilder
1018
1089
                " id and insertion revid (%r, %r)"
1019
1090
                % (inv.revision_id, revision_id))
1020
1091
        if inv.root is None:
1021
 
            raise AssertionError()
 
1092
            raise errors.RootMissing()
1022
1093
        return self._add_inventory_checked(revision_id, inv, parents)
1023
1094
 
1024
1095
    def _add_inventory_checked(self, revision_id, inv, parents):
1376
1447
        data during reads, and allows a 'write_group' to be obtained. Write
1377
1448
        groups must be used for actual data insertion.
1378
1449
 
 
1450
        A token should be passed in if you know that you have locked the object
 
1451
        some other way, and need to synchronise this object's state with that
 
1452
        fact.
 
1453
 
 
1454
        XXX: this docstring is duplicated in many places, e.g. lockable_files.py
 
1455
 
1379
1456
        :param token: if this is already locked, then lock_write will fail
1380
1457
            unless the token matches the existing lock.
1381
1458
        :returns: a token if this instance supports tokens, otherwise None.
1384
1461
        :raises MismatchedToken: if the specified token doesn't match the token
1385
1462
            of the existing lock.
1386
1463
        :seealso: start_write_group.
1387
 
 
1388
 
        A token should be passed in if you know that you have locked the object
1389
 
        some other way, and need to synchronise this object's state with that
1390
 
        fact.
1391
 
 
1392
 
        XXX: this docstring is duplicated in many places, e.g. lockable_files.py
 
1464
        :return: A RepositoryWriteLockResult.
1393
1465
        """
1394
1466
        locked = self.is_locked()
1395
 
        result = self.control_files.lock_write(token=token)
 
1467
        token = self.control_files.lock_write(token=token)
1396
1468
        if not locked:
1397
1469
            self._warn_if_deprecated()
1398
1470
            self._note_lock('w')
1400
1472
                # Writes don't affect fallback repos
1401
1473
                repo.lock_read()
1402
1474
            self._refresh_data()
1403
 
        return result
 
1475
        return RepositoryWriteLockResult(self.unlock, token)
1404
1476
 
1405
1477
    def lock_read(self):
 
1478
        """Lock the repository for read operations.
 
1479
 
 
1480
        :return: An object with an unlock method which will release the lock
 
1481
            obtained.
 
1482
        """
1406
1483
        locked = self.is_locked()
1407
1484
        self.control_files.lock_read()
1408
1485
        if not locked:
1411
1488
            for repo in self._fallback_repositories:
1412
1489
                repo.lock_read()
1413
1490
            self._refresh_data()
 
1491
        return LogicalLockResult(self.unlock)
1414
1492
 
1415
1493
    def get_physical_lock_status(self):
1416
1494
        return self.control_files.get_physical_lock_status()
1634
1712
        return missing_keys
1635
1713
 
1636
1714
    def refresh_data(self):
1637
 
        """Re-read any data needed to to synchronise with disk.
 
1715
        """Re-read any data needed to synchronise with disk.
1638
1716
 
1639
1717
        This method is intended to be called after another repository instance
1640
1718
        (such as one used by a smart server) has inserted data into the
1641
 
        repository. It may not be called during a write group, but may be
1642
 
        called at any other time.
 
1719
        repository. On all repositories this will work outside of write groups.
 
1720
        Some repository formats (pack and newer for bzrlib native formats)
 
1721
        support refresh_data inside write groups. If called inside a write
 
1722
        group on a repository that does not support refreshing in a write group
 
1723
        IsInWriteGroupError will be raised.
1643
1724
        """
1644
 
        if self.is_in_write_group():
1645
 
            raise errors.InternalBzrError(
1646
 
                "May not refresh_data while in a write group.")
1647
1725
        self._refresh_data()
1648
1726
 
1649
1727
    def resume_write_group(self, tokens):
1688
1766
                "May not fetch while in a write group.")
1689
1767
        # fast path same-url fetch operations
1690
1768
        # TODO: lift out to somewhere common with RemoteRepository
1691
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401646>
 
1769
        # <https://bugs.launchpad.net/bzr/+bug/401646>
1692
1770
        if (self.has_same_location(source)
1693
1771
            and fetch_spec is None
1694
1772
            and self._has_same_fallbacks(source)):
1722
1800
        :param revprops: Optional dictionary of revision properties.
1723
1801
        :param revision_id: Optional revision id.
1724
1802
        """
1725
 
        if self._fallback_repositories:
1726
 
            raise errors.BzrError("Cannot commit from a lightweight checkout "
1727
 
                "to a stacked branch. See "
1728
 
                "https://bugs.launchpad.net/bzr/+bug/375013 for details.")
1729
1803
        result = self._commit_builder_class(self, parents, config,
1730
1804
            timestamp, timezone, committer, revprops, revision_id)
1731
1805
        self.start_write_group()
2476
2550
            ancestors will be traversed.
2477
2551
        """
2478
2552
        graph = self.get_graph()
2479
 
        next_id = revision_id
2480
 
        while True:
2481
 
            if next_id in (None, _mod_revision.NULL_REVISION):
2482
 
                return
2483
 
            try:
2484
 
                parents = graph.get_parent_map([next_id])[next_id]
2485
 
            except KeyError:
2486
 
                raise errors.RevisionNotPresent(next_id, self)
2487
 
            yield next_id
2488
 
            if len(parents) == 0:
2489
 
                return
2490
 
            else:
2491
 
                next_id = parents[0]
 
2553
        stop_revisions = (None, _mod_revision.NULL_REVISION)
 
2554
        return graph.iter_lefthand_ancestry(revision_id, stop_revisions)
2492
2555
 
2493
2556
    def is_shared(self):
2494
2557
        """Return True if this repository is flagged as a shared repository."""
2595
2658
        types it should be a no-op that just returns.
2596
2659
 
2597
2660
        This stub method does not require a lock, but subclasses should use
2598
 
        @needs_write_lock as this is a long running call its reasonable to
 
2661
        @needs_write_lock as this is a long running call it's reasonable to
2599
2662
        implicitly lock for the user.
2600
2663
 
2601
2664
        :param hint: If not supplied, the whole repository is packed.
2801
2864
            % (name, from_module),
2802
2865
            DeprecationWarning,
2803
2866
            stacklevel=2)
2804
 
        m = __import__(from_module, globals(), locals(), [name])
2805
2867
        try:
2806
 
            return getattr(m, name)
 
2868
            return pyutils.get_named_object(from_module, name)
2807
2869
        except AttributeError:
2808
2870
            raise AttributeError('module %s has no name %s'
2809
 
                    % (m, name))
 
2871
                    % (sys.modules[from_module], name))
2810
2872
    globals()[name] = _deprecated_repository_forwarder
2811
2873
 
2812
2874
for _name in [
3325
3387
    'bzrlib.repofmt.pack_repo',
3326
3388
    'RepositoryFormatKnitPack6RichRoot',
3327
3389
    )
 
3390
format_registry.register_lazy(
 
3391
    'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
 
3392
    'bzrlib.repofmt.groupcompress_repo',
 
3393
    'RepositoryFormat2a',
 
3394
    )
3328
3395
 
3329
3396
# Development formats.
3330
 
# Obsolete but kept pending a CHK based subtree format.
 
3397
# Check their docstrings to see if/when they are obsolete.
3331
3398
format_registry.register_lazy(
3332
3399
    ("Bazaar development format 2 with subtree support "
3333
3400
        "(needs bzr.dev from before 1.8)\n"),
3334
3401
    'bzrlib.repofmt.pack_repo',
3335
3402
    'RepositoryFormatPackDevelopment2Subtree',
3336
3403
    )
3337
 
 
3338
 
# 1.14->1.16 go below here
3339
 
format_registry.register_lazy(
3340
 
    'Bazaar development format - group compression and chk inventory'
3341
 
        ' (needs bzr.dev from 1.14)\n',
3342
 
    'bzrlib.repofmt.groupcompress_repo',
3343
 
    'RepositoryFormatCHK1',
3344
 
    )
3345
 
 
3346
 
format_registry.register_lazy(
3347
 
    'Bazaar development format - chk repository with bencode revision '
3348
 
        'serialization (needs bzr.dev from 1.16)\n',
3349
 
    'bzrlib.repofmt.groupcompress_repo',
3350
 
    'RepositoryFormatCHK2',
3351
 
    )
3352
 
format_registry.register_lazy(
3353
 
    'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
3354
 
    'bzrlib.repofmt.groupcompress_repo',
3355
 
    'RepositoryFormat2a',
 
3404
format_registry.register_lazy(
 
3405
    'Bazaar development format 8\n',
 
3406
    'bzrlib.repofmt.groupcompress_repo',
 
3407
    'RepositoryFormat2aSubtree',
3356
3408
    )
3357
3409
 
3358
3410
 
3536
3588
        return InterRepository._same_model(source, target)
3537
3589
 
3538
3590
 
3539
 
class InterWeaveRepo(InterSameDataRepository):
3540
 
    """Optimised code paths between Weave based repositories.
3541
 
 
3542
 
    This should be in bzrlib/repofmt/weaverepo.py but we have not yet
3543
 
    implemented lazy inter-object optimisation.
3544
 
    """
3545
 
 
3546
 
    @classmethod
3547
 
    def _get_repo_format_to_test(self):
3548
 
        from bzrlib.repofmt import weaverepo
3549
 
        return weaverepo.RepositoryFormat7()
3550
 
 
3551
 
    @staticmethod
3552
 
    def is_compatible(source, target):
3553
 
        """Be compatible with known Weave formats.
3554
 
 
3555
 
        We don't test for the stores being of specific types because that
3556
 
        could lead to confusing results, and there is no need to be
3557
 
        overly general.
3558
 
        """
3559
 
        from bzrlib.repofmt.weaverepo import (
3560
 
                RepositoryFormat5,
3561
 
                RepositoryFormat6,
3562
 
                RepositoryFormat7,
3563
 
                )
3564
 
        try:
3565
 
            return (isinstance(source._format, (RepositoryFormat5,
3566
 
                                                RepositoryFormat6,
3567
 
                                                RepositoryFormat7)) and
3568
 
                    isinstance(target._format, (RepositoryFormat5,
3569
 
                                                RepositoryFormat6,
3570
 
                                                RepositoryFormat7)))
3571
 
        except AttributeError:
3572
 
            return False
3573
 
 
3574
 
    @needs_write_lock
3575
 
    def copy_content(self, revision_id=None):
3576
 
        """See InterRepository.copy_content()."""
3577
 
        # weave specific optimised path:
3578
 
        try:
3579
 
            self.target.set_make_working_trees(self.source.make_working_trees())
3580
 
        except (errors.RepositoryUpgradeRequired, NotImplemented):
3581
 
            pass
3582
 
        # FIXME do not peek!
3583
 
        if self.source._transport.listable():
3584
 
            pb = ui.ui_factory.nested_progress_bar()
3585
 
            try:
3586
 
                self.target.texts.insert_record_stream(
3587
 
                    self.source.texts.get_record_stream(
3588
 
                        self.source.texts.keys(), 'topological', False))
3589
 
                pb.update('Copying inventory', 0, 1)
3590
 
                self.target.inventories.insert_record_stream(
3591
 
                    self.source.inventories.get_record_stream(
3592
 
                        self.source.inventories.keys(), 'topological', False))
3593
 
                self.target.signatures.insert_record_stream(
3594
 
                    self.source.signatures.get_record_stream(
3595
 
                        self.source.signatures.keys(),
3596
 
                        'unordered', True))
3597
 
                self.target.revisions.insert_record_stream(
3598
 
                    self.source.revisions.get_record_stream(
3599
 
                        self.source.revisions.keys(),
3600
 
                        'topological', True))
3601
 
            finally:
3602
 
                pb.finished()
3603
 
        else:
3604
 
            self.target.fetch(self.source, revision_id=revision_id)
3605
 
 
3606
 
    @needs_read_lock
3607
 
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
3608
 
        """See InterRepository.missing_revision_ids()."""
3609
 
        # we want all revisions to satisfy revision_id in source.
3610
 
        # but we don't want to stat every file here and there.
3611
 
        # we want then, all revisions other needs to satisfy revision_id
3612
 
        # checked, but not those that we have locally.
3613
 
        # so the first thing is to get a subset of the revisions to
3614
 
        # satisfy revision_id in source, and then eliminate those that
3615
 
        # we do already have.
3616
 
        # this is slow on high latency connection to self, but as this
3617
 
        # disk format scales terribly for push anyway due to rewriting
3618
 
        # inventory.weave, this is considered acceptable.
3619
 
        # - RBC 20060209
3620
 
        if revision_id is not None:
3621
 
            source_ids = self.source.get_ancestry(revision_id)
3622
 
            if source_ids[0] is not None:
3623
 
                raise AssertionError()
3624
 
            source_ids.pop(0)
3625
 
        else:
3626
 
            source_ids = self.source._all_possible_ids()
3627
 
        source_ids_set = set(source_ids)
3628
 
        # source_ids is the worst possible case we may need to pull.
3629
 
        # now we want to filter source_ids against what we actually
3630
 
        # have in target, but don't try to check for existence where we know
3631
 
        # we do not have a revision as that would be pointless.
3632
 
        target_ids = set(self.target._all_possible_ids())
3633
 
        possibly_present_revisions = target_ids.intersection(source_ids_set)
3634
 
        actually_present_revisions = set(
3635
 
            self.target._eliminate_revisions_not_present(possibly_present_revisions))
3636
 
        required_revisions = source_ids_set.difference(actually_present_revisions)
3637
 
        if revision_id is not None:
3638
 
            # we used get_ancestry to determine source_ids then we are assured all
3639
 
            # revisions referenced are present as they are installed in topological order.
3640
 
            # and the tip revision was validated by get_ancestry.
3641
 
            result_set = required_revisions
3642
 
        else:
3643
 
            # if we just grabbed the possibly available ids, then
3644
 
            # we only have an estimate of whats available and need to validate
3645
 
            # that against the revision records.
3646
 
            result_set = set(
3647
 
                self.source._eliminate_revisions_not_present(required_revisions))
3648
 
        return self.source.revision_ids_to_search_result(result_set)
3649
 
 
3650
 
 
3651
 
class InterKnitRepo(InterSameDataRepository):
3652
 
    """Optimised code paths between Knit based repositories."""
3653
 
 
3654
 
    @classmethod
3655
 
    def _get_repo_format_to_test(self):
3656
 
        from bzrlib.repofmt import knitrepo
3657
 
        return knitrepo.RepositoryFormatKnit1()
3658
 
 
3659
 
    @staticmethod
3660
 
    def is_compatible(source, target):
3661
 
        """Be compatible with known Knit formats.
3662
 
 
3663
 
        We don't test for the stores being of specific types because that
3664
 
        could lead to confusing results, and there is no need to be
3665
 
        overly general.
3666
 
        """
3667
 
        from bzrlib.repofmt.knitrepo import RepositoryFormatKnit
3668
 
        try:
3669
 
            are_knits = (isinstance(source._format, RepositoryFormatKnit) and
3670
 
                isinstance(target._format, RepositoryFormatKnit))
3671
 
        except AttributeError:
3672
 
            return False
3673
 
        return are_knits and InterRepository._same_model(source, target)
3674
 
 
3675
 
    @needs_read_lock
3676
 
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
3677
 
        """See InterRepository.missing_revision_ids()."""
3678
 
        if revision_id is not None:
3679
 
            source_ids = self.source.get_ancestry(revision_id)
3680
 
            if source_ids[0] is not None:
3681
 
                raise AssertionError()
3682
 
            source_ids.pop(0)
3683
 
        else:
3684
 
            source_ids = self.source.all_revision_ids()
3685
 
        source_ids_set = set(source_ids)
3686
 
        # source_ids is the worst possible case we may need to pull.
3687
 
        # now we want to filter source_ids against what we actually
3688
 
        # have in target, but don't try to check for existence where we know
3689
 
        # we do not have a revision as that would be pointless.
3690
 
        target_ids = set(self.target.all_revision_ids())
3691
 
        possibly_present_revisions = target_ids.intersection(source_ids_set)
3692
 
        actually_present_revisions = set(
3693
 
            self.target._eliminate_revisions_not_present(possibly_present_revisions))
3694
 
        required_revisions = source_ids_set.difference(actually_present_revisions)
3695
 
        if revision_id is not None:
3696
 
            # we used get_ancestry to determine source_ids then we are assured all
3697
 
            # revisions referenced are present as they are installed in topological order.
3698
 
            # and the tip revision was validated by get_ancestry.
3699
 
            result_set = required_revisions
3700
 
        else:
3701
 
            # if we just grabbed the possibly available ids, then
3702
 
            # we only have an estimate of whats available and need to validate
3703
 
            # that against the revision records.
3704
 
            result_set = set(
3705
 
                self.source._eliminate_revisions_not_present(required_revisions))
3706
 
        return self.source.revision_ids_to_search_result(result_set)
3707
 
 
3708
 
 
3709
3591
class InterDifferingSerializer(InterRepository):
3710
3592
 
3711
3593
    @classmethod
3813
3695
                basis_id, delta, current_revision_id, parents_parents)
3814
3696
            cache[current_revision_id] = parent_tree
3815
3697
 
3816
 
    def _fetch_batch(self, revision_ids, basis_id, cache, a_graph=None):
 
3698
    def _fetch_batch(self, revision_ids, basis_id, cache):
3817
3699
        """Fetch across a few revisions.
3818
3700
 
3819
3701
        :param revision_ids: The revisions to copy
3820
3702
        :param basis_id: The revision_id of a tree that must be in cache, used
3821
3703
            as a basis for delta when no other base is available
3822
3704
        :param cache: A cache of RevisionTrees that we can use.
3823
 
        :param a_graph: A Graph object to determine the heads() of the
3824
 
            rich-root data stream.
3825
3705
        :return: The revision_id of the last converted tree. The RevisionTree
3826
3706
            for it will be in cache
3827
3707
        """
3895
3775
        if root_keys_to_create:
3896
3776
            root_stream = _mod_fetch._new_root_data_stream(
3897
3777
                root_keys_to_create, self._revision_id_to_root_id, parent_map,
3898
 
                self.source, graph=a_graph)
 
3778
                self.source)
3899
3779
            to_texts.insert_record_stream(root_stream)
3900
3780
        to_texts.insert_record_stream(from_texts.get_record_stream(
3901
3781
            text_keys, self.target._format._fetch_order,
3958
3838
        cache[basis_id] = basis_tree
3959
3839
        del basis_tree # We don't want to hang on to it here
3960
3840
        hints = []
3961
 
        if self._converting_to_rich_root and len(revision_ids) > 100:
3962
 
            a_graph = _mod_fetch._get_rich_root_heads_graph(self.source,
3963
 
                                                            revision_ids)
3964
 
        else:
3965
 
            a_graph = None
 
3841
        a_graph = None
3966
3842
 
3967
3843
        for offset in range(0, len(revision_ids), batch_size):
3968
3844
            self.target.start_write_group()
3970
3846
                pb.update('Transferring revisions', offset,
3971
3847
                          len(revision_ids))
3972
3848
                batch = revision_ids[offset:offset+batch_size]
3973
 
                basis_id = self._fetch_batch(batch, basis_id, cache,
3974
 
                                             a_graph=a_graph)
 
3849
                basis_id = self._fetch_batch(batch, basis_id, cache)
3975
3850
            except:
3976
3851
                self.source._safe_to_return_from_cache = False
3977
3852
                self.target.abort_write_group()
4043
3918
            basis_id = first_rev.parent_ids[0]
4044
3919
            # only valid as a basis if the target has it
4045
3920
            self.target.get_revision(basis_id)
4046
 
            # Try to get a basis tree - if its a ghost it will hit the
 
3921
            # Try to get a basis tree - if it's a ghost it will hit the
4047
3922
            # NoSuchRevision case.
4048
3923
            basis_tree = self.source.revision_tree(basis_id)
4049
3924
        except (IndexError, errors.NoSuchRevision):
4054
3929
 
4055
3930
InterRepository.register_optimiser(InterDifferingSerializer)
4056
3931
InterRepository.register_optimiser(InterSameDataRepository)
4057
 
InterRepository.register_optimiser(InterWeaveRepo)
4058
 
InterRepository.register_optimiser(InterKnitRepo)
4059
3932
 
4060
3933
 
4061
3934
class CopyConverter(object):
4249
4122
                is_resume = False
4250
4123
            try:
4251
4124
                # locked_insert_stream performs a commit|suspend.
4252
 
                return self._locked_insert_stream(stream, src_format, is_resume)
 
4125
                return self._locked_insert_stream(stream, src_format,
 
4126
                    is_resume)
4253
4127
            except:
4254
4128
                self.target_repo.abort_write_group(suppress_errors=True)
4255
4129
                raise
4302
4176
                # required if the serializers are different only in terms of
4303
4177
                # the inventory.
4304
4178
                if src_serializer == to_serializer:
4305
 
                    self.target_repo.revisions.insert_record_stream(
4306
 
                        substream)
 
4179
                    self.target_repo.revisions.insert_record_stream(substream)
4307
4180
                else:
4308
4181
                    self._extract_and_insert_revisions(substream,
4309
4182
                        src_serializer)
4417
4290
        """Create a StreamSource streaming from from_repository."""
4418
4291
        self.from_repository = from_repository
4419
4292
        self.to_format = to_format
 
4293
        self._record_counter = RecordCounter()
4420
4294
 
4421
4295
    def delta_on_metadata(self):
4422
4296
        """Return True if delta's are permitted on metadata streams.