/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 breezy/inter.py

  • Committer: Breezy landing bot
  • Author(s): Colin Watson
  • Date: 2020-11-16 21:47:08 UTC
  • mfrom: (7521.1.1 remove-lp-workaround)
  • Revision ID: breezy.the.bot@gmail.com-20201116214708-jos209mgxi41oy15
Remove breezy.git workaround for bazaar.launchpad.net.

Merged from https://code.launchpad.net/~cjwatson/brz/remove-lp-workaround/+merge/393710

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/inter.py
16
16
 
17
17
"""Inter-object utility class."""
18
18
 
19
 
from __future__ import absolute_import
20
 
 
21
 
from bzrlib.errors import NoCompatibleInter
 
19
from .errors import BzrError
 
20
from .lock import LogicalLockResult
 
21
from .pyutils import get_named_object
 
22
 
 
23
 
 
24
class NoCompatibleInter(BzrError):
 
25
 
 
26
    _fmt = ('No compatible object available for operations from %(source)r '
 
27
            'to %(target)r.')
 
28
 
 
29
    def __init__(self, source, target):
 
30
        self.source = source
 
31
        self.target = target
22
32
 
23
33
 
24
34
class InterObject(object):
35
45
 
36
46
    If the source and target objects implement the locking protocol -
37
47
    lock_read, lock_write, unlock, then the InterObject's lock_read,
38
 
    lock_write and unlock methods may be used (optionally in conjunction with
39
 
    the needs_read_lock and needs_write_lock decorators.)
 
48
    lock_write and unlock methods may be used.
40
49
 
41
50
    When looking for an inter, the most recently registered types are tested
42
51
    first.  So typically the most generic and slowest InterObjects should be
82
91
        If an optimised worker exists it will be used otherwise
83
92
        a default Inter worker instance will be created.
84
93
        """
85
 
        for provider in reversed(klass._optimisers):
 
94
        for i, provider in enumerate(reversed(klass._optimisers)):
 
95
            if isinstance(provider, tuple):
 
96
                provider = get_named_object(provider[0], provider[1])
 
97
                klass._optimisers[-i] = provider
86
98
            if provider.is_compatible(source, target):
87
99
                return provider(source, target)
88
100
        raise NoCompatibleInter(source, target)
89
101
 
 
102
    @classmethod
 
103
    def iter_optimisers(klass):
 
104
        for provider in klass._optimisers:
 
105
            if isinstance(provider, tuple):
 
106
                yield get_named_object(provider[0], provider[1])
 
107
            else:
 
108
                yield provider
 
109
 
90
110
    def lock_read(self):
91
111
        """Take out a logical read lock.
92
112
 
94
114
        a read lock and the target a read lock.
95
115
        """
96
116
        self._double_lock(self.source.lock_read, self.target.lock_read)
 
117
        return LogicalLockResult(self.unlock)
97
118
 
98
119
    def lock_write(self):
99
120
        """Take out a logical write lock.
102
123
        a read lock and the target a write lock.
103
124
        """
104
125
        self._double_lock(self.source.lock_read, self.target.lock_write)
 
126
        return LogicalLockResult(self.unlock)
105
127
 
106
128
    @classmethod
107
129
    def register_optimiser(klass, optimiser):
108
130
        """Register an InterObject optimiser."""
109
131
        klass._optimisers.append(optimiser)
110
132
 
 
133
    @classmethod
 
134
    def register_lazy_optimiser(klass, module_name, member_name):
 
135
        # TODO(jelmer): Allow passing in a custom .is_compatible
 
136
        klass._optimisers.append((module_name, member_name))
 
137
 
111
138
    def unlock(self):
112
139
        """Release the locks on source and target."""
113
140
        try: