/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: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2004, 2005, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2005-2010 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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
45
44
 
46
45
from bzrlib import (
47
46
    _format_version_tuple,
53
52
from bzrlib import plugins as _mod_plugins
54
53
""")
55
54
 
56
 
from bzrlib.symbol_versioning import deprecated_function, one_three
 
55
from bzrlib.symbol_versioning import (
 
56
    deprecated_function,
 
57
    deprecated_in,
 
58
    )
57
59
 
58
60
 
59
61
DEFAULT_PLUGIN_PATH = None
60
62
_loaded = False
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
 
63
_plugins_disabled = False
 
64
 
 
65
 
 
66
def are_plugins_disabled():
 
67
    return _plugins_disabled
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
75
77
    load_plugins([])
76
78
 
77
79
 
89
91
    if path is None:
90
92
        path = get_standard_plugins_path()
91
93
    _mod_plugins.__path__ = path
 
94
    PluginImporter.reset()
 
95
    # Set up a blacklist for disabled plugins
 
96
    disabled_plugins = os.environ.get('BZR_DISABLE_PLUGINS', None)
 
97
    if disabled_plugins is not None:
 
98
        for name in disabled_plugins.split(os.pathsep):
 
99
            PluginImporter.blacklist.add('bzrlib.plugins.' + name)
 
100
    # Set up a the specific paths for plugins
 
101
    specific_plugins = os.environ.get('BZR_PLUGINS_AT', None)
 
102
    if specific_plugins is not None:
 
103
        for spec in specific_plugins.split(os.pathsep):
 
104
            plugin_name, plugin_path = spec.split('@')
 
105
            PluginImporter.specific_paths[
 
106
                'bzrlib.plugins.%s' % plugin_name] = plugin_path
92
107
    return path
93
108
 
94
109
 
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)
 
110
def _append_new_path(paths, new_path):
 
111
    """Append a new path if it set and not already known."""
 
112
    if new_path is not None and new_path not in paths:
 
113
        paths.append(new_path)
 
114
    return paths
 
115
 
 
116
 
 
117
def get_core_plugin_path():
 
118
    core_path = None
102
119
    bzr_exe = bool(getattr(sys, 'frozen', None))
103
120
    if bzr_exe:    # expand path for bzr.exe
104
121
        # We need to use relative path to system-wide plugin
111
128
        # then plugins directory is
112
129
        # C:\Program Files\Bazaar\plugins
113
130
        # so relative path is ../../../plugins
114
 
        path.append(osutils.abspath(osutils.pathjoin(
115
 
            osutils.dirname(__file__), '../../../plugins')))
116
 
    if not bzr_exe:     # don't look inside library.zip
 
131
        core_path = osutils.abspath(osutils.pathjoin(
 
132
                osutils.dirname(__file__), '../../../plugins'))
 
133
    else:     # don't look inside library.zip
117
134
        # search the plugin path before the bzrlib installed dir
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
 
135
        core_path = os.path.dirname(_mod_plugins.__file__)
 
136
    return core_path
 
137
 
 
138
 
 
139
def get_site_plugin_path():
 
140
    """Returns the path for the site installed plugins."""
 
141
    if sys.platform == 'win32':
 
142
        # We don't have (yet) a good answer for windows since that is certainly
 
143
        # related to the way we build the installers. -- vila20090821
 
144
        return None
 
145
    site_path = None
 
146
    try:
 
147
        from distutils.sysconfig import get_python_lib
 
148
    except ImportError:
 
149
        # If distutuils is not available, we just don't know where they are
 
150
        pass
 
151
    else:
 
152
        site_path = osutils.pathjoin(get_python_lib(), 'bzrlib', 'plugins')
 
153
    return site_path
 
154
 
 
155
 
 
156
def get_user_plugin_path():
 
157
    return osutils.pathjoin(config.config_dir(), 'plugins')
 
158
 
 
159
 
 
160
def get_standard_plugins_path():
 
161
    """Determine a plugin path suitable for general use."""
 
162
    # Ad-Hoc default: core is not overriden by site but user can overrides both
 
163
    # The rationale is that:
 
164
    # - 'site' comes last, because these plugins should always be available and
 
165
    #   are supposed to be in sync with the bzr installed on site.
 
166
    # - 'core' comes before 'site' so that running bzr from sources or a user
 
167
    #   installed version overrides the site version.
 
168
    # - 'user' comes first, because... user is always right.
 
169
    # - the above rules clearly defines which plugin version will be loaded if
 
170
    #   several exist. Yet, it is sometimes desirable to disable some directory
 
171
    #   so that a set of plugins is disabled as once. This can be done via
 
172
    #   -site, -core, -user.
 
173
 
 
174
    env_paths = os.environ.get('BZR_PLUGIN_PATH', '+user').split(os.pathsep)
 
175
    defaults = ['+core', '+site']
 
176
 
 
177
    # The predefined references
 
178
    refs = dict(core=get_core_plugin_path(),
 
179
                site=get_site_plugin_path(),
 
180
                user=get_user_plugin_path())
 
181
 
 
182
    # Unset paths that should be removed
 
183
    for k,v in refs.iteritems():
 
184
        removed = '-%s' % k
 
185
        # defaults can never mention removing paths as that will make it
 
186
        # impossible for the user to revoke these removals.
 
187
        if removed in env_paths:
 
188
            env_paths.remove(removed)
 
189
            refs[k] = None
 
190
 
 
191
    # Expand references
 
192
    paths = []
 
193
    for p in env_paths + defaults:
 
194
        if p.startswith('+'):
 
195
            # Resolve references if they are known
 
196
            try:
 
197
                p = refs[p[1:]]
 
198
            except KeyError:
 
199
                # Leave them untouched so user can still use paths starting
 
200
                # with '+'
 
201
                pass
 
202
        _append_new_path(paths, p)
 
203
 
 
204
    # Get rid of trailing slashes, since Python can't handle them when
 
205
    # it tries to import modules.
 
206
    paths = map(_strip_trailing_sep, paths)
 
207
    return paths
133
208
 
134
209
 
135
210
def load_plugins(path=None):
140
215
    files (and whatever other extensions are used in the platform,
141
216
    such as *.pyd).
142
217
 
143
 
    load_from_dirs() provides the underlying mechanism and is called with
 
218
    load_from_path() provides the underlying mechanism and is called with
144
219
    the default directory list to provide the normal behaviour.
145
220
 
146
221
    :param path: The list of paths to search for plugins.  By default,
169
244
 
170
245
    The python module path for bzrlib.plugins will be modified to be 'dirs'.
171
246
    """
 
247
    # Explicitly load the plugins with a specific path
 
248
    for fullname, path in PluginImporter.specific_paths.iteritems():
 
249
        name = fullname[len('bzrlib.plugins.'):]
 
250
        _load_plugin_module(name, path)
 
251
 
172
252
    # We need to strip the trailing separators here as well as in the
173
253
    # set_plugins_path function because calling code can pass anything in to
174
254
    # this function, and since it sets plugins.__path__, it should set it to
188
268
load_from_dirs = load_from_path
189
269
 
190
270
 
 
271
def _find_plugin_module(dir, name):
 
272
    """Check if there is a valid python module that can be loaded as a plugin.
 
273
 
 
274
    :param dir: The directory where the search is performed.
 
275
    :param path: An existing file path, either a python file or a package
 
276
        directory.
 
277
 
 
278
    :return: (name, path, description) name is the module name, path is the
 
279
        file to load and description is the tuple returned by
 
280
        imp.get_suffixes().
 
281
    """
 
282
    path = osutils.pathjoin(dir, name)
 
283
    if os.path.isdir(path):
 
284
        # Check for a valid __init__.py file, valid suffixes depends on -O and
 
285
        # can be .py, .pyc and .pyo
 
286
        for suffix, mode, kind in imp.get_suffixes():
 
287
            if kind not in (imp.PY_SOURCE, imp.PY_COMPILED):
 
288
                # We don't recognize compiled modules (.so, .dll, etc)
 
289
                continue
 
290
            init_path = osutils.pathjoin(path, '__init__' + suffix)
 
291
            if os.path.isfile(init_path):
 
292
                return name, init_path, (suffix, mode, kind)
 
293
    else:
 
294
        for suffix, mode, kind in imp.get_suffixes():
 
295
            if name.endswith(suffix):
 
296
                # Clean up the module name
 
297
                name = name[:-len(suffix)]
 
298
                if kind == imp.C_EXTENSION and name.endswith('module'):
 
299
                    name = name[:-len('module')]
 
300
                return name, path, (suffix, mode, kind)
 
301
    # There is no python module here
 
302
    return None, None, (None, None, None)
 
303
 
 
304
 
 
305
def _load_plugin_module(name, dir):
 
306
    """Load plugin name from dir.
 
307
 
 
308
    :param name: The plugin name in the bzrlib.plugins namespace.
 
309
    :param dir: The directory the plugin is loaded from for error messages.
 
310
    """
 
311
    if ('bzrlib.plugins.%s' % name) in PluginImporter.blacklist:
 
312
        return
 
313
    try:
 
314
        exec "import bzrlib.plugins.%s" % name in {}
 
315
    except KeyboardInterrupt:
 
316
        raise
 
317
    except errors.IncompatibleAPI, e:
 
318
        trace.warning("Unable to load plugin %r. It requested API version "
 
319
            "%s of module %s but the minimum exported version is %s, and "
 
320
            "the maximum is %s" %
 
321
            (name, e.wanted, e.api, e.minimum, e.current))
 
322
    except Exception, e:
 
323
        trace.warning("%s" % e)
 
324
        if re.search('\.|-| ', name):
 
325
            sanitised_name = re.sub('[-. ]', '_', name)
 
326
            if sanitised_name.startswith('bzr_'):
 
327
                sanitised_name = sanitised_name[len('bzr_'):]
 
328
            trace.warning("Unable to load %r in %r as a plugin because the "
 
329
                    "file path isn't a valid module name; try renaming "
 
330
                    "it to %r." % (name, dir, sanitised_name))
 
331
        else:
 
332
            trace.warning('Unable to load plugin %r from %r' % (name, dir))
 
333
        trace.log_exception_quietly()
 
334
        if 'error' in debug.debug_flags:
 
335
            trace.print_exception(sys.exc_info(), sys.stderr)
 
336
 
 
337
 
191
338
def load_from_dir(d):
192
339
    """Load the plugins in directory d.
193
340
 
194
341
    d must be in the plugins module path already.
 
342
    This function is called once for each directory in the module path.
195
343
    """
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]
202
344
    plugin_names = set()
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
 
