/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: Jelmer Vernooij
  • Date: 2017-06-08 23:30:31 UTC
  • mto: This revision was merged to the branch mainline in revision 6690.
  • Revision ID: jelmer@jelmer.uk-20170608233031-3qavls2o7a1pqllj
Update imports.

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 .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
 
19
from __future__ import absolute_import
 
20
 
 
21
from .errors import NoCompatibleInter
32
22
 
33
23
 
34
24
class InterObject(object):
45
35
 
46
36
    If the source and target objects implement the locking protocol -
47
37
    lock_read, lock_write, unlock, then the InterObject's lock_read,
48
 
    lock_write and unlock methods may be used.
 
38
    lock_write and unlock methods may be used (optionally in conjunction with
 
39
    the needs_read_lock and needs_write_lock decorators.)
49
40
 
50
41
    When looking for an inter, the most recently registered types are tested
51
42
    first.  So typically the most generic and slowest InterObjects should be
91
82
        If an optimised worker exists it will be used otherwise
92
83
        a default Inter worker instance will be created.
93
84
        """
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
 
85
        for provider in reversed(klass._optimisers):
98
86
            if provider.is_compatible(source, target):
99
87
                return provider(source, target)
100
88
        raise NoCompatibleInter(source, target)
101
89
 
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
 
 
110
90
    def lock_read(self):
111
91
        """Take out a logical read lock.
112
92
 
114
94
        a read lock and the target a read lock.
115
95
        """
116
96
        self._double_lock(self.source.lock_read, self.target.lock_read)
117
 
        return LogicalLockResult(self.unlock)
118
97
 
119
98
    def lock_write(self):
120
99
        """Take out a logical write lock.
123
102
        a read lock and the target a write lock.
124
103
        """
125
104
        self._double_lock(self.source.lock_read, self.target.lock_write)
126
 
        return LogicalLockResult(self.unlock)
127
105
 
128
106
    @classmethod
129
107
    def register_optimiser(klass, optimiser):
130
108
        """Register an InterObject optimiser."""
131
109
        klass._optimisers.append(optimiser)
132
110
 
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
 
 
138
111
    def unlock(self):
139
112
        """Release the locks on source and target."""
140
113
        try: