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

  • Committer: Jelmer Vernooij
  • Date: 2020-09-02 16:35:18 UTC
  • mto: (7490.40.109 work)
  • mto: This revision was merged to the branch mainline in revision 7526.
  • Revision ID: jelmer@jelmer.uk-20200902163518-sy9f4unbboljphgu
Handle duplicate directories entries for git.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/plugin.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd, 2017 Breezy developers
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
 
 
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.
 
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.
24
32
 
25
33
See the plugin-api developer documentation for information about writing
26
34
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.
31
35
"""
32
36
 
 
37
from __future__ import absolute_import
 
38
 
33
39
import os
 
40
import re
34
41
import sys
35
42
 
36
 
from bzrlib import osutils
37
 
 
38
 
from bzrlib.lazy_import import lazy_import
39
 
 
 
43
import breezy
 
44
from . import osutils
 
45
 
 
46
from .lazy_import import lazy_import
40
47
lazy_import(globals(), """
41
48
import imp
42
 
import re
43
 
import types
 
49
from importlib import util as importlib_util
44
50
 
45
 
from bzrlib import (
46
 
    _format_version_tuple,
47
 
    config,
 
51
from breezy import (
 
52
    bedding,
48
53
    debug,
49
 
    errors,
 
54
    help_topics,
50
55
    trace,
51
56
    )
52
 
from bzrlib import plugins as _mod_plugins
53
57
""")
54
58
 
55
 
from bzrlib.symbol_versioning import (
56
 
    deprecated_function,
57
 
    deprecated_in,
 
59
from . import (
 
60
    errors,
58
61
    )
59
62
 
60
63
 
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():
 
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):
71
73
    """Disable loading plugins.
72
74
 
73
75
    Future calls to load_plugins() will be ignored.
 
76
 
 
77
    :param state: The library state object that records loaded plugins.
74
78
    """
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.
 
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`).
86
91
 
87
92
    :param path: The list of paths to search for plugins.  By default,
88
 
        path will be determined using get_standard_plugins_path.
89
 
        if path is [], no plugins can be loaded.
 
93
        it is populated from the __path__ of the breezy.plugins package.
 
94
    :param state: The library state object that records loaded plugins.
90
95
    """
 
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
 
91
102
    if path is None:
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
 
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):
121
392
        # We need to use relative path to system-wide plugin
122
 
        # directory because bzrlib from standalone bzr.exe
 
393
        # directory because breezy from standalone brz.exe
123
394
        # could be imported by another standalone program
124
 
        # (e.g. bzr-config; or TortoiseBzr/Olive if/when they
 
395
        # (e.g. brz-config; or TortoiseBzr/Olive if/when they
125
396
        # will become standalone exe). [bialix 20071123]
126
397
        # __file__ typically is
127
 
        # C:\Program Files\Bazaar\lib\library.zip\bzrlib\plugin.pyc
 
398
        # C:\Program Files\Bazaar\lib\library.zip\breezy\plugin.pyc
128
399
        # then plugins directory is
129
400
        # C:\Program Files\Bazaar\plugins
130
401
        # so relative path is ../../../plugins
131
 
        core_path = osutils.abspath(osutils.pathjoin(
132
 
                osutils.dirname(__file__), '../../../plugins'))
 
402
        yield osutils.abspath(osutils.pathjoin(
 
403
            osutils.dirname(__file__), '../../../plugins'))
133
404
    else:     # don't look inside library.zip
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
 
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')
154
414
 
155
415
 
156
416
def get_user_plugin_path():
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)
 
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
303
423
 
304
424
 
305
425
def _load_plugin_module(name, dir):
306
 
    """Load plugin name from dir.
 
426
    """Load plugin by name.
307
427
 
308
 
    :param name: The plugin name in the bzrlib.plugins namespace.
 
428
    :param name: The plugin name in the breezy.plugins namespace.
309
429
    :param dir: The directory the plugin is loaded from for error messages.
310
430
    """
311
 
    if ('bzrlib.plugins.%s' % name) in PluginImporter.blacklist:
 
431
    if _MODULE_PREFIX + name in sys.modules:
312
432
        return
313
433
    try:
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))
 
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:
333
442
        trace.log_exception_quietly()
334
443
        if 'error' in debug.debug_flags:
335
444
            trace.print_exception(sys.exc_info(), sys.stderr)
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)
 
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))
364
457
 
365
458
 
366
459
def plugins():
369
462
    Each item in the dictionary is a PlugIn object.
370
463
    """
371
464
    result = {}
372
 
    for name, plugin in _mod_plugins.__dict__.items():
373
 
        if isinstance(plugin, types.ModuleType):
374
 
            result[name] = PlugIn(name, plugin)
 
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])
375
470
    return result
376
471
 
377
472
 
 
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
 
378
499
class PluginsHelpIndex(object):
379
500
    """A help index that returns help topics for plugins."""
380
501
 
394
515
            return []
395
516
        if topic.startswith(self.prefix):
396
517
            topic = topic[len(self.prefix):]
397
 
        plugin_module_name = 'bzrlib.plugins.%s' % topic
 
518
        plugin_module_name = _MODULE_PREFIX + topic
398
519
        try:
399
520
            module = sys.modules[plugin_module_name]
