← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/registry.py

  • Committer: v.ladeuil+lp at free
  • Date: 2007-05-15 17:40:32 UTC
  • mto: (2485.8.44 bzr.connection.sharing)
  • mto: This revision was merged to the branch mainline in revision 2646.
  • Revision ID: v.ladeuil+lp@free.fr-20070515174032-qzdkangpv29l9e7g
Add a test that check that init connect only once. It fails.

* __init__.py:
(test_suite): Register the new test class.

* test_init.py: 
(InstrumentedTransport): A transport that can track connections.
(TransportHooks): Transport specific hooks.
(TestInit): Iniit command behavior tests.

* ftp.py:
(FtpTransport.__init__): Mark place that need fixing regarding
transport connection sharing

* builtins.py:
(cmd_init.run): Mark places that need fixing regarding transport
connection sharing.

Show diffs side-by-side

added added

removed removed

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