← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/registry.py

  • Committer: Vincent Ladeuil
  • Date: 2012-01-18 14:09:19 UTC
  • mto: This revision was merged to the branch mainline in revision 6468.
  • Revision ID: v.ladeuil+lp@free.fr-20120118140919-rlvdrhpc0nq1lbwi
Change set/remove to require a lock for the branch config files.

This means that tests (or any plugin for that matter) do not requires an
explicit lock on the branch anymore to change a single option. This also
means the optimisation becomes "opt-in" and as such won't be as
spectacular as it may be and/or harder to get right (nothing fails
anymore).

This reduces the diff by ~300 lines.

Code/tests that were updating more than one config option is still taking
a lock to at least avoid some IOs and demonstrate the benefits through
the decreased number of hpss calls.

The duplication between BranchStack and BranchOnlyStack will be removed
once the same sharing is in place for local config files, at which point
the Stack class itself may be able to host the changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/registry.py
1
 
# Copyright (C) 2006 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Classes to provide name-to-object registry-like support."""
18
18
 
 
19
from __future__ import absolute_import
 
20
 
 
21
from bzrlib.pyutils import get_named_object
 
22
 
19
23
 
20
24
class _ObjectGetter(object):
21
25
    """Maintain a reference to an object, and return the object on request.
32
36
    def __init__(self, obj):
33
37
        self._obj = obj
34
38
 
 
39
    def get_module(self):
 
40
        """Get the module the object was loaded from."""
 
41
        return self._obj.__module__
 
42
 
35
43
    def get_obj(self):
36
44
        """Get the object that was saved at creation time"""
37
45
        return self._obj
51
59
        self._imported = False
52
60
        super(_LazyObjectGetter, self).__init__(None)
53
61
 
 
62
    def get_module(self):
 
63
        """Get the module the referenced object will be loaded from.
 
64
        """
 
65
        return self._module_name
 
66
 
54
67
    def get_obj(self):
55
68
        """Get the referenced object.
56
69
 
58
71
        return the imported object.
59
72
        """
60
73
        if not self._imported:
61
 
            self._do_import()
 
74
            self._obj = get_named_object(self._module_name, self._member_name)
 
75
            self._imported = True
62
76
        return super(_LazyObjectGetter, self).get_obj()
63
77
 
64
 
    def _do_import(self):
65
 
        obj = __import__(self._module_name, globals(), locals(),
66
 
                         [self._member_name])
67
 
        if self._member_name:
68
 
            obj = getattr(obj, self._member_name)
69
 
        self._obj = obj
70
 
        self._imported = True
 
78
    def __repr__(self):
 
79
        return "<%s.%s object at %x, module=%r attribute=%r imported=%r>" % (
 
80
            self.__class__.__module__, self.__class__.__name__, id(self),
 
81
            self._module_name, self._member_name, self._imported)
71
82
 
72
83
 
73
84
class Registry(object):
102
113
        :param obj: The object to register.
103
114
        :param help: Help text for this entry. This may be a string or
104
115
                a callable. If it is a callable, it should take two
105
 
                parameters (registry, key): this registry and the key that 
 
116
                parameters (registry, key): this registry and the key that
106
117
                the help was registered under.
107
118
        :param info: More information for this entry. Registry.get_info()
108
119
                can be used to get this information. Registry treats this as an
122
133
                      override_existing=False):
123
134
        """Register a new object to be loaded on request.
124
135
 
 
136
        :param key: This is the key to use to request the object later.
125
137
        :param module_name: The python path to the module. Such as 'os.path'.
126
 
        :param member_name: The member of the module to return.  If empty or 
 
138
        :param member_name: The member of the module to return.  If empty or
127
139
                None, get() will return the module itself.
128
140
        :param help: Help text for this entry. This may be a string or
129
141
                a callable.
130
 
        :param info: More information for this entry. Registry 
 
