/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: 2007-02-02 16:17:55 UTC
  • mto: (2257.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 2258.
  • Revision ID: robertc@robertcollins.net-20070202161755-zy2d68928wqwehj6
Allow 'import bzrlib.plugins.NAME' to work when the plugin NAME has not
yet been loaded by load_plugins(). This allows plugins to depend on each
other for code reuse without requiring users to perform file-renaming
gymnastics. (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/plugin.py
1
 
# Copyright (C) 2004, 2005 by Canonical Ltd
2
 
 
 
1
# Copyright (C) 2004, 2005 Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
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.
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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
 
"""bzr python plugin support
19
 
 
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.
 
18
"""bzr python plugin support.
 
19
 
 
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; for example, to add new
 
24
commands, import bzrlib.commands and add your new command to the plugin_cmds
 
25
variable.
 
26
 
 
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 
 
29
called.
25
30
"""
26
31
 
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.
31
 
# 
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
36
 
#
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.
41
 
 
42
 
import imp
43
32
import os
44
33
import sys
 
34
 
 
35
from bzrlib.lazy_import import lazy_import
 
36
lazy_import(globals(), """
 
37
import imp
45
38
import types
46
 
 
47
 
import bzrlib
48
 
from bzrlib.config import config_dir
49
 
from bzrlib.trace import log_error, mutter, log_exception, warning, \
50
 
        log_exception_quietly
51
 
from bzrlib.errors import BzrError
52
 
from bzrlib import plugins
53
 
from bzrlib.osutils import pathjoin
54
 
 
55
 
DEFAULT_PLUGIN_PATH = pathjoin(config_dir(), 'plugins')
56
 
 
 
39
import zipimport
 
40
 
 
41
from bzrlib import (
 
42
    config,
 
43
    osutils,
 
44
    plugins,
 
45
    )
 
46
""")
 
47
 
 
48
from bzrlib.trace import mutter, warning, log_exception_quietly
 
49
 
 
50
 
 
51
DEFAULT_PLUGIN_PATH = None
57
52
_loaded = False
58
53
 
 
54
def get_default_plugin_path():
 
55
    """Get the DEFAULT_PLUGIN_PATH"""
 
56
    global DEFAULT_PLUGIN_PATH
 
57
    if DEFAULT_PLUGIN_PATH is None:
 
58
        DEFAULT_PLUGIN_PATH = osutils.pathjoin(config.config_dir(), 'plugins')
 
59
    return DEFAULT_PLUGIN_PATH
 
60
 
59
61
 
60
62
def all_plugins():
61
63
    """Return a dictionary of the plugins."""
62
64
    result = {}
63
 
    for name, plugin in bzrlib.plugins.__dict__.items():
 
65
    for name, plugin in plugins.__dict__.items():
64
66
        if isinstance(plugin, types.ModuleType):
65
67
            result[name] = plugin
66
68
    return result
77
79
    _loaded = True
78
80
 
79
81
 
 
82
def set_plugins_path():
 
83
    """Set the path for plugins to be loaded from."""
 
84
    path = os.environ.get('BZR_PLUGIN_PATH',
 
85
                          get_default_plugin_path()).split(os.pathsep)
 
86
    # search the bzrlib installed dir before anything else.
 
87
    path.insert(0, os.path.dirname(plugins.__file__))
 
88
    plugins.__path__ = path
 
89
    return path
 
90
 
 
91
 
80
92
def load_plugins():
81
93
    """Load bzrlib plugins.
82
94
 
92
104
    if _loaded:
93
105
        # People can make sure plugins are loaded, they just won't be twice
94
106
        return
95
 
        #raise BzrError("plugins already initialized")
96
107
    _loaded = True
97
108
 
98
 
    dirs = os.environ.get('BZR_PLUGIN_PATH', DEFAULT_PLUGIN_PATH).split(os.pathsep)
99
 
    dirs.insert(0, os.path.dirname(plugins.__file__))
100
 
 
101
 
    load_from_dirs(dirs)
102
 
 
103
 
 
104
 
def load_from_dirs(dirs):
 
109
    # scan for all plugins in the path.
 
110
    load_from_path(set_plugins_path())
 
111
 
 
112
 
 
113
def load_from_path(dirs):
105
114
    """Load bzrlib plugins found in each dir in dirs.
106
115
 
107
116
    Loading a plugin means importing it into the python interpreter.
110
119
 
111
120
    Plugins are loaded into bzrlib.plugins.NAME, and can be found there
112
121
    for future reference.
 
122
 
 
123
    The python module path for bzrlib.plugins will be modified to be 'dirs'.
113
124
    """
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']
 
125
    plugins.__path__ = dirs
122
126
    for d in dirs:
123
127
        if not d:
124
128
            continue
125
129
        mutter('looking for plugins in %s', d)
126
 
        plugin_names = set()
127
 
        if not os.path.isdir(d):
128
 
            continue
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
134
 
                    # the list
135
 
                    if os.path.isfile(pathjoin(path, entry)):
136
 
                        break
137
 
                else: # This directory is not a package
138
 
                    continue
139
 
            else:
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')]
145
 
                        break
146
 
                else:
147
 
                    continue
148
 
            if getattr(bzrlib.plugins, f, None):
149
 
                mutter('Plugin name %s already loaded', f)
150
 
            else:
151
 
                mutter('add plugin name %s', f)
152
 
                plugin_names.add(f)
153
 
 
154
 
        plugin_names = list(plugin_names)
155
 
        plugin_names.sort()
156
 
        for name in plugin_names:
157
 
            try:
158
 
                plugin_info = imp.find_module(name, [d])
159
 
                mutter('load plugin %r', plugin_info)
160
 
                try:
161
 
                    plugin = imp.load_module('bzrlib.plugins.' + name,
162
 
                                             *plugin_info)
163
 
                    setattr(bzrlib.plugins, name, plugin)
164
 
                finally:
165
 
                    if plugin_info[0] is not None:
166
 
                        plugin_info[0].close()
167
 
 
168
 
                mutter('loaded succesfully')
169
 
            except KeyboardInterrupt:
170
 
                raise
171
 
            except Exception, e:
172
 
                ## import pdb; pdb.set_trace()
173
 
                warning('Unable to load plugin %r from %r' % (name, d))
174
 
                log_exception_quietly()
 
130
        if os.path.isdir(d):
 
131
            load_from_dir(d)
 
132
        else:
 
133
            # it might be a zip: try loading from the zip.
 
134
            load_from_zip(d)
 
135
            continue
 
136
 
 
137
 
 
138
# backwards compatability: load_from_dirs was the old name
 
139
# This was changed in 0.15
 
140
load_from_dirs = load_from_path
 
141
 
 
142
 
 
143
def load_from_dir(d):
 
144
    """Load the plugins in directory d."""
 
145
    # Get the list of valid python suffixes for __init__.py?
 
146
    # this includes .py, .pyc, and .pyo (depending on if we are running -O)
 
147
    # but it doesn't include compiled modules (.so, .dll, etc)
 
148
    valid_suffixes = [suffix for suffix, mod_type, flags in imp.get_suffixes()
 
149
                              if flags in (imp.PY_SOURCE, imp.PY_COMPILED)]
 
150
    package_entries = ['__init__'+suffix for suffix in valid_suffixes]
 
151
    plugin_names = set()
 
152
    for f in os.listdir(d):
 
153
        path = osutils.pathjoin(d, f)
 
154
        if os.path.isdir(path):
 
155
            for entry in package_entries:
 
156
                # This directory should be a package, and thus added to
 
157
                # the list
 
158
                if os.path.isfile(osutils.pathjoin(path, entry)):
 
159
                    break
 
160
            else: # This directory is not a package
 
161
                continue
 
162
        else:
 
163
            for suffix_info in imp.get_suffixes():
 
164
                if f.endswith(suffix_info[0]):
 
165
                    f = f[:-len(suffix_info[0])]
 
166
                    if suffix_info[2] == imp.C_EXTENSION and f.endswith('module'):
 
167
                        f = f[:-len('module')]
 
168
                    break
 
169
            else:
 
170
                continue
 
171
        if getattr(plugins, f, None):
 
172
            mutter('Plugin name %s already loaded', f)
 
173
        else:
 
174
            # mutter('add plugin name %s', f)
 
175
            plugin_names.add(f)
 
176
    
 
177
    for name in plugin_names:
 
178
        try:
 
179
            exec "import bzrlib.plugins.%s" % name
 
180
        except KeyboardInterrupt:
 
181
            raise
 
182
        except Exception, e:
 
183
            ## import pdb; pdb.set_trace()
 
184
            warning('Unable to load plugin %r from %r' % (name, d))
 
185
            log_exception_quietly()
 
186
 
 
187
 
 
188
def load_from_zip(zip_name):
 
189
    """Load all the plugins in a zip."""
 
190
    valid_suffixes = ('.py', '.pyc', '.pyo')    # only python modules/packages
 
191
                                                # is allowed
 
192
    if '.zip' not in zip_name:
 
193
        return
 
194
    try:
 
195
        ziobj = zipimport.zipimporter(zip_name)
 
196
    except zipimport.ZipImportError:
 
197
        # not a valid zip
 
198
        return
 
199
    mutter('Looking for plugins in %r', zip_name)
 
200
    
 
201
    import zipfile
 
202
 
 
203
    # use zipfile to get list of files/dirs inside zip
 
204
    z = zipfile.ZipFile(ziobj.archive)
 
205
    namelist = z.namelist()
 
206
    z.close()
 
207
    
 
208
    if ziobj.prefix:
 
209
        prefix = ziobj.prefix.replace('\\','/')
 
210
        ix = len(prefix)
 
211
        namelist = [name[ix:]
 
212
                    for name in namelist
 
213
                    if name.startswith(prefix)]
 
214
    
 
215
    mutter('Names in archive: %r', namelist)
 
216
    
 
217
    for name in namelist:
 
218
        if not name or name.endswith('/'):
 
219
            continue
 
220
    
 
221
        # '/' is used to separate pathname components inside zip archives
 
222
        ix = name.rfind('/')
 
223
        if ix == -1:
 
224
            head, tail = '', name
 
225
        else:
 
226
            head, tail = name.rsplit('/',1)
 
227
        if '/' in head:
 
228
            # we don't need looking in subdirectories
 
229
            continue
 
230
    
 
231
        base, suffix = osutils.splitext(tail)
 
232
        if suffix not in valid_suffixes:
 
233
            continue
 
234
    
 
235
        if base == '__init__':
 
236
            # package
 
237
            plugin_name = head
 
238
        elif head == '':
 
239
            # module
 
240
            plugin_name = base
 
241
        else:
 
242
            continue
 
243
    
 
244
        if not plugin_name:
 
245
            continue
 
246
        if getattr(plugins, plugin_name, None):
 
247
            mutter('Plugin name %s already loaded', plugin_name)
 
248
            continue
 
249
    
 
250
        try:
 
251
            plugin = ziobj.load_module(plugin_name)
 
252
            setattr(plugins, plugin_name, plugin)
 
253
            mutter('Load plugin %s from zip %r', plugin_name, zip_name)
 
254
        except zipimport.ZipImportError, e:
 
255
            mutter('Unable to load plugin %r from %r: %s',
 
256
                   plugin_name, zip_name, str(e))
 
257
            continue
 
258
        except KeyboardInterrupt:
 
259
            raise
 
260
        except Exception, e:
 
261
            ## import pdb; pdb.set_trace()
 
262
            warning('Unable to load plugin %r from %r'
 
263
                    % (name, zip_name))
 
264
            log_exception_quietly()