/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: Vincent Ladeuil
  • Date: 2010-03-24 13:58:37 UTC
  • mfrom: (5086.5.12 82693-plugin-at-path)
  • mto: This revision was merged to the branch mainline in revision 5108.
  • Revision ID: v.ladeuil+lp@free.fr-20100324135837-06hiz4gj3b29zlr0
https://launchpad.net/bugs/82693
Add BZR_PLUGINS_AT support to specify a directory for a given plugin

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/plugin.py
91
91
    if path is None:
92
92
        path = get_standard_plugins_path()
93
93
    _mod_plugins.__path__ = path
94
 
    # Set up a blacklist for disabled plugins if any
95
 
    PluginBlackListImporter.blacklist = {}
 
94
    PluginImporter.reset()
 
95
    # Set up a blacklist for disabled plugins
96
96
    disabled_plugins = os.environ.get('BZR_DISABLE_PLUGINS', None)
97
97
    if disabled_plugins is not None:
98
98
        for name in disabled_plugins.split(os.pathsep):
99
 
            PluginBlackListImporter.blacklist['bzrlib.plugins.' + name] = True
 
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
100
107
    return path
101
108
 
102
109
 
237
244
 
238
245
    The python module path for bzrlib.plugins will be modified to be 'dirs'.
239
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
 
240
252
    # We need to strip the trailing separators here as well as in the
241
253
    # set_plugins_path function because calling code can pass anything in to
242
254
    # this function, and since it sets plugins.__path__, it should set it to
256
268
load_from_dirs = load_from_path
257
269
 
258
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 plugine 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
 
259
338
def load_from_dir(d):
260
339
    """Load the plugins in directory d.
261
340
 
262
341
    d must be in the plugins module path already.
 
342
    This function is called once for each directory in the module path.
263
343
    """
264
 
    # Get the list of valid python suffixes for __init__.py?
265
 
    # this includes .py, .pyc, and .pyo (depending on if we are running -O)
266
 
    # but it doesn't include compiled modules (.so, .dll, etc)
267
 
    valid_suffixes = [suffix for suffix, mod_type, flags in imp.get_suffixes()
268
 
                              if flags in (imp.PY_SOURCE, imp.PY_COMPILED)]
269
 
    package_entries = ['__init__'+suffix for suffix in valid_suffixes]
270
344
    plugin_names = set()
271
 
    for f in os.listdir(d):
272
 
        path = osutils.pathjoin(d, f)
273
 
        if os.path.isdir(path):
274
 
            for entry in package_entries:
275
 
                # This directory should be a package, and thus added to
276
 
                # the list
277
 
                if os.path.isfile(osutils.pathjoin(path, entry)):
278
 
                    break
279
 
            else: # This directory is not a package
280
 
                continue
281
 
        else:
282
 
            for suffix_info in imp.get_suffixes():
283
 
                if f.endswith(suffix_info[0]):
284
 
                    f = f[:-len(suffix_info[0])]
285
 
                    if suffix_info[2] == imp.C_EXTENSION and f.endswith('module'):
286
 
                        f = f[:-len('module')]
287
 
                    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)
288
359
            else:
289
 
                continue
290
 
        if f == '__init__':
291
 
            continue # We don't load __init__.py again in the plugin dir
292
 
        elif getattr(_mod_plugins, f, None):
293
 
            trace.mutter('Plugin name %s already loaded', f)
294
 
        else:
295
 
            # trace.mutter('add plugin name %s', f)
296
 
            plugin_names.add(f)
 
360
                plugin_names.add(name)
297
361
 
298
362
    for name in plugin_names:
299
 
        if ('bzrlib.plugins.%s' % name) in PluginBlackListImporter.blacklist:
300
 
            continue
301
 
        try:
302
 
            exec "import bzrlib.plugins.%s" % name in {}
303
 
        except KeyboardInterrupt:
304
 
            raise
305
 
        except errors.IncompatibleAPI, e:
306
 
            trace.warning("Unable to load plugin %r. It requested API version "
307
 
                "%s of module %s but the minimum exported version is %s, and "
308
 
                "the maximum is %s" %
309
 
                (name, e.wanted, e.api, e.minimum, e.current))
310
 
        except Exception, e:
311
 
            trace.warning("%s" % e)
312
 
            ## import pdb; pdb.set_trace()
313
 
            if re.search('\.|-| ', name):
314
 
                sanitised_name = re.sub('[-. ]', '_', name)
315
 
                if sanitised_name.startswith('bzr_'):
316
 
                    sanitised_name = sanitised_name[len('bzr_'):]
317
 
                trace.warning("Unable to load %r in %r as a plugin because the "
318
 
                        "file path isn't a valid module name; try renaming "
319
 
                        "it to %r." % (name, d, sanitised_name))
320
 
            else:
321
 
                trace.warning('Unable to load plugin %r from %r' % (name, d))
322
 
            trace.log_exception_quietly()
323
 
            if 'error' in debug.debug_flags:
324
 
                trace.print_exception(sys.exc_info(), sys.stderr)
 
363
        _load_plugin_module(name, d)
325
364
 
326
365
 
327
366
def plugins():
486
525
    __version__ = property(_get__version__)
487
526
 
488
527
 
489
 
class _PluginBlackListImporter(object):
 
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
    """
490
535
 
491
536
    def __init__(self):
492
 
        self.blacklist = {}
 
537
        self.reset()
 
538
 
 
539
    def reset(self):
 
540
        self.blacklist = set()
 
541
        self.specific_paths = {}
493
542
 
494
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
495
554
        if fullname in self.blacklist:
496
555
            raise ImportError('%s is disabled' % fullname)
 
556
        if fullname in self.specific_paths:
 
557
            return self
497
558
        return None
498
559
 
499
 
PluginBlackListImporter = _PluginBlackListImporter()
500
 
sys.meta_path.append(PluginBlackListImporter)
501
 
 
502
 
 
 
560
    def load_module(self, fullname):
 
561
        """Load a plugin from a specific directory."""
 
562
        # We are called only for specific paths
 
563
        plugin_dir = self.specific_paths[fullname]
 
564
        candidate = None
 
565
        maybe_package = False
 
566
        for p in os.listdir(plugin_dir):
 
567
            if os.path.isdir(osutils.pathjoin(plugin_dir, p)):
 
568
                # We're searching for files only and don't want submodules to
 
569
                # be recognized as plugins (they are submodules inside the
 
570
                # plugin).
 
571
                continue
 
572
            name, path, (
 
573
                suffix, mode, kind) = _find_plugin_module(plugin_dir, p)
 
574
            if name is not None:
 
575
                candidate = (name, path, suffix, mode, kind)
 
576
                if kind == imp.PY_SOURCE:
 
577
                    # We favour imp.PY_SOURCE (which will use the compiled
 
578
                    # version if available) over imp.PY_COMPILED (which is used
 
579
                    # only if the source is not available)
 
580
                    break
 
581
        if candidate is None:
 
582
            raise ImportError('%s cannot be loaded from %s'
 
583
                              % (fullname, plugin_dir))
 
584
        f = open(path, mode)
 
585
        try:
 
586
            mod = imp.load_module(fullname, f, path, (suffix, mode, kind))
 
587
            # The plugin can contain modules, so be ready
 
588
            mod.__path__ = [plugin_dir]
 
589
            mod.__package__ = fullname
 
590
            return mod
 
591
        finally:
 
592
            f.close()
 
593
 
 
594
 
 
595
# Install a dedicated importer for plugins requiring special handling
 
596
PluginImporter = _PluginImporter()
 
597
sys.meta_path.append(PluginImporter)