/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/plugin.py

  • Committer: Robert Collins
  • Date: 2010-05-11 08:36:16 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100511083616-b8fjb19zomwupid0
Make all lock methods return Result objects, rather than lock_read returning self, as per John's review.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/plugin.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd, 2017 Breezy developers
 
1
# Copyright (C) 2005-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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
"""Breezy plugin support.
18
 
 
19
 
Which plugins to load can be configured by setting these environment variables:
20
 
 
21
 
- BRZ_PLUGIN_PATH: Paths to look for plugins in.
22
 
- BRZ_DISABLE_PLUGINS: Plugin names to block from being loaded.
23
 
- BRZ_PLUGINS_AT: Name and paths for plugins to load from specific locations.
24
 
 
25
 
The interfaces this module exports include:
26
 
 
27
 
- disable_plugins: Load no plugins and stop future automatic loading.
28
 
- load_plugins: Load all plugins that can be found in configuration.
29
 
- describe_plugins: Generate text for each loaded (or failed) plugin.
30
 
- extend_path: Mechanism by which the plugins package path is set.
31
 
- plugin_name: Gives unprefixed name of a plugin module.
 
17
 
 
18
"""bzr python plugin support.
 
19
 
 
20
When load_plugins() is invoked, any python module in any directory in
 
21
$BZR_PLUGIN_PATH will be imported.  The module will be imported as
 
22
'bzrlib.plugins.$BASENAME(PLUGIN)'.  In the plugin's main body, it should
 
23
update any bzrlib registries it wants to extend.
32
24
 
33
25
See the plugin-api developer documentation for information about writing
34
26
plugins.
 
27
 
 
28
BZR_PLUGIN_PATH is also honoured for any plugins imported via
 
29
'import bzrlib.plugins.PLUGINNAME', as long as set_plugins_path has been
 
30
called.
35
31
"""
36
32
 
37
 
from __future__ import absolute_import
38
 
 
39
33
import os
40
 
import re
41
34
import sys
42
35
 
43
 
import breezy
44
 
from . import osutils
45
 
 
46
 
from .lazy_import import lazy_import
 
36
from bzrlib import osutils
 
37
 
 
38
from bzrlib.lazy_import import lazy_import
 
39
 
47
40
lazy_import(globals(), """
48
41
import imp
49
 
from importlib import util as importlib_util
 
42
import re
 
43
import types
50
44
 
51
 