345
    for p in os.listdir(d):
 
346
        name, path, desc = _find_plugin_module(d, p)
 
347
        if name is not None:
 
348
            if name == '__init__':
 
349
                # We do nothing with the __init__.py file in directories from
 
350
                # the bzrlib.plugins module path, we may want to, one day
 
351
                # -- vila 20100316.
 
352
                continue # We don't load __init__.py in the plugins dirs
 
353
            elif getattr(_mod_plugins, name, None) is not None:
 
354
                # The module has already been loaded from another directory
 
355
                # during a previous call.
 
356
                # FIXME: There should be a better way to report masked plugins
 
357
                # -- vila 20100316
 
358
                trace.mutter('Plugin name %s already loaded', name)
220
359
            else:
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)
 
360
                plugin_names.add(name)
229
361
 
230
362
    for name in plugin_names:
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)
 
363
        _load_plugin_module(name, d)
336
364
 
337
365
 
338
366
def plugins():
385
413
        """
386
414
        self.module = module
387
415
 
388
 
    def get_help_text(self, additional_see_also=None):
 
416
    def get_help_text(self, additional_see_also=None, verbose=True):
389
417
        """Return a string with the help for this topic.
390
418
 
391
419
        :param additional_see_also: Additional help topics to be
495
523
        return version_string
