1
# Copyright (C) 2004, 2005 by Canonical Ltd
1
# Copyright (C) 2005-2011 Canonical Ltd
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
"""bzr python plugin support
20
Any python module in $BZR_PLUGIN_PATH will be imported upon initialization of
21
bzrlib. The module will be imported as 'bzrlib.plugins.$BASENAME(PLUGIN)'.
22
In the plugin's main body, it should update any bzrlib registries it wants to
23
extend; for example, to add new commands, import bzrlib.commands and add your
24
new command to the plugin_cmds variable.
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
"""bzr python plugin support.
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.
25
See the plugin-api developer documentation for information about writing
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
27
# TODO: Refactor this to make it more testable. The main problem at the
28
# moment is that loading plugins affects the global process state -- for bzr
29
# in general use it's a reasonable assumption that all plugins are loaded at
30
# startup and then stay loaded, but this is less good for testing.
32
# Several specific issues:
33
# - plugins can't be unloaded and will continue to effect later tests
34
# - load_plugins does nothing if called a second time
35
# - plugin hooks can't be removed
37
# Our options are either to remove these restrictions, or work around them by
38
# loading the plugins into a different space than the one running the tests.
39
# That could be either a separate Python interpreter or perhaps a new
40
# namespace inside this interpreter.
36
from bzrlib import osutils
38
from bzrlib.lazy_import import lazy_import
39
lazy_import(globals(), """
48
from bzrlib.config import config_dir
49
from bzrlib.trace import log_error, mutter, log_exception, warning, \
51
from bzrlib.errors import BzrError
52
from bzrlib import plugins
53
from bzrlib.osutils import pathjoin
55
DEFAULT_PLUGIN_PATH = pathjoin(config_dir(), 'plugins')
45
_format_version_tuple,
51
from bzrlib.i18n import gettext
52
from bzrlib import plugins as _mod_plugins
56
DEFAULT_PLUGIN_PATH = None
61
"""Return a dictionary of the plugins."""
63
for name, plugin in bzrlib.plugins.__dict__.items():
64
if isinstance(plugin, types.ModuleType):
58
_plugins_disabled = False
62
# Map from plugin name, to list of string warnings about eg plugin
66
def are_plugins_disabled():
67
return _plugins_disabled
69
70
def disable_plugins():
72
73
Future calls to load_plugins() will be ignored.
74
# TODO: jam 20060131 This should probably also disable
75
global _plugins_disabled
76
_plugins_disabled = True
80
def describe_plugins(show_paths=False):
81
"""Generate text description of plugins.
83
Includes both those that have loaded, and those that failed to
86
:param show_paths: If true,
87
:returns: Iterator of text lines (including newlines.)
89
from inspect import getdoc
90
loaded_plugins = plugins()
91
all_names = sorted(list(set(
92
loaded_plugins.keys() + plugin_warnings.keys())))
93
for name in all_names:
94
if name in loaded_plugins:
95
plugin = loaded_plugins[name]
96
version = plugin.__version__
97
if version == 'unknown':
99
yield '%s %s\n' % (name, version)
100
d = getdoc(plugin.module)
102
doc = d.split('\n')[0]
104
doc = '(no description)'
105
yield (" %s\n" % doc)
107
yield (" %s\n" % plugin.path())
110
yield "%s (failed to load)\n" % name
111
if name in plugin_warnings:
112
for line in plugin_warnings[name]:
113
yield " ** " + line + '\n'
117
def _strip_trailing_sep(path):
118
return path.rstrip("\\/")
121
def _get_specific_plugin_paths(paths):
122
"""Returns the plugin paths from a string describing the associations.
124
:param paths: A string describing the paths associated with the plugins.
126
:returns: A list of (plugin name, path) tuples.
128
For example, if paths is my_plugin@/test/my-test:her_plugin@/production/her,
129
[('my_plugin', '/test/my-test'), ('her_plugin', '/production/her')]
132
Note that ':' in the example above depends on the os.
137
for spec in paths.split(os.pathsep):
139
name, path = spec.split('@')
141
raise errors.BzrCommandError(gettext(
142
'"%s" is not a valid <plugin_name>@<plugin_path> description ')
144
specs.append((name, path))
148
def set_plugins_path(path=None):
149
"""Set the path for plugins to be loaded from.
151
:param path: The list of paths to search for plugins. By default,
152
path will be determined using get_standard_plugins_path.
153
if path is [], no plugins can be loaded.
156
path = get_standard_plugins_path()
157
_mod_plugins.__path__ = path
158
PluginImporter.reset()
159
# Set up a blacklist for disabled plugins
160
disabled_plugins = os.environ.get('BZR_DISABLE_PLUGINS', None)
161
if disabled_plugins is not None:
162
for name in disabled_plugins.split(os.pathsep):
163
PluginImporter.blacklist.add('bzrlib.plugins.' + name)
164
# Set up a the specific paths for plugins
165
for plugin_name, plugin_path in _get_specific_plugin_paths(os.environ.get(
166
'BZR_PLUGINS_AT', None)):
167
PluginImporter.specific_paths[
168
'bzrlib.plugins.%s' % plugin_name] = plugin_path
172
def _append_new_path(paths, new_path):
173
"""Append a new path if it set and not already known."""
174
if new_path is not None and new_path not in paths:
175
paths.append(new_path)
179
def get_core_plugin_path():
181
bzr_exe = bool(getattr(sys, 'frozen', None))
182
if bzr_exe: # expand path for bzr.exe
183
# We need to use relative path to system-wide plugin
184
# directory because bzrlib from standalone bzr.exe
185
# could be imported by another standalone program
186
# (e.g. bzr-config; or TortoiseBzr/Olive if/when they
187
# will become standalone exe). [bialix 20071123]
188
# __file__ typically is
189
# C:\Program Files\Bazaar\lib\library.zip\bzrlib\plugin.pyc
190
# then plugins directory is
191
# C:\Program Files\Bazaar\plugins
192
# so relative path is ../../../plugins
193
core_path = osutils.abspath(osutils.pathjoin(
194
osutils.dirname(__file__), '../../../plugins'))
195
else: # don't look inside library.zip
196
# search the plugin path before the bzrlib installed dir
197
core_path = os.path.dirname(_mod_plugins.__file__)
201
def get_site_plugin_path():
202
"""Returns the path for the site installed plugins."""
203
if sys.platform == 'win32':
204
# We don't have (yet) a good answer for windows since that is certainly
205
# related to the way we build the installers. -- vila20090821
209
from distutils.sysconfig import get_python_lib
211
# If distutuils is not available, we just don't know where they are
214
site_path = osutils.pathjoin(get_python_lib(), 'bzrlib', 'plugins')
218
def get_user_plugin_path():
219
return osutils.pathjoin(config.config_dir(), 'plugins')
222
def get_standard_plugins_path():
223
"""Determine a plugin path suitable for general use."""
224
# Ad-Hoc default: core is not overriden by site but user can overrides both
225
# The rationale is that:
226
# - 'site' comes last, because these plugins should always be available and
227
# are supposed to be in sync with the bzr installed on site.
228
# - 'core' comes before 'site' so that running bzr from sources or a user
229
# installed version overrides the site version.
230
# - 'user' comes first, because... user is always right.
231
# - the above rules clearly defines which plugin version will be loaded if
232
# several exist. Yet, it is sometimes desirable to disable some directory
233
# so that a set of plugins is disabled as once. This can be done via
234
# -site, -core, -user.
236
env_paths = os.environ.get('BZR_PLUGIN_PATH', '+user').split(os.pathsep)
237
defaults = ['+core', '+site']
239
# The predefined references
240
refs = dict(core=get_core_plugin_path(),
241
site=get_site_plugin_path(),
242
user=get_user_plugin_path())
244
# Unset paths that should be removed
245
for k,v in refs.iteritems():
247
# defaults can never mention removing paths as that will make it
248
# impossible for the user to revoke these removals.
249
if removed in env_paths:
250
env_paths.remove(removed)
255
for p in env_paths + defaults:
256
if p.startswith('+'):
257
# Resolve references if they are known
261
# Leave them untouched so user can still use paths starting
264
_append_new_path(paths, p)
266
# Get rid of trailing slashes, since Python can't handle them when
267
# it tries to import modules.
268
paths = map(_strip_trailing_sep, paths)
272
def load_plugins(path=None):
81
273
"""Load bzrlib plugins.
83
275
The environment variable BZR_PLUGIN_PATH is considered a delimited
84
set of paths to look through. Each entry is searched for *.py
276
set of paths to look through. Each entry is searched for `*.py`
85
277
files (and whatever other extensions are used in the platform,
88
load_from_dirs() provides the underlying mechanism and is called with
280
load_from_path() provides the underlying mechanism and is called with
89
281
the default directory list to provide the normal behaviour.
283
:param path: The list of paths to search for plugins. By default,
284
path will be determined using get_standard_plugins_path.
285
if path is [], no plugins can be loaded.
93
289
# People can make sure plugins are loaded, they just won't be twice
95
#raise BzrError("plugins already initialized")
98
dirs = os.environ.get('BZR_PLUGIN_PATH', DEFAULT_PLUGIN_PATH).split(os.pathsep)
99
dirs.insert(0, os.path.dirname(plugins.__file__))
104
def load_from_dirs(dirs):
293
# scan for all plugins in the path.
294
load_from_path(set_plugins_path(path))
297
def load_from_path(dirs):
105
298
"""Load bzrlib plugins found in each dir in dirs.
107
300
Loading a plugin means importing it into the python interpreter.
111
304
Plugins are loaded into bzrlib.plugins.NAME, and can be found there
112
305
for future reference.
307
The python module path for bzrlib.plugins will be modified to be 'dirs'.
114
# The problem with imp.get_suffixes() is that it doesn't include
115
# .pyo which is technically valid
116
# It also means that "testmodule.so" will show up as both test and testmodule
117
# though it is only valid as 'test'
118
# but you should be careful, because "testmodule.py" loads as testmodule.
119
suffixes = imp.get_suffixes()
120
suffixes.append(('.pyo', 'rb', imp.PY_COMPILED))
121
package_entries = ['__init__.py', '__init__.pyc', '__init__.pyo']
309
# Explicitly load the plugins with a specific path
310
for fullname, path in PluginImporter.specific_paths.iteritems():
311
name = fullname[len('bzrlib.plugins.'):]
312
_load_plugin_module(name, path)
314
# We need to strip the trailing separators here as well as in the
315
# set_plugins_path function because calling code can pass anything in to
316
# this function, and since it sets plugins.__path__, it should set it to
317
# something that will be valid for Python to use (in case people try to
318
# run "import bzrlib.plugins.PLUGINNAME" after calling this function).
319
_mod_plugins.__path__ = map(_strip_trailing_sep, dirs)
125
mutter('looking for plugins in %s', d)
127
if not os.path.isdir(d):
129
for f in os.listdir(d):
130
path = pathjoin(d, f)
131
if os.path.isdir(path):
132
for entry in package_entries:
133
# This directory should be a package, and thus added to
135
if os.path.isfile(pathjoin(path, entry)):
137
else: # This directory is not a package
140
for suffix_info in suffixes:
141
if f.endswith(suffix_info[0]):
142
f = f[:-len(suffix_info[0])]
143
if suffix_info[2] == imp.C_EXTENSION and f.endswith('module'):
144
f = f[:-len('module')]
148
if getattr(bzrlib.plugins, f, None):
149
mutter('Plugin name %s already loaded', f)
151
mutter('add plugin name %s', f)
154
plugin_names = list(plugin_names)
156
for name in plugin_names:
323
trace.mutter('looking for plugins in %s', d)
328
# backwards compatability: load_from_dirs was the old name
329
# This was changed in 0.15
330
load_from_dirs = load_from_path
333
def _find_plugin_module(dir, name):
334
"""Check if there is a valid python module that can be loaded as a plugin.
336
:param dir: The directory where the search is performed.
337
:param path: An existing file path, either a python file or a package
340
:return: (name, path, description) name is the module name, path is the
341
file to load and description is the tuple returned by
344
path = osutils.pathjoin(dir, name)
345
if os.path.isdir(path):
346
# Check for a valid __init__.py file, valid suffixes depends on -O and
347
# can be .py, .pyc and .pyo
348
for suffix, mode, kind in imp.get_suffixes():
349
if kind not in (imp.PY_SOURCE, imp.PY_COMPILED):
350
# We don't recognize compiled modules (.so, .dll, etc)
352
init_path = osutils.pathjoin(path, '__init__' + suffix)
353
if os.path.isfile(init_path):
354
return name, init_path, (suffix, mode, kind)
356
for suffix, mode, kind in imp.get_suffixes():
357
if name.endswith(suffix):
358
# Clean up the module name
359
name = name[:-len(suffix)]
360
if kind == imp.C_EXTENSION and name.endswith('module'):
361
name = name[:-len('module')]
362
return name, path, (suffix, mode, kind)
363
# There is no python module here
364
return None, None, (None, None, None)
367
def record_plugin_warning(plugin_name, warning_message):
368
trace.mutter(warning_message)
369
plugin_warnings.setdefault(plugin_name, []).append(warning_message)
372
def _load_plugin_module(name, dir):
373
"""Load plugin name from dir.
375
:param name: The plugin name in the bzrlib.plugins namespace.
376
:param dir: The directory the plugin is loaded from for error messages.
378
if ('bzrlib.plugins.%s' % name) in PluginImporter.blacklist:
381
exec "import bzrlib.plugins.%s" % name in {}
382
except KeyboardInterrupt:
384
except errors.IncompatibleAPI, e:
386
"Unable to load plugin %r. It requested API version "
387
"%s of module %s but the minimum exported version is %s, and "
388
"the maximum is %s" %
389
(name, e.wanted, e.api, e.minimum, e.current))
390
record_plugin_warning(name, warning_message)
392
trace.warning("%s" % e)
393
if re.search('\.|-| ', name):
394
sanitised_name = re.sub('[-. ]', '_', name)
395
if sanitised_name.startswith('bzr_'):
396
sanitised_name = sanitised_name[len('bzr_'):]
397
trace.warning("Unable to load %r in %r as a plugin because the "
398
"file path isn't a valid module name; try renaming "
399
"it to %r." % (name, dir, sanitised_name))
401
record_plugin_warning(
403
'Unable to load plugin %r from %r' % (name, dir))
404
trace.log_exception_quietly()
405
if 'error' in debug.debug_flags:
406
trace.print_exception(sys.exc_info(), sys.stderr)
409
def load_from_dir(d):
410
"""Load the plugins in directory d.
412
d must be in the plugins module path already.
413
This function is called once for each directory in the module path.
416
for p in os.listdir(d):
417
name, path, desc = _find_plugin_module(d, p)
419
if name == '__init__':
420
# We do nothing with the __init__.py file in directories from
421
# the bzrlib.plugins module path, we may want to, one day
423
continue # We don't load __init__.py in the plugins dirs
424
elif getattr(_mod_plugins, name, None) is not None:
425
# The module has already been loaded from another directory
426
# during a previous call.
427
# FIXME: There should be a better way to report masked plugins
429
trace.mutter('Plugin name %s already loaded', name)
431
plugin_names.add(name)
433
for name in plugin_names:
434
_load_plugin_module(name, d)
438
"""Return a dictionary of the plugins.
440
Each item in the dictionary is a PlugIn object.
443
for name, plugin in _mod_plugins.__dict__.items():
444
if isinstance(plugin, types.ModuleType):
445
result[name] = PlugIn(name, plugin)
449
def format_concise_plugin_list():
450
"""Return a string holding a concise list of plugins and their version.
453
for name, a_plugin in sorted(plugins().items()):
454
items.append("%s[%s]" %
455
(name, a_plugin.__version__))
456
return ', '.join(items)
460
class PluginsHelpIndex(object):
461
"""A help index that returns help topics for plugins."""
464
self.prefix = 'plugins/'
466
def get_topics(self, topic):
467
"""Search for topic in the loaded plugins.
469
This will not trigger loading of new plugins.
471
:param topic: A topic to search for.
472
:return: A list which is either empty or contains a single
473
RegisteredTopic entry.
477
if topic.startswith(self.prefix):
478
topic = topic[len(self.prefix):]
479
plugin_module_name = 'bzrlib.plugins.%s' % topic
481
module = sys.modules[plugin_module_name]
485
return [ModuleHelpTopic(module)]
488
class ModuleHelpTopic(object):
489
"""A help topic which returns the docstring for a module."""
491
def __init__(self, module):
494
:param module: The module for which help should be generated.
498
def get_help_text(self, additional_see_also=None, verbose=True):
499
"""Return a string with the help for this topic.
501
:param additional_see_also: Additional help topics to be
504
if not self.module.__doc__:
505
result = "Plugin '%s' has no docstring.\n" % self.module.__name__
507
result = self.module.__doc__
508
if result[-1] != '\n':
510
from bzrlib import help_topics
511
result += help_topics._format_see_also(additional_see_also)
514
def get_help_topic(self):
515
"""Return the module help topic: its basename."""
516
return self.module.__name__[len('bzrlib.plugins.'):]
519
class PlugIn(object):
520
"""The bzrlib representation of a plugin.
522
The PlugIn object provides a way to manipulate a given plugin module.
525
def __init__(self, name, module):
526
"""Construct a plugin for module."""
531
"""Get the path that this plugin was loaded from."""
532
if getattr(self.module, '__path__', None) is not None:
533
return os.path.abspath(self.module.__path__[0])
534
elif getattr(self.module, '__file__', None) is not None:
535
path = os.path.abspath(self.module.__file__)
536
if path[-4:] in ('.pyc', '.pyo'):
537
pypath = path[:-4] + '.py'
538
if os.path.isfile(pypath):
542
return repr(self.module)
545
return "<%s.%s object at %s, name=%s, module=%s>" % (
546
self.__class__.__module__, self.__class__.__name__, id(self),
547
self.name, self.module)
551
def test_suite(self):
552
"""Return the plugin's test suite."""
553
if getattr(self.module, 'test_suite', None) is not None:
554
return self.module.test_suite()
558
def load_plugin_tests(self, loader):
559
"""Return the adapted plugin's test suite.
561
:param loader: The custom loader that should be used to load additional
565
if getattr(self.module, 'load_tests', None) is not None:
566
return loader.loadTestsFromModule(self.module)
570
def version_info(self):
571
"""Return the plugin's version_tuple or None if unknown."""
572
version_info = getattr(self.module, 'version_info', None)
573
if version_info is not None:
158
plugin_info = imp.find_module(name, [d])
159
mutter('load plugin %r', plugin_info)
161
plugin = imp.load_module('bzrlib.plugins.' + name,
163
setattr(bzrlib.plugins, name, plugin)
165
if plugin_info[0] is not None:
166
plugin_info[0].close()
168
mutter('loaded succesfully')
169
except KeyboardInterrupt:
172
## import pdb; pdb.set_trace()
173
warning('Unable to load plugin %r from %r' % (name, d))
174
log_exception_quietly()
575
if isinstance(version_info, types.StringType):
576
version_info = version_info.split('.')
577
elif len(version_info) == 3:
578
version_info = tuple(version_info) + ('final', 0)
580
# The given version_info isn't even iteratible
581
trace.log_exception_quietly()
582
version_info = (version_info,)
585
def _get__version__(self):
586
version_info = self.version_info()
587
if version_info is None or len(version_info) == 0:
590
version_string = _format_version_tuple(version_info)
591
except (ValueError, TypeError, IndexError), e:
592
trace.log_exception_quietly()
593
# try to return something usefull for bad plugins, in stead of
595
version_string = '.'.join(map(str, version_info))
596
return version_string
598
__version__ = property(_get__version__)
601
class _PluginImporter(object):
602
"""An importer tailored to bzr specific needs.
604
This is a singleton that takes care of:
605
- disabled plugins specified in 'blacklist',
606
- plugins that needs to be loaded from specific directories.
613
self.blacklist = set()
614
self.specific_paths = {}
616
def find_module(self, fullname, parent_path=None):
617
"""Search a plugin module.
619
Disabled plugins raise an import error, plugins with specific paths
620
returns a specific loader.
622
:return: None if the plugin doesn't need special handling, self
625
if not fullname.startswith('bzrlib.plugins.'):
627
if fullname in self.blacklist:
628
raise ImportError('%s is disabled' % fullname)
629
if fullname in self.specific_paths:
633
def load_module(self, fullname):
634
"""Load a plugin from a specific directory."""
635
# We are called only for specific paths
636
plugin_path = self.specific_paths[fullname]
638
if os.path.isdir(plugin_path):
639
for suffix, mode, kind in imp.get_suffixes():
640
if kind not in (imp.PY_SOURCE, imp.PY_COMPILED):
641
# We don't recognize compiled modules (.so, .dll, etc)
643
init_path = osutils.pathjoin(plugin_path, '__init__' + suffix)
644
if os.path.isfile(init_path):
645
# We've got a module here and load_module needs specific
647
loading_path = plugin_path
650
kind = imp.PKG_DIRECTORY
653
for suffix, mode, kind in imp.get_suffixes():
654
if plugin_path.endswith(suffix):
655
loading_path = plugin_path
657
if loading_path is None:
658
raise ImportError('%s cannot be loaded from %s'
659
% (fullname, plugin_path))
660
if kind is imp.PKG_DIRECTORY:
663
f = open(loading_path, mode)
665
mod = imp.load_module(fullname, f, loading_path,
666
(suffix, mode, kind))
667
mod.__package__ = fullname
674
# Install a dedicated importer for plugins requiring special handling
675
PluginImporter = _PluginImporter()
676
sys.meta_path.append(PluginImporter)
added
removed
bzrlib/plugin.py
