/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: Canonical.com Patch Queue Manager
  • Date: 2010-06-04 05:59:55 UTC
  • mfrom: (5279.1.1 lazy-import-merge)
  • Revision ID: pqm@pqm.ubuntu.com-20100604055955-98pfcy1bn8oz7749
(spiv) Use lazy imports in bzrilb.merge to minimise the startup cost of
 plugins like news_merge. (Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repository.py
26
26
    chk_map,
27
27
    config,
28
28
    debug,
29
 
    errors,
30
29
    fetch as _mod_fetch,
31
30
    fifo_cache,
32
31
    generate_ids,
44
43
    symbol_versioning,
45
44
    trace,
46
45
    tsort,
47
 
    ui,
48
46
    versionedfile,
49
47
    )
50
48
from bzrlib.bundle import serializer
53
51
from bzrlib.testament import Testament
54
52
""")
55
53
 
 
54
from bzrlib import (
 
55
    errors,
 
56
    registry,
 
57
    ui,
 
58
    )
56
59
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
57
60
from bzrlib.inter import InterObject
58
61
from bzrlib.inventory import (
61
64
    ROOT_ID,
62
65
    entry_factory,
63
66
    )
64
 
from bzrlib.lock import _RelockDebugMixin
65
 
from bzrlib import registry
 
67
from bzrlib.recordcounter import RecordCounter
 
68
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
66
69
from bzrlib.trace import (
67
70
    log_exception_quietly, note, mutter, mutter_callsite, warning)
68
71
 
71
74
_deprecation_warning_done = False
72
75
 
73
76
 
 
77
class IsInWriteGroupError(errors.InternalBzrError):
 
78
 
 
79
    _fmt = "May not refresh_data of repo %(repo)s while in a write group."
 
80
 
 
81
    def __init__(self, repo):
 
82
        errors.InternalBzrError.__init__(self, repo=repo)
 
83
 
 
84
 
74
85
class CommitBuilder(object):
75
86
    """Provides an interface to build up a commit.
76
87
 
278
289
 
279
290
        :param tree: The tree which is being committed.
280
291
        """
281
 
        # NB: if there are no parents then this method is not called, so no
282
 
        # need to guard on parents having length.
 
292
        if len(self.parents) == 0:
 
293
            raise errors.RootMissing()
283
294
        entry = entry_factory['directory'](tree.path2id(''), '',
284
295
            None)
285
296
        entry.revision = self._new_revision_id
860
871
        # versioned roots do not change unless the tree found a change.
861
872
 
862
873
 
863
 
class RepositoryWriteLockResult(object):
 
874
class RepositoryWriteLockResult(LogicalLockResult):
864
875
    """The result of write locking a repository.
865
876
 
866
877
    :ivar repository_token: The token obtained from the underlying lock, or
869
880
    """
870
881
 
871
882
    def __init__(self, unlock, repository_token):
 
883
        LogicalLockResult.__init__(self, unlock)
872
884
        self.repository_token = repository_token
873
 
        self.unlock = unlock
 
885
 
 
886
    def __repr__(self):
 
887
        return "RepositoryWriteLockResult(%s, %s)" % (self.repository_token,
 
888
            self.unlock)
874
889
 
875
890
 
876
891
######################################################################
1031
1046
                " id and insertion revid (%r, %r)"
1032
1047
                % (inv.revision_id, revision_id))
1033
1048
        if inv.root is None:
1034
 
            raise AssertionError()
 
1049
            raise errors.RootMissing()
1035
1050
        return self._add_inventory_checked(revision_id, inv, parents)
1036
1051
 
1037
1052
    def _add_inventory_checked(self, revision_id, inv, parents):
1430
1445
            for repo in self._fallback_repositories:
1431
1446
                repo.lock_read()
1432
1447
            self._refresh_data()
1433
 
        return self
 
1448
        return LogicalLockResult(self.unlock)
1434
1449
 
1435
1450
    def get_physical_lock_status(self):
1436
1451
        return self.control_files.get_physical_lock_status()
1654
1669
        return missing_keys
1655
1670
 
1656
1671
    def refresh_data(self):
1657
 
        """Re-read any data needed to to synchronise with disk.
 
1672
        """Re-read any data needed to synchronise with disk.
1658
1673
 
1659
1674
        This method is intended to be called after another repository instance
1660
1675
        (such as one used by a smart server) has inserted data into the
1661
 
        repository. It may not be called during a write group, but may be
1662
 
        called at any other time.
 
1676
        repository. On all repositories this will work outside of write groups.
 
1677
        Some repository formats (pack and newer for bzrlib native formats)
 
1678
        support refresh_data inside write groups. If called inside a write
 
1679
        group on a repository that does not support refreshing in a write group
 
1680
        IsInWriteGroupError will be raised.
1663
1681
        """
1664
 
        if self.is_in_write_group():
1665
 
            raise errors.InternalBzrError(
1666
 
                "May not refresh_data while in a write group.")
1667
1682
        self._refresh_data()
1668
1683
 
1669
1684
    def resume_write_group(self, tokens):
1708
1723
                "May not fetch while in a write group.")
1709
1724
        # fast path same-url fetch operations
1710
1725
        # TODO: lift out to somewhere common with RemoteRepository
1711
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401646>
 
1726
        # <https://bugs.launchpad.net/bzr/+bug/401646>
1712
1727
        if (self.has_same_location(source)
1713
1728
            and fetch_spec is None
1714
1729
            and self._has_same_fallbacks(source)):
4269
4284
                is_resume = False
4270
4285
            try:
4271
4286
                # locked_insert_stream performs a commit|suspend.
4272
 
                return self._locked_insert_stream(stream, src_format, is_resume)
 
4287
                return self._locked_insert_stream(stream, src_format,
 
4288
                    is_resume)
4273
4289
            except:
4274
4290
                self.target_repo.abort_write_group(suppress_errors=True)
4275
4291
                raise
4322
4338
                # required if the serializers are different only in terms of
4323
4339
                # the inventory.
4324
4340
                if src_serializer == to_serializer:
4325
 
                    self.target_repo.revisions.insert_record_stream(
4326
 
                        substream)
 
4341
                    self.target_repo.revisions.insert_record_stream(substream)
4327
4342
                else:
4328
4343
                    self._extract_and_insert_revisions(substream,
4329
4344
                        src_serializer)
4437
4452
        """Create a StreamSource streaming from from_repository."""
4438
4453
        self.from_repository = from_repository
4439
4454
        self.to_format = to_format
 
4455
        self._record_counter = RecordCounter()
4440
4456
 
4441
4457
    def delta_on_metadata(self):
4442
4458
        """Return True if delta's are permitted on metadata streams.