/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: John Ferlito
  • Date: 2009-09-02 04:31:45 UTC
  • mto: (4665.7.1 serve-init)
  • mto: This revision was merged to the branch mainline in revision 4913.
  • Revision ID: johnf@inodes.org-20090902043145-gxdsfw03ilcwbyn5
Add a debian init script for bzr --serve

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