1
# Copyright (C) 2005-2011 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
"""bzr python plugin support.
19
When load_plugins() is invoked, any python module in any directory in
20
$BZR_PLUGIN_PATH will be imported. The module will be imported as
21
'bzrlib.plugins.$BASENAME(PLUGIN)'. In the plugin's main body, it should
22
update any bzrlib registries it wants to extend.
24
See the plugin-api developer documentation for information about writing
27
BZR_PLUGIN_PATH is also honoured for any plugins imported via
28
'import bzrlib.plugins.PLUGINNAME', as long as set_plugins_path has been
32
from __future__ import absolute_import
37
from bzrlib import osutils
39
from bzrlib.lazy_import import lazy_import
40
lazy_import(globals(), """
46
_format_version_tuple,
52
from bzrlib.i18n import gettext
53
from bzrlib import plugins as _mod_plugins
57
DEFAULT_PLUGIN_PATH = None
59
_plugins_disabled = False
63
# Map from plugin name, to list of string warnings about eg plugin
67
def are_plugins_disabled():
68
return _plugins_disabled
71
def disable_plugins():
72
"""Disable loading plugins.
74
Future calls to load_plugins() will be ignored.
76
global _plugins_disabled
77
_plugins_disabled = True
81
def describe_plugins(show_paths=False):
82
"""Generate text description of plugins.
84
Includes both those that have loaded, and those that failed to
87
:param show_paths: If true,
88
:returns: Iterator of text lines (including newlines.)
90
from inspect import getdoc
91
loaded_plugins = plugins()
92
all_names = sorted(list(set(
93
loaded_plugins.keys() + plugin_warnings.keys())))
94
for name in all_names:
95
if name in loaded_plugins:
96
plugin = loaded_plugins[name]
97
version = plugin.__version__
98
if version == 'unknown':
100
yield '%s %s\n' % (name, version)
101
d = getdoc(plugin.module)
103
doc = d.split('\n')[0]
105
doc = '(no description)'
106
yield (" %s\n" % doc)
108
yield (" %s\n" % plugin.path())
111
yield "%s (failed to load)\n" % name
112
if name in plugin_warnings:
113
for line in plugin_warnings[name]:
114
yield " ** " + line + '\n'
118
def _strip_trailing_sep(path):
119
return path.rstrip("\\/")
122
def _get_specific_plugin_paths(paths):
123
"""Returns the plugin paths from a string describing the associations.
125
:param paths: A string describing the paths associated with the plugins.
127
:returns: A list of (plugin name, path) tuples.
129
For example, if paths is my_plugin@/test/my-test:her_plugin@/production/her,
130
[('my_plugin', '/test/my-test'), ('her_plugin', '/production/her')]
133
Note that ':' in the example above depends on the os.
138
for spec in paths.split(os.pathsep):
140
name, path = spec.split('@')
142
raise errors.BzrCommandError(gettext(
143
'"%s" is not a valid <plugin_name>@<plugin_path> description ')
145
specs.append((name, path))
149
def set_plugins_path(path=None):
150
"""Set the path for plugins to be loaded from.
152
:param path: The list of paths to search for plugins. By default,
153
path will be determined using get_standard_plugins_path.
154
if path is [], no plugins can be loaded.
157
path = get_standard_plugins_path()
158
_mod_plugins.__path__ = path
159
PluginImporter.reset()
160
# Set up a blacklist for disabled plugins
161
disabled_plugins = os.environ.get('BZR_DISABLE_PLUGINS', None)
162
if disabled_plugins is not None:
163
for name in disabled_plugins.split(os.pathsep):
164
PluginImporter.blacklist.add('bzrlib.plugins.' + name)
165
# Set up a the specific paths for plugins
166
for plugin_name, plugin_path in _get_specific_plugin_paths(os.environ.get(
167
'BZR_PLUGINS_AT', None)):
168
PluginImporter.specific_paths[
169
'bzrlib.plugins.%s' % plugin_name] = plugin_path
173
def _append_new_path(paths, new_path):
174
"""Append a new path if it set and not already known."""
175
if new_path is not None and new_path not in paths:
176
paths.append(new_path)
180
def get_core_plugin_path():
182
bzr_exe = bool(getattr(sys, 'frozen', None))
183
if bzr_exe: # expand path for bzr.exe
184
# We need to use relative path to system-wide plugin
185
# directory because bzrlib from standalone bzr.exe
186
# could be imported by another standalone program
187
# (e.g. bzr-config; or TortoiseBzr/Olive if/when they
188
# will become standalone exe). [bialix 20071123]
189
# __file__ typically is
190
# C:\Program Files\Bazaar\lib\library.zip\bzrlib\plugin.pyc
191
# then plugins directory is
192
# C:\Program Files\Bazaar\plugins
193
# so relative path is ../../../plugins
194
core_path = osutils.abspath(osutils.pathjoin(
195
osutils.dirname(__file__), '../../../plugins'))
196
else: # don't look inside library.zip
197
# search the plugin path before the bzrlib installed dir
198
core_path = os.path.dirname(_mod_plugins.__file__)
202
def get_site_plugin_path():
203
"""Returns the path for the site installed plugins."""
204
if sys.platform == 'win32':
205
# We don't have (yet) a good answer for windows since that is certainly
206
# related to the way we build the installers. -- vila20090821
210
from distutils.sysconfig import get_python_lib
212
# If distutuils is not available, we just don't know where they are
215
site_path = osutils.pathjoin(get_python_lib(), 'bzrlib', 'plugins')
219
def get_user_plugin_path():
220
return osutils.pathjoin(config.config_dir(), 'plugins')
223
def get_standard_plugins_path():
224
"""Determine a plugin path suitable for general use."""
225
# Ad-Hoc default: core is not overriden by site but user can overrides both
226
# The rationale is that:
227
# - 'site' comes last, because these plugins should always be available and
228
# are supposed to be in sync with the bzr installed on site.
229
# - 'core' comes before 'site' so that running bzr from sources or a user
230
# installed version overrides the site version.
231
# - 'user' comes first, because... user is always right.
232
# - the above rules clearly defines which plugin version will be loaded if
233
# several exist. Yet, it is sometimes desirable to disable some directory
234
# so that a set of plugins is disabled as once. This can be done via
235
# -site, -core, -user.
237
env_paths = os.environ.get('BZR_PLUGIN_PATH', '+user').split(os.pathsep)
238
defaults = ['+core', '+site']
240
# The predefined references
241
refs = dict(core=get_core_plugin_path(),
242
site=get_site_plugin_path(),
243
user=get_user_plugin_path())
245
# Unset paths that should be removed
246
for k,v in refs.iteritems():
248
# defaults can never mention removing paths as that will make it
249
# impossible for the user to revoke these removals.
250
if removed in env_paths:
251
env_paths.remove(removed)
256
for p in env_paths + defaults:
257
if p.startswith('+'):
258
# Resolve references if they are known
262
# Leave them untouched so user can still use paths starting
265
_append_new_path(paths, p)
267
# Get rid of trailing slashes, since Python can't handle them when
268
# it tries to import modules.
269
paths = map(_strip_trailing_sep, paths)
273
def load_plugins(path=None):
274
"""Load bzrlib plugins.
276
The environment variable BZR_PLUGIN_PATH is considered a delimited
277
set of paths to look through. Each entry is searched for `*.py`
278
files (and whatever other extensions are used in the platform,
281
load_from_path() provides the underlying mechanism and is called with
282
the default directory list to provide the normal behaviour.
284
:param path: The list of paths to search for plugins. By default,
285
path will be determined using get_standard_plugins_path.
286
if path is [], no plugins can be loaded.
290
# People can make sure plugins are loaded, they just won't be twice
294
# scan for all plugins in the path.
295
load_from_path(set_plugins_path(path))
298
def load_from_path(dirs):
299
"""Load bzrlib plugins found in each dir in dirs.
301
Loading a plugin means importing it into the python interpreter.
302
The plugin is expected to make calls to register commands when
303
it's loaded (or perhaps access other hooks in future.)
305
Plugins are loaded into bzrlib.plugins.NAME, and can be found there
306
for future reference.
308
The python module path for bzrlib.plugins will be modified to be 'dirs'.
310
# Explicitly load the plugins with a specific path
311
for fullname, path in PluginImporter.specific_paths.iteritems():
312
name = fullname[len('bzrlib.plugins.'):]
313
_load_plugin_module(name, path)
315
# We need to strip the trailing separators here as well as in the
316
# set_plugins_path function because calling code can pass anything in to
317
# this function, and since it sets plugins.__path__, it should set it to
318
# something that will be valid for Python to use (in case people try to
319
# run "import bzrlib.plugins.PLUGINNAME" after calling this function).
320
_mod_plugins.__path__ = map(_strip_trailing_sep, dirs)
324
trace.mutter('looking for plugins in %s', d)
329
# backwards compatability: load_from_dirs was the old name
330
# This was changed in 0.15
331
load_from_dirs = load_from_path
334
def _find_plugin_module(dir, name):
335
"""Check if there is a valid python module that can be loaded as a plugin.
337
:param dir: The directory where the search is performed.
338
:param path: An existing file path, either a python file or a package
341
:return: (name, path, description) name is the module name, path is the
342
file to load and description is the tuple returned by
345
path = osutils.pathjoin(dir, name)
346
if os.path.isdir(path):
347
# Check for a valid __init__.py file, valid suffixes depends on -O and
348
# can be .py, .pyc and .pyo
349
for suffix, mode, kind in imp.get_suffixes():
350
if kind not in (imp.PY_SOURCE, imp.PY_COMPILED):
351
# We don't recognize compiled modules (.so, .dll, etc)
353
init_path = osutils.pathjoin(path, '__init__' + suffix)
354
if os.path.isfile(init_path):
355
return name, init_path, (suffix, mode, kind)
357
for suffix, mode, kind in imp.get_suffixes():
358
if name.endswith(suffix):
359
# Clean up the module name
360
name = name[:-len(suffix)]
361
if kind == imp.C_EXTENSION and name.endswith('module'):
362
name = name[:-len('module')]
363
return name, path, (suffix, mode, kind)
364
# There is no python module here
365
return None, None, (None, None, None)
368
def record_plugin_warning(plugin_name, warning_message):
369
trace.mutter(warning_message)
370
plugin_warnings.setdefault(plugin_name, []).append(warning_message)
373
def _load_plugin_module(name, dir):
374
"""Load plugin name from dir.
376
:param name: The plugin name in the bzrlib.plugins namespace.
377
:param dir: The directory the plugin is loaded from for error messages.
379
if ('bzrlib.plugins.%s' % name) in PluginImporter.blacklist:
382
exec "import bzrlib.plugins.%s" % name in {}
383
except KeyboardInterrupt:
385
except errors.IncompatibleAPI, e:
387
"Unable to load plugin %r. It requested API version "
388
"%s of module %s but the minimum exported version is %s, and "
389
"the maximum is %s" %
390
(name, e.wanted, e.api, e.minimum, e.current))
391
record_plugin_warning(name, warning_message)
393
trace.warning("%s" % e)
394
if re.search('\.|-| ', name):
395
sanitised_name = re.sub('[-. ]', '_', name)
396
if sanitised_name.startswith('bzr_'):
397
sanitised_name = sanitised_name[len('bzr_'):]
398
trace.warning("Unable to load %r in %r as a plugin because the "
399
"file path isn't a valid module name; try renaming "
400
"it to %r." % (name, dir, sanitised_name))
402
record_plugin_warning(
404
'Unable to load plugin %r from %r' % (name, dir))
405
trace.log_exception_quietly()
406
if 'error' in debug.debug_flags:
407
trace.print_exception(sys.exc_info(), sys.stderr)
410
def load_from_dir(d):
411
"""Load the plugins in directory d.
413
d must be in the plugins module path already.
414
This function is called once for each directory in the module path.
417
for p in os.listdir(d):
418
name, path, desc = _find_plugin_module(d, p)
420
if name == '__init__':
421
# We do nothing with the __init__.py file in directories from
422
# the bzrlib.plugins module path, we may want to, one day
424
continue # We don't load __init__.py in the plugins dirs
425
elif getattr(_mod_plugins, name, None) is not None:
426
# The module has already been loaded from another directory
427
# during a previous call.
428
# FIXME: There should be a better way to report masked plugins
430
trace.mutter('Plugin name %s already loaded', name)
432
plugin_names.add(name)
434
for name in plugin_names:
435
_load_plugin_module(name, d)
439
"""Return a dictionary of the plugins.
441
Each item in the dictionary is a PlugIn object.
444
for name, plugin in _mod_plugins.__dict__.items():
445
if isinstance(plugin, types.ModuleType):
446
result[name] = PlugIn(name, plugin)
450
def format_concise_plugin_list():
451
"""Return a string holding a concise list of plugins and their version.
454
for name, a_plugin in sorted(plugins().items()):
455
items.append("%s[%s]" %
456
(name, a_plugin.__version__))
457
return ', '.join(items)
461
class PluginsHelpIndex(object):
462
"""A help index that returns help topics for plugins."""
465
self.prefix = 'plugins/'
467
def get_topics(self, topic):
468
"""Search for topic in the loaded plugins.
470
This will not trigger loading of new plugins.
472
:param topic: A topic to search for.
473
:return: A list which is either empty or contains a single
474
RegisteredTopic entry.
478
if topic.startswith(self.prefix):
479
topic = topic[len(self.prefix):]
480
plugin_module_name = 'bzrlib.plugins.%s' % topic
482
module = sys.modules[plugin_module_name]
486
return [ModuleHelpTopic(module)]
489
class ModuleHelpTopic(object):
490
"""A help topic which returns the docstring for a module."""
492
def __init__(self, module):
495
:param module: The module for which help should be generated.
499
def get_help_text(self, additional_see_also=None, verbose=True):
500
"""Return a string with the help for this topic.
502
:param additional_see_also: Additional help topics to be
505
if not self.module.__doc__:
506
result = "Plugin '%s' has no docstring.\n" % self.module.__name__
508
result = self.module.__doc__
509
if result[-1] != '\n':
511
from bzrlib import help_topics
512
result += help_topics._format_see_also(additional_see_also)
515
def get_help_topic(self):
516
"""Return the module help topic: its basename."""
517
return self.module.__name__[len('bzrlib.plugins.'):]
520
class PlugIn(object):
521
"""The bzrlib representation of a plugin.
523
The PlugIn object provides a way to manipulate a given plugin module.
526
def __init__(self, name, module):
527
"""Construct a plugin for module."""
532
"""Get the path that this plugin was loaded from."""
533
if getattr(self.module, '__path__', None) is not None:
534
return os.path.abspath(self.module.__path__[0])
535
elif getattr(self.module, '__file__', None) is not None:
536
path = os.path.abspath(self.module.__file__)
537
if path[-4:] in ('.pyc', '.pyo'):
538
pypath = path[:-4] + '.py'
539
if os.path.isfile(pypath):
543
return repr(self.module)
546
return "<%s.%s object at %s, name=%s, module=%s>" % (
547
self.__class__.__module__, self.__class__.__name__, id(self),
548
self.name, self.module)
552
def test_suite(self):
553
"""Return the plugin's test suite."""
554
if getattr(self.module, 'test_suite', None) is not None:
555
return self.module.test_suite()
559
def load_plugin_tests(self, loader):
560
"""Return the adapted plugin's test suite.
562
:param loader: The custom loader that should be used to load additional
566
if getattr(self.module, 'load_tests', None) is not None:
567
return loader.loadTestsFromModule(self.module)
571
def version_info(self):
572
"""Return the plugin's version_tuple or None if unknown."""
573
version_info = getattr(self.module, 'version_info', None)
574
if version_info is not None:
576
if isinstance(version_info, types.StringType):
577
version_info = version_info.split('.')
578
elif len(version_info) == 3:
579
version_info = tuple(version_info) + ('final', 0)
581
# The given version_info isn't even iteratible
582
trace.log_exception_quietly()
583
version_info = (version_info,)
586
def _get__version__(self):
587
version_info = self.version_info()
588
if version_info is None or len(version_info) == 0:
591
version_string = _format_version_tuple(version_info)
592
except (ValueError, TypeError, IndexError), e:
593
trace.log_exception_quietly()
594
# try to return something usefull for bad plugins, in stead of
596
version_string = '.'.join(map(str, version_info))
597
return version_string
599
__version__ = property(_get__version__)
602
class _PluginImporter(object):
603
"""An importer tailored to bzr specific needs.
605
This is a singleton that takes care of:
606
- disabled plugins specified in 'blacklist',
607
- plugins that needs to be loaded from specific directories.
614
self.blacklist = set()
615
self.specific_paths = {}
617
def find_module(self, fullname, parent_path=None):
618
"""Search a plugin module.
620
Disabled plugins raise an import error, plugins with specific paths
621
returns a specific loader.
623
:return: None if the plugin doesn't need special handling, self
626
if not fullname.startswith('bzrlib.plugins.'):
628
if fullname in self.blacklist:
629
raise ImportError('%s is disabled' % fullname)
630
if fullname in self.specific_paths:
634
def load_module(self, fullname):
635
"""Load a plugin from a specific directory (or file)."""
636
# We are called only for specific paths
637
plugin_path = self.specific_paths[fullname]
639
if os.path.isdir(plugin_path):
640
for suffix, mode, kind in imp.get_suffixes():
641
if kind not in (imp.PY_SOURCE, imp.PY_COMPILED):
642
# We don't recognize compiled modules (.so, .dll, etc)
644
init_path = osutils.pathjoin(plugin_path, '__init__' + suffix)
645
if os.path.isfile(init_path):
646
# We've got a module here and load_module needs specific
648
loading_path = plugin_path
651
kind = imp.PKG_DIRECTORY
654
for suffix, mode, kind in imp.get_suffixes():
655
if plugin_path.endswith(suffix):
656
loading_path = plugin_path
658
if loading_path is None:
659
raise ImportError('%s cannot be loaded from %s'
660
% (fullname, plugin_path))
661
if kind is imp.PKG_DIRECTORY:
664
f = open(loading_path, mode)
666
mod = imp.load_module(fullname, f, loading_path,
667
(suffix, mode, kind))
668
mod.__package__ = fullname
675
# Install a dedicated importer for plugins requiring special handling
676
PluginImporter = _PluginImporter()
677
sys.meta_path.append(PluginImporter)
added
removed
bzrlib/plugin.py
