← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/plugin.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-03-17 07:05:37 UTC
  • mfrom: (4152.1.2 branch.stacked.streams)
  • Revision ID: pqm@pqm.ubuntu.com-20090317070537-zaud24vjs2szna87
(robertc) Add client-side streaming from stacked branches (over
        bzr:// protocols) when the sort order is compatible with doing
        that. (Robert Collins, Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/plugin.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
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
12
12
#
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
18
"""bzr python plugin support.
41
41
import imp
42
42
import re
43
43
import types
 
44
import zipfile
44
45
 
45
46
from bzrlib import (
46
47
    _format_version_tuple,
52
53
from bzrlib import plugins as _mod_plugins
53
54
""")
54
55
 
55
 
from bzrlib.symbol_versioning import (
56
 
    deprecated_function,
57
 
    deprecated_in,
58
 
    )
 
56
from bzrlib.symbol_versioning import deprecated_function, one_three
59
57
 
60
58
 
61
59
DEFAULT_PLUGIN_PATH = None
62
60
_loaded = False
63
 
_plugins_disabled = False
64
 
 
65
 
 
66
 
def are_plugins_disabled():
67
 
    return _plugins_disabled
 
61
 
 
62
def get_default_plugin_path():
 
63
    """Get the DEFAULT_PLUGIN_PATH"""
 
64
    global DEFAULT_PLUGIN_PATH
 
65
    if DEFAULT_PLUGIN_PATH is None:
 
66
        DEFAULT_PLUGIN_PATH = osutils.pathjoin(config.config_dir(), 'plugins')
 
67
    return DEFAULT_PLUGIN_PATH
68
68
 
69
69
 
70
70
def disable_plugins():
72
72
 
73
73
    Future calls to load_plugins() will be ignored.
74
74
    """
75
 
    global _plugins_disabled
76
 
    _plugins_disabled = True
77
75
    load_plugins([])
78
76
 
79
77
 
81
79
    return path.rstrip("\\/")
82
80
 
83
81
 
84
 
def _get_specific_plugin_paths(paths):
85
 
    """Returns the plugin paths from a string describing the associations.
86
 
 
87
 
    :param paths: A string describing the paths associated with the plugins.
88
 
 
89
 
    :returns: A list of (plugin name, path) tuples.
90
 
 
91
 
    For example, if paths is my_plugin@/test/my-test:her_plugin@/production/her,
92
 
    [('my_plugin', '/test/my-test'), ('her_plugin', '/production/her')] 
93
 
    will be returned.
94
 
 
95
 
    Note that ':' in the example above depends on the os.
96
 
    """
97
 
    if not paths:
98
 
        return []
99
 
    specs = []
100
 
    for spec in paths.split(os.pathsep):
101
 
        try:
102
 
            name, path = spec.split('@')
103
 
        except ValueError:
104
 
            raise errors.BzrCommandError(
105
 
                '"%s" is not a valid <plugin_name>@<plugin_path> description '
106
 
                % spec)
107
 
        specs.append((name, path))
108
 
    return specs
109
 
 
110
 
 
111
82
def set_plugins_path(path=None):
112
83
    """Set the path for plugins to be loaded from.
113
84
 
118
89
    if path is None:
119
90
        path = get_standard_plugins_path()
120
91
    _mod_plugins.__path__ = path
121
 
    PluginImporter.reset()
122
 
    # Set up a blacklist for disabled plugins
123
 
    disabled_plugins = os.environ.get('BZR_DISABLE_PLUGINS', None)
124
 
    if disabled_plugins is not None:
125
 
        for name in disabled_plugins.split(os.pathsep):
126
 
            PluginImporter.blacklist.add('bzrlib.plugins.' + name)
127
 
    # Set up a the specific paths for plugins
128
 
    for plugin_name, plugin_path in _get_specific_plugin_paths(os.environ.get(
129
 
            'BZR_PLUGINS_AT', None)):
130
 
            PluginImporter.specific_paths[
131
 
                'bzrlib.plugins.%s' % plugin_name] = plugin_path
132
92
    return path
133
93
 
134
94
 
135
 
def _append_new_path(paths, new_path):
136
 
    """Append a new path if it set and not already known."""
137
 
    if new_path is not None and new_path not in paths:
138
 
        paths.append(new_path)
139
 
    return paths
140
 
 
141
 
 
142
 
def get_core_plugin_path():
143
 
    core_path = None
 
95
def get_standard_plugins_path():
 
96
    """Determine a plugin path suitable for general use."""
 
97
    path = os.environ.get('BZR_PLUGIN_PATH',
 
98
                          get_default_plugin_path()).split(os.pathsep)
 
99
    # Get rid of trailing slashes, since Python can't handle them when
 
100
    # it tries to import modules.
 
101
    path = map(_strip_trailing_sep, path)
144
102
    bzr_exe = bool(getattr(sys, 'frozen', None))
145
103
    if bzr_exe:    # expand path for bzr.exe
146
104
        # We need to use relative path to system-wide plugin
153
111
        # then plugins directory is
154
112
        # C:\Program Files\Bazaar\plugins
155
113
        # so relative path is ../../../plugins
156
 
        core_path = osutils.abspath(osutils.pathjoin(
157
 
                osutils.dirname(__file__), '../../../plugins'))
158
 
    else:     # don't look inside library.zip
 
114
        path.append(osutils.abspath(osutils.pathjoin(
 
115
            osutils.dirname(__file__), '../../../plugins')))
 
116
    if not bzr_exe:     # don't look inside library.zip
159
117
        # search the plugin path before the bzrlib installed dir
160
 
        core_path = os.path.dirname(_mod_plugins.__file__)
161
 
    return core_path
162
 
 
163
 
 
164
 
def get_site_plugin_path():
165
 
    """Returns the path for the site installed plugins."""
166
 
    if sys.platform == 'win32':
167
 
        # We don't have (yet) a good answer for windows since that is certainly
168
 
        # related to the way we build the installers. -- vila20090821
169
 
        return None
170
 
    site_path = None
171
 
    try:
172
 
        from distutils.sysconfig import get_python_lib
173
 
    except ImportError:
174
 
        # If distutuils is not available, we just don't know where they are
175
 
        pass
176
 
    else:
177
 
        site_path = osutils.pathjoin(get_python_lib(), 'bzrlib', 'plugins')
178
 
    return site_path
179
 
 
180
 
 
181
 
def get_user_plugin_path():
182
 
    return osutils.pathjoin(config.config_dir(), 'plugins')
183
 
 
184
 
 
185
 
def get_standard_plugins_path():
186
 
    """Determine a plugin path suitable for general use."""
187
 
    # Ad-Hoc default: core is not overriden by site but user can overrides both
188
 
    # The rationale is that:
189
 
    # - 'site' comes last, because these plugins should always be available and
190
 
    #   are supposed to be in sync with the bzr installed on site.
191
 
    # - 'core' comes before 'site' so that running bzr from sources or a user
192
 
    #   installed version overrides the site version.
193
 
    # - 'user' comes first, because... user is always right.
194
 
    # - the above rules clearly defines which plugin version will be loaded if
195
 
    #   several exist. Yet, it is sometimes desirable to disable some directory
196
 
    #   so that a set of plugins is disabled as once. This can be done via
197
 
    #   -site, -core, -user.
198
 
 
199
 
    env_paths = os.environ.get('BZR_PLUGIN_PATH', '+user').split(os.pathsep)
200
 
    defaults = ['+core', '+site']
201
 
 
202
 
    # The predefined references
203
 
    refs = dict(core=get_core_plugin_path(),
204
 
                site=get_site_plugin_path(),
205
 
                user=get_user_plugin_path())
206
 
 
207
 
    # Unset paths that should be removed
208
 
    for k,v in refs.iteritems():
209
 
        removed = '-%s' % k
210
 
        # defaults can never mention removing paths as that will make it
211
 
        # impossible for the user to revoke these removals.
212
 
        if removed in env_paths:
213
 
            env_paths.remove(removed)
214
 
            refs[k] = None
215
 
 
216
 
    # Expand references
217
 
    paths = []
218
 
    for p in env_paths + defaults:
219
 
        if p.startswith('+'):
220
 
            # Resolve references if they are known
221
 
            try:
222
 
                p = refs[p[1:]]
223
 
            except KeyError:
224
 
                # Leave them untouched so user can still use paths starting
225
 
                # with '+'
226
 
                pass
227
 
        _append_new_path(paths, p)
228
 
 
229
 
    # Get rid of trailing slashes, since Python can't handle them when
230
 
    # it tries to import modules.
231
 
    paths = map(_strip_trailing_sep, paths)
232
 
    return paths
 
118
        path.append(os.path.dirname(_mod_plugins.__file__))
 
119
    # search the arch independent path if we can determine that and
 
120
    # the plugin is found nowhere else
 
121
    if sys.platform != 'win32':
 
122
        try:
 
123
            from distutils.sysconfig import get_python_lib
 
124
        except ImportError:
 
125
            # If distutuils is not available, we just won't add that path
 
126
            pass
 
127
        else:
 
128
            archless_path = osutils.pathjoin(get_python_lib(), 'bzrlib',
 
129
                    'plugins')
 
130
            if archless_path not in path:
 
131
                path.append(archless_path)
 
132
    return path
233
133
 
234
134
 
235
135
def load_plugins(path=None):
240
140
    files (and whatever other extensions are used in the platform,
241
141
    such as *.pyd).
242
142
 
243
 
    load_from_path() provides the underlying mechanism and is called with
 
143
    load_from_dirs() provides the underlying mechanism and is called with
244
144
    the default directory list to provide the normal behaviour.
245
145
 
246
146
    :param path: The list of paths to search for plugins.  By default,
269
169
 
270
170
    The python module path for bzrlib.plugins will be modified to be 'dirs'.
271
171
    """
272
 
    # Explicitly load the plugins with a specific path
273
 
    for fullname, path in PluginImporter.specific_paths.iteritems():
274
 
        name = fullname[len('bzrlib.plugins.'):]
275
 
        _load_plugin_module(name, path)
276
 
 
277
172
    # We need to strip the trailing separators here as well as in the
278
173
    # set_plugins_path function because calling code can pass anything in to
279
174
    # this function, and since it sets plugins.__path__, it should set it to
293
188
load_from_dirs = load_from_path
294
189
 
295
190
 
296
 
def _find_plugin_module(dir, name):
297
 
    """Check if there is a valid python module that can be loaded as a plugin.
298
 
 
299
 
    :param dir: The directory where the search is performed.
300
 
    :param path: An existing file path, either a python file or a package
301
 
        directory.
302
 
 
303
 
    :return: (name, path, description) name is the module name, path is the
304
 
        file to load and description is the tuple returned by
305
 
        imp.get_suffixes().
306
 
    """
307
 
    path = osutils.pathjoin(dir, name)
308
 
    if os.path.isdir(path):
309
 
        # Check for a valid __init__.py file, valid suffixes depends on -O and
310
 
        # can be .py, .pyc and .pyo
311
 
        for suffix, mode, kind in imp.get_suffixes():
312
 
            if kind not in (imp.PY_SOURCE, imp.PY_COMPILED):
313
 
                # We don't recognize compiled modules (.so, .dll, etc)
314
 
                continue
315
 
            init_path = osutils.pathjoin(path, '__init__' + suffix)
316
 
            if os.path.isfile(init_path):
317
 
                return name, init_path, (suffix, mode, kind)
318
 
    else:
319
 
        for suffix, mode, kind in imp.get_suffixes():
320
 
            if name.endswith(suffix):
321
 
                # Clean up the module name
322
 
                name = name[:-len(suffix)]
323
 
                if kind == imp.C_EXTENSION and name.endswith('module'):
324
 
                    name = name[:-len('module')]
325
 
                return name, path, (suffix, mode, kind)
326
 
    # There is no python module here
327
 
    return None, None, (None, None, None)
328
 
 
329
 
 
330
 
def _load_plugin_module(name, dir):
331
 
    """Load plugin name from dir.
332
 
 
333
 
    :param name: The plugin name in the bzrlib.plugins namespace.
334
 
    :param dir: The directory the plugin is loaded from for error messages.
335
 
    """
336
 
    if ('bzrlib.plugins.%s' % name) in PluginImporter.blacklist:
337
 
        return
338
 
    try:
339
 
        exec "import bzrlib.plugins.%s" % name in {}
340
 
    except KeyboardInterrupt:
341
 
        raise
342
 
    except errors.IncompatibleAPI, e:
343
 
        trace.warning("Unable to load plugin %r. It requested API version "
344
 
            "%s of module %s but the minimum exported version is %s, and "
345
 
            "the maximum is %s" %
346
 
            (name, e.wanted, e.api, e.minimum, e.current))
347
 
    except Exception, e:
348
 
        trace.warning("%s" % e)
349
 
        if re.search('\.|-| ', name):
350
 
            sanitised_name = re.sub('[-. ]', '_', name)
351
 
            if sanitised_name.startswith('bzr_'):
352
 
                sanitised_name = sanitised_name[len('bzr_'):]
353
 
            trace.warning("Unable to load %r in %r as a plugin because the "
354
 
                    "file path isn't a valid module name; try renaming "
355
 
                    "it to %r." % (name, dir, sanitised_name))
356
 
        else:
357
 
            trace.warning('Unable to load plugin %r from %r' % (name, dir))
358
 
        trace.log_exception_quietly()
359
 
        if 'error' in debug.debug_flags:
360
 
            trace.print_exception(sys.exc_info(), sys.stderr)
361
 
 
362
 
 
363
191
def load_from_dir(d):
364
192
    """Load the plugins in directory d.
365
193
 
366
194
    d must be in the plugins module path already.
367
 
    This function is called once for each directory in the module path.
368
195
    """
 
196
    # Get the list of valid python suffixes for __init__.py?
 
197
    # this includes .py, .pyc, and .pyo (depending on if we are running -O)
 
198
    # but it doesn't include compiled modules (.so, .dll, etc)
 
199
    valid_suffixes = [suffix for suffix, mod_type, flags in imp.get_suffixes()
 
200
                              if flags in (imp.PY_SOURCE, imp.PY_COMPILED)]
 
201
    package_entries = ['__init__'+suffix for suffix in valid_suffixes]
369
202
    plugin_names = set()
370
 
    for p in os.listdir(d):
371
 
        name, path, desc = _find_plugin_module(d, p)
372
 
        if name is not None:
373
 
            if name == '__init__':
374
 
                # We do nothing with the __init__.py file in directories from
375
 
                # the bzrlib.plugins module path, we may want to, one day
376
 
                # -- vila 20100316.
377
 
                continue # We don't load __init__.py in the plugins dirs
378
 
            elif getattr(_mod_plugins, name, None) is not None:
379
 
                # The module has already been loaded from another directory
380
 
                # during a previous call.
381
 
                # FIXME: There should be a better way to report masked plugins
382
 
                # -- vila 20100316
383
 
                trace.mutter('Plugin name %s already loaded', name)
 
203
    for f in os.listdir(d):
 
204
        path = osutils.pathjoin(d, f)
 
205
        if os.path.isdir(path):
 
206
            for entry in package_entries:
 
207
                # This directory should be a package, and thus added to
 
208
                # the list
 
209
                if os.path.isfile(osutils.pathjoin(path, entry)):
 
210
                    break
 
211
            else: # This directory is not a package
 
212
                continue
 
213
        else:
 
214
            for suffix_info in imp.get_suffixes():
 
215
                if f.endswith(suffix_info[0]):
 
216
                    f = f[:-len(suffix_info[0])]
 
217
                    if suffix_info[2] == imp.C_EXTENSION and f.endswith('module'):
 
218
                        f = f[:-len('module')]
 
219
                    break
384
220
            else:
385
 
                plugin_names.add(name)
 
221
                continue
 
222
        if f == '__init__':
 
223
            continue # We don't load __init__.py again in the plugin dir
 
224
        elif getattr(_mod_plugins, f, None):
 
225
            trace.mutter('Plugin name %s already loaded', f)
 
226
        else:
 
227
            # trace.mutter('add plugin name %s', f)
 
228
            plugin_names.add(f)
386
229
 
387
230
    for name in plugin_names:
388
 
        _load_plugin_module(name, d)
 
231
        try:
 
232
            exec "import bzrlib.plugins.%s" % name in {}
 
233
        except KeyboardInterrupt:
 
234
            raise
 
235
        except errors.IncompatibleAPI, e:
 
236
            trace.warning("Unable to load plugin %r. It requested API version "
 
237
                "%s of module %s but the minimum exported version is %s, and "
 
238
                "the maximum is %s" %
 
239
                (name, e.wanted, e.api, e.minimum, e.current))
 
240
        except Exception, e:
 
241
            trace.warning("%s" % e)
 
242
            ## import pdb; pdb.set_trace()
 
243
            if re.search('\.|-| ', name):
 
244
                sanitised_name = re.sub('[-. ]', '_', name)
 
245
                if sanitised_name.startswith('bzr_'):
 
246
                    sanitised_name = sanitised_name[len('bzr_'):]
 
247
                trace.warning("Unable to load %r in %r as a plugin because the "
 
248
                        "file path isn't a valid module name; try renaming "
 
249
                        "it to %r." % (name, d, sanitised_name))
 
250
            else:
 
251
                trace.warning('Unable to load plugin %r from %r' % (name, d))
 
252
            trace.log_exception_quietly()
 
253
            if 'error' in debug.debug_flags:
 
254
                trace.print_exception(sys.exc_info(), sys.stderr)
 
255
 
 
256
 
 
257
@deprecated_function(one_three)
 
258
def load_from_zip(zip_name):
 
259
    """Load all the plugins in a zip."""
 
260
    valid_suffixes = ('.py', '.pyc', '.pyo')    # only python modules/packages
 
261
                                                # is allowed
 
262
    try:
 
263
        index = zip_name.rindex('.zip')
 
264
    except ValueError:
 
265
        return
 
266
    archive = zip_name[:index+4]
 
267
    prefix = zip_name[index+5:]
 
268
 
 
269
    trace.mutter('Looking for plugins in %r', zip_name)
 
270
 
 
271
    # use zipfile to get list of files/dirs inside zip
 
272
    try:
 
273
        z = zipfile.ZipFile(archive)
 
274
        namelist = z.namelist()
 
275
        z.close()
 
276
    except zipfile.error:
 
277
        # not a valid zip
 
278
        return
 
279
 
 
280
    if prefix:
 
281
        prefix = prefix.replace('\\','/')
 
282
        if prefix[-1] != '/':
 
283
            prefix += '/'
 
284
        ix = len(prefix)
 
285
        namelist = [name[ix:]
 
286
                    for name in namelist
 
287
                    if name.startswith(prefix)]
 
288
 
 
289
    trace.mutter('Names in archive: %r', namelist)
 
290
 
 
291
    for name in namelist:
 
292
        if not name or name.endswith('/'):
 
293
            continue
 
294
 
 
295
        # '/' is used to separate pathname components inside zip archives
 
296
        ix = name.rfind('/')
 
297
        if ix == -1:
 
298
            head, tail = '', name
 
299
        else:
 
300
            head, tail = name.rsplit('/',1)
 
301
        if '/' in head:
 
302
            # we don't need looking in subdirectories
 
303
            continue
 
304
 
 
305
        base, suffix = osutils.splitext(tail)
 
306
        if suffix not in valid_suffixes:
 
307
            continue
 
308
 
 
309
        if base == '__init__':
 
310
            # package
 
311
            plugin_name = head
 
312
        elif head == '':
 
313
            # module
 
314
            plugin_name = base
 
315
        else:
 
316
            continue
 
317
 
 
318
        if not plugin_name:
 
319
            continue
 
320
        if getattr(_mod_plugins, plugin_name, None):
 
321
            trace.mutter('Plugin name %s already loaded', plugin_name)
 
322
            continue
 
323
 
 
324
        try:
 
325
            exec "import bzrlib.plugins.%s" % plugin_name in {}
 
326
            trace.mutter('Load plugin %s from zip %r', plugin_name, zip_name)
 
327
        except KeyboardInterrupt:
 
328
            raise
 
329
        except Exception, e:
 
330
            ## import pdb; pdb.set_trace()
 
331
            trace.warning('Unable to load plugin %r from %r'
 
332
                    % (name, zip_name))
 
333
            trace.log_exception_quietly()
 
334
            if 'error' in debug.debug_flags:
 
335
                trace.print_exception(sys.exc_info(), sys.stderr)
389
336
 
390
337
 
391
338
def plugins():
438
385
        """
439
386
        self.module = module
440
387
 
441
 
    def get_help_text(self, additional_see_also=None, verbose=True):
 
388
    def get_help_text(self, additional_see_also=None):
442
389
        """Return a string with the help for this topic.
443
390
 
444
391
        :param additional_see_also: Additional help topics to be
548
495
        return version_string
549
496
 
550
497
    __version__ = property(_get__version__)
551
 
 
552
 
 
553
 
class _PluginImporter(object):
554
 
    """An importer tailored to bzr specific needs.
555
 
 
556
 
    This is a singleton that takes care of:
557
 
    - disabled plugins specified in 'blacklist',
558
 
    - plugins that needs to be loaded from specific directories.
559
 
    """
560
 
 
561
 
    def __init__(self):
562
 
        self.reset()
563
 
 
564
 
    def reset(self):
565
 
        self.blacklist = set()
566
 
        self.specific_paths = {}
567
 
 
568
 
    def find_module(self, fullname, parent_path=None):
569
 
        """Search a plugin module.
570
 
 
571
 
        Disabled plugins raise an import error, plugins with specific paths
572
 
        returns a specific loader.
573
 
 
574
 
        :return: None if the plugin doesn't need special handling, self
575
 
            otherwise.
576
 
        """
577
 
        if not fullname.startswith('bzrlib.plugins.'):
578
 
            return None
579
 
        if fullname in self.blacklist:
580
 
            raise ImportError('%s is disabled' % fullname)
581
 
        if fullname in self.specific_paths:
582
 
            return self
583
 
        return None
584
 
 
585
 
    def load_module(self, fullname):
586
 
        """Load a plugin from a specific directory."""
587
 
        # We are called only for specific paths
588
 
        plugin_path = self.specific_paths[fullname]
589
 
        loading_path = None
590
 
        if os.path.isdir(plugin_path):
591
 
            for suffix, mode, kind in imp.get_suffixes():
592
 
                if kind not in (imp.PY_SOURCE, imp.PY_COMPILED):
593
 
                    # We don't recognize compiled modules (.so, .dll, etc)
594
 
                    continue
595
 
                init_path = osutils.pathjoin(plugin_path, '__init__' + suffix)
596
 
                if os.path.isfile(init_path):
597
 
                    # We've got a module here and load_module needs specific
598
 
                    # parameters.
599
 
                    loading_path = plugin_path
600
 
                    suffix = ''
601
 
                    mode = ''
602
 
                    kind = imp.PKG_DIRECTORY
603
 
                    break
604
 
        else:
605
 
            for suffix, mode, kind in imp.get_suffixes():
606
 
                if plugin_path.endswith(suffix):
607
 
                    loading_path = plugin_path
608
 
                    break
609
 
        if loading_path is None:
610
 
            raise ImportError('%s cannot be loaded from %s'
611
 
                              % (fullname, plugin_path))
612
 
        if kind is imp.PKG_DIRECTORY:
613
 
            f = None
614
 
        else:
615
 
            f = open(loading_path, mode)
616
 
        try:
617
 
            mod = imp.load_module(fullname, f, loading_path,
618
 
                                  (suffix, mode, kind))
619
 
            mod.__package__ = fullname
620
 
            return mod
621
 
        finally:
622
 
            if f is not None:
623
 
                f.close()
624
 
 
625
 
 
626
 
# Install a dedicated importer for plugins requiring special handling
627
 
PluginImporter = _PluginImporter()
628
 
sys.meta_path.append(PluginImporter)