142
        :param info: More information for this entry. Registry.get_info()
 
143
                can be used to get this information. Registry treats this as an
 
144
                opaque storage location (it is defined by the caller).
131
145
        :param override_existing: If True, replace the existing object
132
146
                with the new one. If False, if there is already something
133
147
                registered with the same key, raise a KeyError
147
161
        """Return the object register()'ed to the given key.
148
162
 
149
163
        May raise ImportError if the object was registered lazily and
150
 
        there are any problems, or AttributeError if the module does not 
 
164
        there are any problems, or AttributeError if the module does not
151
165
        have the supplied member.
152
166
 
153
167
        :param key: The key to obtain the object for. If no object has been
162
176
        """
163
177
        return self._dict[self._get_key_or_default(key)].get_obj()
164
178
 
 
179
    def _get_module(self, key):
 
180
        """Return the module the object will be or was loaded from.
 
181
 
 
182
        :param key: The key to obtain the module for.
 
183
        :return: The name of the module
 
184
        """
 
185
        return self._dict[key].get_module()
 
186
 
 
187
    def get_prefix(self, fullname):
 
188
        """Return an object whose key is a prefix of the supplied value.
 
189
 
 
190
        :fullname: The name to find a prefix for
 
191
        :return: a tuple of (object, remainder), where the remainder is the
 
192
            portion of the name that did not match the key.
 
193
        """
 
194
        for key in self.keys():
 
195
            if fullname.startswith(key):
 
196
                return self.get(key), fullname[len(key):]
 
197
 
165
198
    def _get_key_or_default(self, key=None):
166
199
        """Return either 'key' or the default key if key is None"""
167
200
        if key is not None:
200
233
        for key, getter in self._dict.iteritems():
201
234
            yield key, getter.get_obj()
202
235
 
 
236
    def items(self):
 
237
        # We should not use the iteritems() implementation below (see bug
 
238
        # #430510)
 
239
        return sorted([(key, getter.get_obj())
 
240
                       for key, getter in self._dict.items()])
 
241
 
203
242
    def _set_default_key(self, key):
204
243
        if not self._dict.has_key(key):
205
244
            raise KeyError('No object registered under key %s.' % key)
212
251
    default_key = property(_get_default_key, _set_default_key,
213
252
                            doc="Current value of the default key."
214
253
                                " Can be set to any existing key.")
 
254
 
 
255
 
 
256
class FormatRegistry(Registry):
 
257
    """Registry specialised for handling formats."""
 
258
 
 
259
    def __init__(self, other_registry=None):
 
260
        Registry.__init__(self)
 
261
        self._other_registry = other_registry
 
262
 
 
263
    def register(self, key, obj, help=None, info=None,
 
264
                 override_existing=False):
 
265
        Registry.register(self, key, obj, help=help, info=info,
 
266
            override_existing=override_existing)
 
267
        if self._other_registry is not None:
 
268
            self._other_registry.register(key, obj, help=help,
 
269
                info=info, override_existing=override_existing)
 
270
 
 
271
    def register_lazy(self, key, module_name, member_name,
 
272
                      help=None, info=None,
 
273
                      override_existing=False):
 
274
        # Overridden to allow capturing registrations to two seperate
 
275
        # registries in a single call.
 
276
        Registry.register_lazy(self, key, module_name, member_name,
 
277
                help=help, info=info, override_existing=override_existing)
 
278
        if self._other_registry is not None:
 
279
            self._other_registry.register_lazy(key, module_name, member_name,
 
280
                help=help, info=info, override_existing=override_existing)
 
281
 
 
282
    def remove(self, key):
 
283
        Registry.remove(self, key)
 
284
        if self._other_registry is not None:
 
285
            self._other_registry.remove(key)
 
286
 
 
287
    def get(self, format_string):
 
288
        r = Registry.get(self, format_string)
 
289
        if callable(r):
 
290
            r = r()
 
291
        return r