496
524
 
497
525
    __version__ = property(_get__version__)
 
526
 
 
527
 
 
528
class _PluginImporter(object):
 
529
    """An importer tailored to bzr specific needs.
 
530
 
 
531
    This is a singleton that takes care of:
 
532
    - disabled plugins specified in 'blacklist',
 
533
    - plugins that needs to be loaded from specific directories.
 
534
    """
 
535
 
 
536
    def __init__(self):
 
537
        self.reset()
 
538
 
 
539
    def reset(self):
 
540
        self.blacklist = set()
 
541
        self.specific_paths = {}
 
542
 
 
543
    def find_module(self, fullname, parent_path=None):
 
544
        """Search a plugin module.
 
545
 
 
546
        Disabled plugins raise an import error, plugins with specific paths
 
547
        returns a specific loader.
 
548
 
 
549
        :return: None if the plugin doesn't need special handling, self
 
550
            otherwise.
 
551
        """
 
552
        if not fullname.startswith('bzrlib.plugins.'):
 
553
            return None
 
554
        if fullname in self.blacklist:
 
555
            raise ImportError('%s is disabled' % fullname)
 
556
        if fullname in self.specific_paths:
 
557
            return self
 
558
        return None
 
559
 
 
560
    def load_module(self, fullname):
 
561
        """Load a plugin from a specific directory."""
 
562
        # We are called only for specific paths
 
563
        plugin_path = self.specific_paths[fullname]
 
564
        loading_path = None
 
565
        package = False
 
566
        if os.path.isdir(plugin_path):
 
567
            for suffix, mode, kind in imp.get_suffixes():
 
568
                if kind not in (imp.PY_SOURCE, imp.PY_COMPILED):
 
569
                    # We don't recognize compiled modules (.so, .dll, etc)
 
570
                    continue
 
571
                init_path = osutils.pathjoin(plugin_path, '__init__' + suffix)
 
572
                if os.path.isfile(init_path):
 
573
                    loading_path = init_path
 
574
                    package = True
 
575
                    break
 
576
        else:
 
577
            for suffix, mode, kind in imp.get_suffixes():
 
578
                if plugin_path.endswith(suffix):
 
579
                    loading_path = plugin_path
 
580
                    break
 
581
        if loading_path is None:
 
582
            raise ImportError('%s cannot be loaded from %s'
 
583
                              % (fullname, plugin_path))
 
584
        f = open(loading_path, mode)
 
585
        try:
 
586
            mod = imp.load_module(fullname, f, loading_path,
 
587
                                  (suffix, mode, kind))
 
588
            if package:
 
589
                # The plugin can contain modules, so be ready
 
590
                mod.__path__ = [plugin_path]
 
591
            mod.__package__ = fullname
 
592
            return mod
 
593
        finally:
 
594
            f.close()
 
595
 
 
596
 
 
597
# Install a dedicated importer for plugins requiring special handling
 
598
PluginImporter = _PluginImporter()
 
599
sys.meta_path.append(PluginImporter)