400
521
        except KeyError:
425
546
            result = self.module.__doc__
426
547
        if result[-1] != '\n':
427
548
            result += '\n'
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'
 
549
        result += help_topics._format_see_also(additional_see_also)
439
550
        return result
440
551
 
441
552
    def get_help_topic(self):
442
 
        """Return the modules help topic - its __name__ after bzrlib.plugins.."""
443
 
        return self.module.__name__[len('bzrlib.plugins.'):]
 
553
        """Return the module help topic: its basename."""
 
554
        return self.module.__name__[len(_MODULE_PREFIX):]
444
555
 
445
556
 
446
557
class PlugIn(object):
447
 
    """The bzrlib representation of a plugin.
 
558
    """The breezy representation of a plugin.
448
559
 
449
560
    The PlugIn object provides a way to manipulate a given plugin module.
450
561
    """
460
571
            return os.path.abspath(self.module.__path__[0])
461
572
        elif getattr(self.module, '__file__', None) is not None:
462
573
            path = os.path.abspath(self.module.__file__)
463
 
            if path[-4:] in ('.pyc', '.pyo'):
 
574
            if path[-4:] == COMPILED_EXT:
464
575
                pypath = path[:-4] + '.py'
465
576
                if os.path.isfile(pypath):
466
577
                    path = pypath
468
579
        else:
469
580
            return repr(self.module)
470
581
 
471
 
    def __str__(self):
472
 
        return "<%s.%s object at %s, name=%s, module=%s>" % (
473
 
            self.__class__.__module__, self.__class__.__name__, id(self),
 
582
    def __repr__(self):
 
583
        return "<%s.%s name=%s, module=%s>" % (
 
584
            self.__class__.__module__, self.__class__.__name__,
474
585
            self.name, self.module)
475
586
 
476
 
    __repr__ = __str__
477
 
 
478
587
    def test_suite(self):
479
588
        """Return the plugin's test suite."""
480
589
        if getattr(self.module, 'test_suite', None) is not None:
487
596
 
488
597
        :param loader: The custom loader that should be used to load additional
489
598
            tests.
490
 
 
491
599
        """
492
600
        if getattr(self.module, 'load_tests', None) is not None:
493
601
            return loader.loadTestsFromModule(self.module)
499
607
        version_info = getattr(self.module, 'version_info', None)
500
608
        if version_info is not None:
501
609
            try:
502
 
                if isinstance(version_info, types.StringType):
 
610
                if isinstance(version_info, str):
503
611
                    version_info = version_info.split('.')
504
612
                elif len(version_info) == 3:
505
613
                    version_info = tuple(version_info) + ('final', 0)
506
 
            except TypeError, e:
 
614
            except TypeError:
507
615
                # The given version_info isn't even iteratible
508
616
                trace.log_exception_quietly()
509
617
                version_info = (version_info,)
510
618
        return version_info
511
619
 
512
 
    def _get__version__(self):
 
620
    @property
 
621
    def __version__(self):
513
622
        version_info = self.version_info()
514
623
        if version_info is None or len(version_info) == 0:
515
624
            return "unknown"
516
625
        try:
517
 
            version_string = _format_version_tuple(version_info)
518
 
        except (ValueError, TypeError, IndexError), e:
 
626
            version_string = breezy._format_version_tuple(version_info)
 
627
        except (ValueError, TypeError, IndexError):
519
628
            trace.log_exception_quietly()
520
 
            # try to return something usefull for bad plugins, in stead of
521
 
            # stack tracing.
 
629
            # Try to show something for the version anyway
522
630
            version_string = '.'.join(map(str, version_info))
523
631
        return version_string
524
632
 
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
 
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)
559
673
 
560
674
    def load_module(self, fullname):
561
 
        """Load a plugin from a specific directory."""
562
 
        # We are called only for specific paths
563
 
        plugin_path = self.specific_paths[fullname]
 
675
        """Load a plugin from a specific directory (or file)."""
 
676
        plugin_path = self.filepath
564
677
        loading_path = None
565
 
        package = False
566
678
        if os.path.isdir(plugin_path):
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
 
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
576
685
        else:
577
686
            for suffix, mode, kind in imp.get_suffixes():
578
687
                if plugin_path.endswith(suffix):
581
690
        if loading_path is None:
582
691
            raise ImportError('%s cannot be loaded from %s'
583
692
                              % (fullname, plugin_path))
584
 
        f = open(loading_path, mode)
 
693
        if kind is imp.PKG_DIRECTORY:
 
694
            f = None
 
695
        else:
 
696
            f = open(loading_path, mode)
585
697
        try:
586
698
            mod = imp.load_module(fullname, f, loading_path,
587
699
                                  (suffix, mode, kind))
588
 
            if package:
589
 
                # The plugin can contain modules, so be ready
590
 
                mod.__path__ = [plugin_path]
591
700
            mod.__package__ = fullname
592
701
            return mod
593
702
        finally:
594
 
            f.close()
595
 
 
596
 
 
597
 
# Install a dedicated importer for plugins requiring special handling
598
 
PluginImporter = _PluginImporter()
599
 
sys.meta_path.append(PluginImporter)
 
703
            if f is not None:
 
704
                f.close()