from breezy import (
52
 
    bedding,
 
45
from bzrlib import (
 
46
    _format_version_tuple,
 
47
    config,
53
48
    debug,
54
 
    help_topics,
 
49
    errors,
55
50
    trace,
56
51
    )
 
52
from bzrlib import plugins as _mod_plugins
57
53
""")
58
54
 
59
 
from . import (
60
 
    errors,
 
55
from bzrlib.symbol_versioning import (
 
56
    deprecated_function,
 
57
    deprecated_in,
61
58
    )
62
59
 
63
60
 
64
 
_MODULE_PREFIX = "breezy.plugins."
65
 
 
66
 
if __debug__ or sys.version_info > (3,):
67
 
    COMPILED_EXT = ".pyc"
68
 
else:
69
 
    COMPILED_EXT = ".pyo"
70
 
 
71
 
 
72
 
def disable_plugins(state=None):
 
61
DEFAULT_PLUGIN_PATH = None
 
62
_loaded = False
 
63
_plugins_disabled = False
 
64
 
 
65
 
 
66
def are_plugins_disabled():
 
67
    return _plugins_disabled
 
68
 
 
69
 
 
70
def disable_plugins():
73
71
    """Disable loading plugins.
74
72
 
75
73
    Future calls to load_plugins() will be ignored.
76
 
 
77
 
    :param state: The library state object that records loaded plugins.
78
74
    """
79
 
    if state is None:
80
 
        state = breezy.get_global_state()
81
 
    state.plugins = {}
82
 
 
83
 
 
84
 
def load_plugins(path=None, state=None, warn_load_problems=True):
85
 
    """Load breezy plugins.
86
 
 
87
 
    The environment variable BRZ_PLUGIN_PATH is considered a delimited
88
 
    set of paths to look through. Each entry is searched for `*.py`
89
 
    files (and whatever other extensions are used in the platform,
90
 
    such as `*.pyd`).
 
75
    global _plugins_disabled
 
76
    _plugins_disabled = True
 
77
    load_plugins([])
 
78
 
 
79
 
 
80
def _strip_trailing_sep(path):
 
81
    return path.rstrip("\\/")
 
82
 
 
83
 
 
84
def set_plugins_path(path=None):
 
85
    """Set the path for plugins to be loaded from.
91
86
 
92
87
    :param path: The list of paths to search for plugins.  By default,
93
 
        it is populated from the __path__ of the breezy.plugins package.
94
 
    :param state: The library state object that records loaded plugins.
 
88
        path will be determined using get_standard_plugins_path.
 
89
        if path is [], no plugins can be loaded.
95
90
    """
96
 
    if state is None:
97
 
        state = breezy.get_global_state()
98
 
    if getattr(state, 'plugins', None) is not None:
99
 
        # People can make sure plugins are loaded, they just won't be twice
100
 
        return
101
 
 
102
91
    if path is None:
103
 
        # Calls back into extend_path() here
104
 
        from breezy.plugins import __path__ as path
105
 
 
106
 
    state.plugin_warnings = {}
107
 
    _load_plugins_from_path(state, path)
108
 
    if (None, 'entrypoints') in _env_plugin_path():
109
 
        _load_plugins_from_entrypoints(state)
110
 
    state.plugins = plugins()
111
 
    if warn_load_problems:
112
 
        for plugin, errors in state.plugin_warnings.items():
113
 
            for error in errors:
114
 
                trace.warning('%s', error)
115
 
 
116
 
 
117
 
def _load_plugins_from_entrypoints(state):
118
 
    try:
119
 
        import pkg_resources
120
 
    except ImportError:
121
 
        # No pkg_resources, no entrypoints.
122
 
        pass
123
 
    else:
124
 
        for ep in pkg_resources.iter_entry_points('breezy.plugin'):
125
 
            fullname = _MODULE_PREFIX + ep.name
126
 
            if fullname in sys.modules:
127
 
                continue
128
 
            sys.modules[fullname] = ep.load()
129
 
 
130
 
 
131
 
def plugin_name(module_name):
132
 
    """Gives unprefixed name from module_name or None."""
133
 
    if module_name.startswith(_MODULE_PREFIX):
134
 
        parts = module_name.split(".")
135
 
        if len(parts) > 2:
136
 
            return parts[2]
137
 
    return None
138
 
 
139
 
 
140
 
def extend_path(path, name):
141
 
    """Helper so breezy.plugins can be a sort of namespace package.
142
 
 
143
 
    To be used in similar fashion to pkgutil.extend_path:
144
 
 
145
 
        from breezy.plugins import extend_path
146
 
        __path__ = extend_path(__path__, __name__)
147
 
 
148
 
    Inspects the BRZ_PLUGIN* envvars, sys.path, and the filesystem to find
149
 
    plugins. May mutate sys.modules in order to block plugin loading, and may
150
 
    append a new meta path finder to sys.meta_path for plugins@ loading.
151
 
 
152
 
    Returns a list of paths to import from, as an enhanced object that also
153
 
    contains details of the other configuration used.
154
 
    """
155
 
    blocks = _env_disable_plugins()
156
 
    _block_plugins(blocks)
157
 
 
158
 
    extra_details = _env_plugins_at()
159
 
    _install_importer_if_needed(extra_details)
160
 
 
161
 
    paths = _iter_plugin_paths(_env_plugin_path(), path)
162
 
 
163
 
    return _Path(name, blocks, extra_details, paths)
164
 
 
165
 
 
166
 
class _Path(list):
167
 
    """List type to use as __path__ but containing additional details.
168
 
 
169
 
    Python 3 allows any iterable for __path__ but Python 2 is more fussy.
170
 
    """
171
 
 
172
 
    def __init__(self, package_name, blocked, extra, paths):
173
 
        super(_Path, self).__init__(paths)
174
 
        self.package_name = package_name
175
 
        self.blocked_names = blocked
176
 
        self.extra_details = extra
177
 
 
178
 
    def __repr__(self):
179
 
        return "%s(%r, %r, %r, %s)" % (
180
 
            self.__class__.__name__, self.package_name, self.blocked_names,
181
 
            self.extra_details, list.__repr__(self))
182
 
 
183
 
 
184
 
def _expect_identifier(name, env_key, env_value):
185
 
    """Validate given name from envvar is usable as a Python identifier.
186
 
 
187
 
    Returns the name as a native str, or None if it was invalid.
188
 
 
189
 
    Per PEP 3131 this is no longer strictly correct for Python 3, but as MvL
190
 
    didn't include a neat way to check except eval, this enforces ascii.
191
 
    """
192
 
    if re.match(r"^[A-Za-z_][A-Za-z0-9_]*$", name) is None:
193
 
        trace.warning("Invalid name '%s' in %s='%s'", name, env_key, env_value)
194
 
        return None
195
 
    return str(name)
196
 
 
197
 
 
198
 
def _env_disable_plugins(key='BRZ_DISABLE_PLUGINS'):
199
 
    """Gives list of names for plugins to disable from environ key."""
200
 
    disabled_names = []
201
 
    env = osutils.path_from_environ(key)
202
 
    if env:
203
 
        for name in env.split(os.pathsep):
204
 
            name = _expect_identifier(name, key, env)
205
 
            if name is not None:
206
 
                disabled_names.append(name)
207
 
    return disabled_names
208
 
 
209
 
 
210
 
def _env_plugins_at(key='BRZ_PLUGINS_AT'):
211
 
    """Gives list of names and paths of specific plugins from environ key."""
212
 
    plugin_details = []
213
 
    env = osutils.path_from_environ(key)
214
 
    if env:
215
 
        for pair in env.split(os.pathsep):
216
 
            if '@' in pair:
217
 
                name, path = pair.split('@', 1)
218
 
            else:
219
 
                path = pair
220
 
                name = osutils.basename(path).split('.', 1)[0]
221
 
            name = _expect_identifier(name, key, env)
222
 
            if name is not None:
223
 
                plugin_details.append((name, path))
224
 
    return plugin_details
225
 
 
226
 
 
227
 
def _env_plugin_path(key='BRZ_PLUGIN_PATH'):
228
 
    """Gives list of paths and contexts for plugins from environ key.
229
 
 
230
 
    Each entry is either a specific path to load plugins from and the value
231
 
    'path', or None and one of the values 'user', 'core', 'entrypoints', 'site'.
232
 
    """
233
 
    path_details = []
234
 
    env = osutils.path_from_environ(key)
235
 
    defaults = {
236
 
        "user": not env,
237
 
        "core": True,
238
 
        "site": True,
239
 
        'entrypoints': False,
240
 
        }
241
 
    if env:
242
 
        # Add paths specified by user in order
243
 
        for p in env.split(os.pathsep):
244
 
            flag, name = p[:1], p[1:]
245
 
            if flag in ("+", "-") and name in defaults:
246
 
                if flag == "+" and defaults[name] is not None:
247
 
                    path_details.append((None, name))
248
 
                defaults[name] = None
249
 
            else:
250
 
                path_details.append((p, 'path'))
251
 
 
252
 
    # Add any remaining default paths
253
 
    for name in ('user', 'core', 'entrypoints', 'site'):
254
 
        if defaults[name]:
255
 
            path_details.append((None, name))
256
 
 
257
 
    return path_details
258
 
 
259
 
 
260
 
def _iter_plugin_paths(paths_from_env, core_paths):
261
 
    """Generate paths using paths_from_env and core_paths."""
262
 
    # GZ 2017-06-02: This is kinda horrid, should make better.
263
 
    for path, context in paths_from_env:
264
 
        if context == 'path':
265
 
            yield path
266
 
        elif context == 'user':
267
 
            path = get_user_plugin_path()
268
 
            if os.path.isdir(path):
269
 
                yield path
270
 
        elif context == 'core':
271
 
            for path in _get_core_plugin_paths(core_paths):
272
 
                yield path
273
 
        elif context == 'site':
274
 
            for path in _get_site_plugin_paths(sys.path):
275
 
                if os.path.isdir(path):
276
 
                    yield path
277
 
 
278
 
 
279
 
def _install_importer_if_needed(plugin_details):
280
 
    """Install a meta path finder to handle plugin_details if any."""
281
 
    if plugin_details:
282
 
        finder = _PluginsAtFinder(_MODULE_PREFIX, plugin_details)
283
 
        # For Python 3, must insert before default PathFinder to override.
284
 
        sys.meta_path.insert(2, finder)
285
 
 
286
 
 
287
 
def _load_plugins_from_path(state, paths):
288
 
    """Do the importing all plugins from paths."""
289
 
    imported_names = set()
290
 
    for name, path in _iter_possible_plugins(paths):
291
 
        if name not in imported_names:
292
 
            msg = _load_plugin_module(name, path)
293
 
            if msg is not None:
294
 
                state.plugin_warnings.setdefault(name, []).append(msg)
295
 
            imported_names.add(name)
296
 
 
297
 
 
298
 
def _block_plugins(names):
299
 
    """Add names to sys.modules to block future imports."""
300
 
    for name in names:
301
 
        package_name = _MODULE_PREFIX + name
302
 
        if sys.modules.get(package_name) is not None:
303
 
            trace.mutter("Blocked plugin %s already loaded.", name)
304
 
        sys.modules[package_name] = None
305
 
 
306
 
 
307
 
def _get_package_init(package_path):
308
 
    """Get path of __init__ file from package_path or None if not a package."""
309
 
    init_path = osutils.pathjoin(package_path, "__init__.py")
310
 
    if os.path.exists(init_path):
311
 
        return init_path
312
 
    init_path = init_path[:-3] + COMPILED_EXT
313
 
    if os.path.exists(init_path):
314
 
        return init_path
315
 
    return None
316
 
 
317
 
 
318
 
def _iter_possible_plugins(plugin_paths):
319
 
    """Generate names and paths of possible plugins from plugin_paths."""
320
 
    # Inspect any from BRZ_PLUGINS_AT first.
321
 
    for name, path in getattr(plugin_paths, "extra_details", ()):
322
 
        yield name, path
323
 
    # Then walk over files and directories in the paths from the package.
324
 
    for path in plugin_paths:
325
 
        if os.path.isfile(path):
326
 
            if path.endswith(".zip"):
327
 
                trace.mutter("Don't yet support loading plugins from zip.")
328
 
        else:
329
 
            for name, path in _walk_modules(path):
330
 
                yield name, path
331
 
 
332
 
 
333
 
def _walk_modules(path):
334
 
    """Generate name and path of modules and packages on path."""
335
 
    for root, dirs, files in os.walk(path):
336
 
        files.sort()
337
 
        for f in files:
338
 
            if f[:2] != "__":
339
 
                if f.endswith((".py", COMPILED_EXT)):
340
 
                    yield f.rsplit(".", 1)[0], root
341
 
        dirs.sort()
342
 
        for d in dirs:
343
 
            if d[:2] != "__":
344
 
                package_dir = osutils.pathjoin(root, d)
345
 
                fullpath = _get_package_init(package_dir)
346
 
                if fullpath is not None:
347
 
                    yield d, package_dir
348
 
        # Don't descend into subdirectories
349
 
        del dirs[:]
350
 
 
351
 
 
352
 
def describe_plugins(show_paths=False, state=None):
353
 
    """Generate text description of plugins.
354
 
 
355
 
    Includes both those that have loaded, and those that failed to load.
356
 
 
357
 
    :param show_paths: If true, include the plugin path.
358
 
    :param state: The library state object to inspect.
359
 
    :returns: Iterator of text lines (including newlines.)
360
 
    """
361
 
    if state is None:
362
 
        state = breezy.get_global_state()
363
 
    loaded_plugins = getattr(state, 'plugins', {})
364
 
    plugin_warnings = set(getattr(state, 'plugin_warnings', []))
365
 
    all_names = sorted(set(loaded_plugins.keys()).union(plugin_warnings))
366
 
    for name in all_names:
367
 
        if name in loaded_plugins:
368
 
            plugin = loaded_plugins[name]
369
 
            version = plugin.__version__
370
 
            if version == 'unknown':
371
 
                version = ''
372
 
            yield '%s %s\n' % (name, version)
373
 
            d = plugin.module.__doc__
374
 
            if d:
375
 
                doc = d.split('\n')[0]
376
 
            else:
377
 
                doc = '(no description)'
378
 
            yield ("  %s\n" % doc)
379
 
            if show_paths:
380
 
                yield ("   %s\n" % plugin.path())
381
 
        else:
382
 
            yield "%s (failed to load)\n" % name
383
 
        if name in state.plugin_warnings:
384
 
            for line in state.plugin_warnings[name]:
385
 
                yield "  ** " + line + '\n'
386
 
        yield '\n'
387
 
 
388
 
 
389
 
def _get_core_plugin_paths(existing_paths):
390
 
    """Generate possible locations for plugins based on existing_paths."""
391
 
    if getattr(sys, 'frozen', False):
 
92
        path = get_standard_plugins_path()
 
93
    _mod_plugins.__path__ = path
 
94
    PluginImporter.reset()
 
95
    # Set up a blacklist for disabled plugins
 
96
    disabled_plugins = os.environ.get('BZR_DISABLE_PLUGINS', None)
 
97
    if disabled_plugins is not None:
 
98
        for name in disabled_plugins.split(os.pathsep):
 
99
            PluginImporter.blacklist.add('bzrlib.plugins.' + name)
 
100
    # Set up a the specific paths for plugins
 
101
    specific_plugins = os.environ.get('BZR_PLUGINS_AT', None)
 
102
    if specific_plugins is not None:
 
103
        for spec in specific_plugins.split(os.pathsep):
 
104
            plugin_name, plugin_path = spec.split('@')
 
105
            PluginImporter.specific_paths[
 
106
                'bzrlib.plugins.%s' % plugin_name] = plugin_path
 
107
    return path
 
108
 
 
109
 
 
110
def _append_new_path(paths, new_path):
 
111
    """Append a new path if it set and not already known."""
 
112
    if new_path is not None and new_path not in paths:
 
113
        paths.append(new_path)
 
114
    return paths
 
115
 
 
116
 
 
117
def get_core_plugin_path():
 
118
    core_path = None
 
119
    bzr_exe = bool(getattr(sys, 'frozen', None))
 
120
    if bzr_exe:    # expand path for bzr.exe
392
121
        # We need to use relative path to system-wide plugin
393
 
        # directory because breezy from standalone brz.exe
 
122
        # directory because bzrlib from standalone bzr.exe
394
123
        # could be imported by another standalone program
395
 
        # (e.g. brz-config; or TortoiseBzr/Olive if/when they
 
124
        # (e.g. bzr-config; or TortoiseBzr/Olive if/when they
396
125
        # will become standalone exe). [bialix 20071123]
397
126
        # __file__ typically is
398
 
        # C:\Program Files\Bazaar\lib\library.zip\breezy\plugin.pyc
 
127
        # C:\Program Files\Bazaar\lib\library.zip\bzrlib\plugin.pyc
399
128
        # then plugins directory is
400
129
        # C:\Program Files\Bazaar\plugins
401
130
        # so relative path is ../../../plugins
402
 
        yield osutils.abspath(osutils.pathjoin(
403
 
            osutils.dirname(__file__), '../../../plugins'))
 
131
        core_path = osutils.abspath(osutils.pathjoin(
 
132
                osutils.dirname(__file__), '../../../plugins'))
404
133
    else:     # don't look inside library.zip
405
 
        for path in existing_paths:
406
 
            yield path
407
 
 
408
 
 
409
 
def _get_site_plugin_paths(sys_paths):
410
 
    """Generate possible locations for plugins from given sys_paths."""
411
 
    for path in sys_paths:
412
 
        if os.path.basename(path) in ('dist-packages', 'site-packages'):
413
 
            yield osutils.pathjoin(path, 'breezy', 'plugins')
 
134
        # search the plugin path before the bzrlib installed dir
 
135
        core_path = os.path.dirname(_mod_plugins.__file__)
 
136
    return core_path
 
137
 
 
138
 
 
139
def get_site_plugin_path():
 
140
    """Returns the path for the site installed plugins."""
 
141
    if sys.platform == 'win32':
 
142
        # We don't have (yet) a good answer for windows since that is certainly
 
143
        # related to the way we build the installers. -- vila20090821
 
144
        return None
 
145
    site_path = None
 
146
    try:
 
147
        from distutils.sysconfig import get_python_lib
 
148
    except ImportError:
 
149
        # If distutuils is not available, we just don't know where they are
 
150
        pass
 
151
    else:
 
152
        site_path = osutils.pathjoin(get_python_lib(), 'bzrlib', 'plugins')
 
153
    return site_path
414
154
 
415
155
 
416
156
def get_user_plugin_path():
417
 
    return osutils.pathjoin(bedding.config_dir(), 'plugins')
418
 
 
419
 
 
420
 
def record_plugin_warning(warning_message):
421
 
    trace.mutter(warning_message)
422
 
    return warning_message
 
157
    return osutils.pathjoin(config.config_dir(), 'plugins')
 
158
 
 
159
 
 
160
def get_standard_plugins_path():
 
161
    """Determine a plugin path suitable for general use."""
 
162
    # Ad-Hoc default: core is not overriden by site but user can overrides both
 
163
    # The rationale is that:
 
164
    # - 'site' comes last, because these plugins should always be available and
 
165
    #   are supposed to be in sync with the bzr installed on site.
 
166
    # - 'core' comes before 'site' so that running bzr from sources or a user
 
167
    #   installed version overrides the site version.
 
168
    # - 'user' comes first, because... user is always right.
 
169
    # - the above rules clearly defines which plugin version will be loaded if
 
170
    #   several exist. Yet, it is sometimes desirable to disable some directory
 
171
    #   so that a set of plugins is disabled as once. This can be done via
 
172
    #   -site, -core, -user.
 
173
 
 
174
    env_paths = os.environ.get('BZR_PLUGIN_PATH', '+user').split(os.pathsep)
 
175
    defaults = ['+core', '+site']
 
176
 
 
177
    # The predefined references
 
178
    refs = dict(core=get_core_plugin_path(),
 
179
                site=get_site_plugin_path(),
 
180
                user=get_user_plugin_path())
 
181
 
 
182
    # Unset paths that should be removed
 
183
    for k,v in refs.iteritems():
 
184
        removed = '-%s' % k
 
185
        # defaults can never mention removing paths as that will make it
 
186
        # impossible for the user to revoke these removals.
 
187
        if removed in env_paths:
 
188
            env_paths.remove(removed)
 
189
            refs[k] = None
 
190
 
 
191
    # Expand references
 
192
    paths = []
 
193
    for p in env_paths + defaults:
 
194
        if p.startswith('+'):
 
195
            # Resolve references if they are known
 
196
            try:
 
197
                p = refs[p[1:]]
 
198
            except KeyError:
 
199
                # Leave them untouched so user can still use paths starting
 
200
                # with '+'
 
201
                pass
 
202
        _append_new_path(paths, p)
 
203
 
 
204
    # Get rid of trailing slashes, since Python can't handle them when
 
205
    # it tries to import modules.
 
206
    paths = map(_strip_trailing_sep, paths)
 
207
    return paths
 
208
 
 
209
 
 
210
def load_plugins(path=None):
 
211
    """Load bzrlib plugins.
 
212
 
 
213
    The environment variable BZR_PLUGIN_PATH is considered a delimited
 
214
    set of paths to look through. Each entry is searched for *.py
 
215
    files (and whatever other extensions are used in the platform,
 
216
    such as *.pyd).
 
217
 
 
218
    load_from_path() provides the underlying mechanism and is called with
 
219
    the default directory list to provide the normal behaviour.
 
220
 
 
221
    :param path: The list of paths to search for plugins.  By default,
 
222
        path will be determined using get_standard_plugins_path.
 
223
        if path is [], no plugins can be loaded.
 
224
    """
 
225
    global _loaded
 
226
    if _loaded:
 
227
        # People can make sure plugins are loaded, they just won't be twice
 
228
        return
 
229
    _loaded = True
 
230
 
 
231
    # scan for all plugins in the path.
 
232
    load_from_path(set_plugins_path(path))
 
233
 
 
234
 
 
235
def load_from_path(dirs):
 
236
    """Load bzrlib plugins found in each dir in dirs.
 
237
 
 
238
    Loading a plugin means importing it into the python interpreter.
 
239
    The plugin is expected to make calls to register commands when
 
240
    it's loaded (or perhaps access other hooks in future.)
 
241
 
 
242
    Plugins are loaded into bzrlib.plugins.NAME, and can be found there
 
243
    for future reference.
 
244
 
 
245
    The python module path for bzrlib.plugins will be modified to be 'dirs'.
 
246
    """
 
247
    # Explicitly load the plugins with a specific path
 
248
    for fullname, path in PluginImporter.specific_paths.iteritems():
 
249
        name = fullname[len('bzrlib.plugins.'):]
 
250
        _load_plugin_module(name, path)
 
251
 
 
252
    # We need to strip the trailing separators here as well as in the
 
253
    # set_plugins_path function because calling code can pass anything in to
 
254
    # this function, and since it sets plugins.__path__, it should set it to
 
255
    # something that will be valid for Python to use (in case people try to
 
256
    # run "import bzrlib.plugins.PLUGINNAME" after calling this function).
 
257
    _mod_plugins.__path__ = map(_strip_trailing_sep, dirs)
 
258
    for d in dirs:
 
259
        if not d:
 
260
            continue
 
261
        trace.mutter('looking for plugins in %s', d)
 
262
        if os.path.isdir(d):
 
263
            load_from_dir(d)
 
264
 
 
265
 
 
266
# backwards compatability: load_from_dirs was the old name
 
267
# This was changed in 0.15
 
268
load_from_dirs = load_from_path
 
269
 
 
270
 
 
271
def _find_plugin_module(dir, name):
 
272
    """Check if there is a valid python module that can be loaded as a plugin.
 
273
 
 
274
    :param dir: The directory where the search is performed.
 
275
    :param path: An existing file path, either a python file or a package
 
276
        directory.
 
277
 
 
278
    :return: (name, path, description) name is the module name, path is the
 
279
        file to load and description is the tuple returned by
 
280
        imp.get_suffixes().
 
281
    """
 
282
    path = osutils.pathjoin(dir, name)
 
283
    if os.path.isdir(path):
 
284
        # Check for a valid __init__.py file, valid suffixes depends on -O and
 
285
        # can be .py, .pyc and .pyo
 
286
        for suffix, mode, kind in imp.get_suffixes():
 
287
            if kind not in (imp.PY_SOURCE, imp.PY_COMPILED):
 
288
                # We don't recognize compiled modules (.so, .dll, etc)
 
289
                continue
 
290
            init_path = osutils.pathjoin(path, '__init__' + suffix)
 
291
            if os.path.isfile(init_path):
 
292
                return name, init_path, (suffix, mode, kind)
 
293
    else:
 
294
        for suffix, mode, kind in imp.get_suffixes():
 
295
            if name.endswith(suffix):
 
296
                # Clean up the module name
 
297
                name = name[:-len(suffix)]
 
298
                if kind == imp.C_EXTENSION and name.endswith('module'):
 
299
                    name = name[:-len('module')]
 
300
                return name, path, (suffix, mode, kind)
 
301
    # There is no python module here
 
302
    return None, None, (None, None, None)
423
303
 
424
304
 
425
305
def _load_plugin_module(name, dir):
426
 
    """Load plugin by name.
 
306
    """Load plugin name from dir.
427
307
 
428
 
    :param name: The plugin name in the breezy.plugins namespace.
 
308
    :param name: The plugin name in the bzrlib.plugins namespace.
429
309
    :param dir: The directory the plugin is loaded from for error messages.
430
310
    """
431
 
    if _MODULE_PREFIX + name in sys.modules:
 
311
    if ('bzrlib.plugins.%s' % name) in PluginImporter.blacklist:
432
312
        return
433
313
    try:
434
 
        __import__(_MODULE_PREFIX + name)
435
 
    except errors.IncompatibleVersion as e:
436
 
        warning_message = (
437
 
            "Unable to load plugin %r. It supports %s "
438
 
            "versions %r but the current version is %s" %
439
 
            (name, e.api.__name__, e.wanted, e.current))
440
 
        return record_plugin_warning(warning_message)
441
 
    except Exception as e:
 
314
        exec "import bzrlib.plugins.%s" % name in {}
 
315
    except KeyboardInterrupt:
 
316
        raise
 
317
    except errors.IncompatibleAPI, e:
 
318
        trace.warning("Unable to load plugin %r. It requested API version "
 
319
            "%s of module %s but the minimum exported version is %s, and "
 
320
            "the maximum is %s" %
 
321
            (name, e.wanted, e.api, e.minimum, e.current))
 
322
    except Exception, e:
 
323
        trace.warning("%s" % e)
 
324
        if re.search('\.|-| ', name):
 
325
            sanitised_name = re.sub('[-. ]', '_', name)
 
326
            if sanitised_name.startswith('bzr_'):
 
327
                sanitised_name = sanitised_name[len('bzr_'):]
 
328
            trace.warning("Unable to load %r in %r as a plugin because the "
 
329
                    "file path isn't a valid module name; try renaming "
 
330
                    "it to %r." % (name, dir, sanitised_name))
 
331
        else:
 
332
            trace.warning('Unable to load plugin %r from %r' % (name, dir))
442
333
        trace.log_exception_quietly()
443
334
        if 'error' in debug.debug_flags:
444
335
            trace.print_exception(sys.exc_info(), sys.stderr)
445
 
        # GZ 2017-06-02: Move this name checking up a level, no point trying
446
 
        # to import things with bad names.
447
 
        if re.search('\\.|-| ', name):
448
 
            sanitised_name = re.sub('[-. ]', '_', name)
449
 
            if sanitised_name.startswith('brz_'):
450
 
                sanitised_name = sanitised_name[len('brz_'):]
451
 
            trace.warning("Unable to load %r in %r as a plugin because the "
452
 
                          "file path isn't a valid module name; try renaming "
453
 
                          "it to %r." % (name, dir, sanitised_name))
454
 
        else:
455
 
            return record_plugin_warning(
456
 
                'Unable to load plugin %r from %r: %s' % (name, dir, e))
 
336
 
 
337
 
 
338
def load_from_dir(d):
 
339
    """Load the plugins in directory d.
 
340
 
 
341
    d must be in the plugins module path already.
 
342
    This function is called once for each directory in the module path.
 
343
    """
 
344
    plugin_names = set()
 
345
    for p in os.listdir(d):
 
346
        name, path, desc = _find_plugin_module(d, p)
 
347
        if name is not None:
 
348
            if name == '__init__':
 
349
                # We do nothing with the __init__.py file in directories from
 
350
                # the bzrlib.plugins module path, we may want to, one day
 
351
                # -- vila 20100316.
 
352
                continue # We don't load __init__.py in the plugins dirs
 
353
            elif getattr(_mod_plugins, name, None) is not None:
 
354
                # The module has already been loaded from another directory
 
355
                # during a previous call.
 
356
                # FIXME: There should be a better way to report masked plugins
 
357
                # -- vila 20100316
 
358
                trace.mutter('Plugin name %s already loaded', name)
 
359
            else:
 
360
                plugin_names.add(name)
 
361
 
 
362
    for name in plugin_names:
 
363
        _load_plugin_module(name, d)
457
364
 
458
365
 
459
366
def plugins():
462
369
    Each item in the dictionary is a PlugIn object.
463
370
    """
464
371
    result = {}
465
 
    for fullname in sys.modules:
466
 
        if fullname.startswith(_MODULE_PREFIX):
467
 
            name = fullname[len(_MODULE_PREFIX):]
468
 
            if "." not in name and sys.modules[fullname] is not None:
469
 
                result[name] = PlugIn(name, sys.modules[fullname])
 
372
    for name, plugin in _mod_plugins.__dict__.items():
 
373
        if isinstance(plugin, types.ModuleType):
 
374
            result[name] = PlugIn(name, plugin)
470
375
    return result
471
376
 
472
377
 
473
 
def get_loaded_plugin(name):
474
 
    """Retrieve an already loaded plugin.
475
 
 
476
 
    Returns None if there is no such plugin loaded
477
 
    """
478
 
    try:
479
 
        module = sys.modules[_MODULE_PREFIX + name]
480
 
    except KeyError:
481
 
        return None
482
 
    if module is None:
483
 
        return None
484
 
    return PlugIn(name, module)
485
 
 
486
 
 
487
 
def format_concise_plugin_list(state=None):
488
 
    """Return a string holding a concise list of plugins and their version.
489
 
    """
490
 
    if state is None:
491
 
        state = breezy.get_global_state()
492
 
    items = []
493
 
    for name, a_plugin in sorted(getattr(state, 'plugins', {}).items()):
494
 
        items.append("%s[%s]" %
495
 
                     (name, a_plugin.__version__))
496
 
    return ', '.join(items)
497
 
 
498
 
 
499
378
class PluginsHelpIndex(object):
500
379
    """A help index that returns help topics for plugins."""
501
380
 
515
394
            return []
516
395
        if topic.startswith(self.prefix):
517
396
            topic = topic[len(self.prefix):]
518
 
        plugin_module_name = _MODULE_PREFIX + topic
 
397
        plugin_module_name = 'bzrlib.plugins.%s' % topic
519
398
        try:
520
399
            module = sys.modules[plugin_module_name]
521
400
        except KeyError:
546
425
            result = self.module.__doc__
547
426
        if result[-1] != '\n':
548
427
            result += '\n'
549
 
        result += help_topics._format_see_also(additional_see_also)
 
428
        # there is code duplicated here and in bzrlib/help_topic.py's
 
429
        # matching Topic code. This should probably be factored in
 
430
        # to a helper function and a common base class.
 
431
        if additional_see_also is not None:
 
432
            see_also = sorted(set(additional_see_also))
 
433
        else:
 
434
            see_also = None
 
435
        if see_also:
 
436
            result += 'See also: '
 
437
            result += ', '.join(see_also)
 
438
            result += '\n'
550
439
        return result
551
440
 
552
441
    def get_help_topic(self):
553
 
        """Return the module help topic: its basename."""
554
 
        return self.module.__name__[len(_MODULE_PREFIX):]
 
442
        """Return the modules help topic - its __name__ after bzrlib.plugins.."""
 
443
        return self.module.__name__[len('bzrlib.plugins.'):]
555
444
 
556
445
 
557
446
class PlugIn(object):
558
 
    """The breezy representation of a plugin.
 
447
    """The bzrlib representation of a plugin.
559
448
 
560
449
    The PlugIn object provides a way to manipulate a given plugin module.
561
450
    """
571
460
            return os.path.abspath(self.module.__path__[0])
572
461
        elif getattr(self.module, '__file__', None) is not None:
573
462
            path = os.path.abspath(self.module.__file__)
574
 
            if path[-4:] == COMPILED_EXT:
 
463
            if path[-4:] in ('.pyc', '.pyo'):
575
464
                pypath = path[:-4] + '.py'
576
465
                if os.path.isfile(pypath):
577
466
                    path = pypath
579
468
        else:
580
469
            return repr(self.module)
581
470
 
582
 
    def __repr__(self):
583
 
        return "<%s.%s name=%s, module=%s>" % (
584
 
            self.__class__.__module__, self.__class__.__name__,
 
471
    def __str__(self):
 
472
        return "<%s.%s object at %s, name=%s, module=%s>" % (
 
473
            self.__class__.__module__, self.__class__.__name__, id(self),
585
474
            self.name, self.module)
586
475
 
 
476
    __repr__ = __str__
 
477
 
587
478
    def test_suite(self):
588
479
        """Return the plugin's test suite."""
589
480
        if getattr(self.module, 'test_suite', None) is not None:
596
487
 
597
488
        :param loader: The custom loader that should be used to load additional
598
489
            tests.
 
490
 
599
491
        """
600
492
        if getattr(self.module, 'load_tests', None) is not None:
601
493
            return loader.loadTestsFromModule(self.module)
607
499
        version_info = getattr(self.module, 'version_info', None)
608
500
        if version_info is not None:
609
501
            try:
610
 
                if isinstance(version_info, str):
 
502
                if isinstance(version_info, types.StringType):
611
503
                    version_info = version_info.split('.')
612
504
                elif len(version_info) == 3:
613
505
                    version_info = tuple(version_info) + ('final', 0)
614
 
            except TypeError:
 
506
            except TypeError, e:
615
507
                # The given version_info isn't even iteratible
616
508
                trace.log_exception_quietly()
617
509
                version_info = (version_info,)
618
510
        return version_info
619
511
 
620
 
    @property
621
 
    def __version__(self):
 
512
    def _get__version__(self):
622
513
        version_info = self.version_info()
623
514
        if version_info is None or len(version_info) == 0:
624
515
            return "unknown"
625
516
        try:
626
 
            version_string = breezy._format_version_tuple(version_info)
627
 
        except (ValueError, TypeError, IndexError):
 
517
            version_string = _format_version_tuple(version_info)
 
518
        except (ValueError, TypeError, IndexError), e:
628
519
            trace.log_exception_quietly()
629
 
            # Try to show something for the version anyway
 
520
            # try to return something usefull for bad plugins, in stead of
 
521
            # stack tracing.
630
522
            version_string = '.'.join(map(str, version_info))
631
523
        return version_string
632
524
 
633
 
 
634
 
class _PluginsAtFinder(object):
635
 
    """Meta path finder to support BRZ_PLUGINS_AT configuration."""
636
 
 
637
 
    def __init__(self, prefix, names_and_paths):
638
 
        self.prefix = prefix
639
 
        self.names_to_path = dict((prefix + n, p) for n, p in names_and_paths)
640
 
 
641
 
    def __repr__(self):
642
 
        return "<%s %r>" % (self.__class__.__name__, self.prefix)
643
 
 
644
 
    def find_spec(self, fullname, paths, target=None):
645
 
        """New module spec returning find method."""
646
 
        if fullname not in self.names_to_path:
647
 
            return None
648
 
        path = self.names_to_path[fullname]
649
 
        if os.path.isdir(path):
650
 
            path = _get_package_init(path)
651
 
            if path is None:
652
 
                # GZ 2017-06-02: Any reason to block loading of the name from
653
 
                # further down the path like this?
654
 
                raise ImportError("Not loading namespace package %s as %s" % (
655
 
                    path, fullname))
656
 
        return importlib_util.spec_from_file_location(fullname, path)
657
 
 
658
 
    def find_module(self, fullname, path):
659
 
        """Old PEP 302 import hook find_module method."""
660
 
        if fullname not in self.names_to_path:
661
 
            return None
662
 
        return _LegacyLoader(self.names_to_path[fullname])
663
 
 
664
 
 
665
 
class _LegacyLoader(object):
666
 
    """Source loader implementation for Python versions without importlib."""
667
 
 
668
 
    def __init__(self, filepath):
669
 
        self.filepath = filepath
670
 
 
671
 
    def __repr__(self):
672
 
        return "<%s %r>" % (self.__class__.__name__, self.filepath)
 
525
    __version__ = property(_get__version__)
 
526
 
 
527
 
 
528
class _PluginImporter(object):
 
529
    """An importer tailored to bzr specific needs.
 
530
 
 
531
    This is a singleton that takes care of:
 
532
    - disabled plugins specified in 'blacklist',
 
533
    - plugins that needs to be loaded from specific directories.
 
534
    """
 
535
 
 
536
    def __init__(self):
 
537
        self.reset()
 
538
 
 
539
    def reset(self):
 
540
        self.blacklist = set()
 
541
        self.specific_paths = {}
 
542
 
 
543
    def find_module(self, fullname, parent_path=None):
 
544
        """Search a plugin module.
 
545
 
 
546
        Disabled plugins raise an import error, plugins with specific paths
 
547
        returns a specific loader.
 
548
 
 
549
        :return: None if the plugin doesn't need special handling, self
 
550
            otherwise.
 
551
        """
 
552
        if not fullname.startswith('bzrlib.plugins.'):
 
553
            return None
 
554
        if fullname in self.blacklist:
 
555
            raise ImportError('%s is disabled' % fullname)
 
556
        if fullname in self.specific_paths:
 
557
            return self
 
558
        return None
673
559
 
674
560
    def load_module(self, fullname):
675
 
        """Load a plugin from a specific directory (or file)."""
676
 
        plugin_path = self.filepath
 
561
        """Load a plugin from a specific directory."""
 
562
        # We are called only for specific paths
 
563
        plugin_path = self.specific_paths[fullname]
677
564
        loading_path = None
 
565
        package = False
678
566
        if os.path.isdir(plugin_path):
679
 
            init_path = _get_package_init(plugin_path)
680
 
            if init_path is not None:
681
 
                loading_path = plugin_path
682
 
                suffix = ''
683
 
                mode = ''
684
 
                kind = imp.PKG_DIRECTORY
 
567
            for suffix, mode, kind in imp.get_suffixes():
 
568
                if kind not in (imp.PY_SOURCE, imp.PY_COMPILED):
 
569
                    # We don't recognize compiled modules (.so, .dll, etc)
 
570
                    continue
 
571
                init_path = osutils.pathjoin(plugin_path, '__init__' + suffix)
 
572
                if os.path.isfile(init_path):
 
573
                    loading_path = init_path
 
574
                    package = True
 
575
                    break
685
576
        else:
686
577
            for suffix, mode, kind in imp.get_suffixes():
687
578
                if plugin_path.endswith(suffix):
690
581
        if loading_path is None:
691
582
            raise ImportError('%s cannot be loaded from %s'
692
583
                              % (fullname, plugin_path))
693
 
        if kind is imp.PKG_DIRECTORY:
694
 
            f = None
695
 
        else:
696
 
            f = open(loading_path, mode)
 
584
        f = open(loading_path, mode)
697
585
        try:
698
586
            mod = imp.load_module(fullname, f, loading_path,
699
587
                                  (suffix, mode, kind))
 
588
            if package:
 
589
                # The plugin can contain modules, so be ready
 
590
                mod.__path__ = [plugin_path]
700
591
            mod.__package__ = fullname
701
592
            return mod
702
593
        finally:
703
 
            if f is not None:
704
 
                f.close()
 
594
            f.close()
 
595
 
 
596
 
 
597
# Install a dedicated importer for plugins requiring special handling
 
598
PluginImporter = _PluginImporter()
 
599
sys.meta_path.append(PluginImporter)