← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/module/loader.cc

  • Committer: pcrews
  • Date: 2011-05-24 17:36:24 UTC
  • mfrom: (1099.4.232 drizzle)
  • Revision ID: pcrews@lucid32-20110524173624-mwr1bvq6fa1r01ao
Updated translations + 2011.05.18 tarball tag

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/module/loader.cc
13
13
   along with this program; if not, write to the Free Software
14
14
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
15
15
 
16
 
#include "config.h"
 
16
#include <config.h>
17
17
 
18
18
#include <dlfcn.h>
19
19
 
26
26
 
27
27
#include <boost/program_options.hpp>
28
28
 
29
 
#include "drizzled/option.h"
30
 
#include "drizzled/internal/m_string.h"
 
29
#include <drizzled/option.h>
 
30
#include <drizzled/internal/m_string.h>
31
31
 
32
 
#include "drizzled/plugin.h"
33
 
#include "drizzled/module/load_list.h"
34
 
#include "drizzled/module/library.h"
35
 
#include "drizzled/module/registry.h"
36
 
#include "drizzled/module/option_context.h"
37
 
#include "drizzled/sql_parse.h"
38
 
#include "drizzled/show.h"
39
 
#include "drizzled/cursor.h"
40
 
#include "drizzled/set_var.h"
41
 
#include "drizzled/session.h"
42
 
#include "drizzled/item/null.h"
43
 
#include "drizzled/error.h"
44
 
#include "drizzled/gettext.h"
45
 
#include "drizzled/errmsg_print.h"
46
 
#include "drizzled/strfunc.h"
47
 
#include "drizzled/pthread_globals.h"
48
 
#include "drizzled/util/tokenize.h"
 
32
#include <drizzled/plugin.h>
 
33
#include <drizzled/module/load_list.h>
 
34
#include <drizzled/module/library.h>
 
35
#include <drizzled/module/registry.h>
 
36
#include <drizzled/module/option_context.h>
 
37
#include <drizzled/sql_parse.h>
 
38
#include <drizzled/show.h>
 
39
#include <drizzled/cursor.h>
 
40
#include <drizzled/set_var.h>
 
41
#include <drizzled/session.h>
 
42
#include <drizzled/item/null.h>
 
43
#include <drizzled/error.h>
 
44
#include <drizzled/gettext.h>
 
45
#include <drizzled/errmsg_print.h>
 
46
#include <drizzled/pthread_globals.h>
 
47
#include <drizzled/util/tokenize.h>
 
48
#include <drizzled/system_variables.h>
49
49
 
50
50
#include <boost/foreach.hpp>
51
51
 
71
71
  PANDORA_BUILTIN_LOAD_SYMBOLS_LIST, NULL
72
72
};
73
73
 
74
 
namespace drizzled
75
 
{
 
74
namespace drizzled {
76
75
 
77
76
 
78
77
typedef vector<string> PluginOptions;
167
166
    return false;
168
167
  }
169
168
 
170
 
  module::Module *tmp= NULL;
171
169
  /* Find plugin by name */
172
170
  const module::Manifest *manifest= library->getManifest();
173
171
 
181
179
    return true;
182
180
  }
183
181
 
184
 
  tmp= new (std::nothrow) module::Module(manifest, library);
185
 
  if (tmp == NULL)
186
 
    return true;
 
182
  module::Module* tmp= new module::Module(manifest, library);
187
183
 
188
184
  if (!test_plugin_options(tmp_root, tmp, long_options))
189
185
  {
198
194
 
199
195
static void reap_plugins(module::Registry &registry)
200
196
{
201
 
  std::map<std::string, module::Module *>::const_iterator modules=
202
 
    registry.getModulesMap().begin();
203
 
 
204
 
  while (modules != registry.getModulesMap().end())
205
 
  {
206
 
    module::Module *module= (*modules).second;
207
 
    delete module;
208
 
    ++modules;
209
 
  }
 
197
  BOOST_FOREACH(module::Registry::ModuleMap::const_reference module, registry.getModulesMap())
 
198
    delete module.second;
210
199
}
211
200
 
212
201
 
227
216
    }
228
217
  }
229
218
  module->isInited= true;
230
 
 
231
 
 
232
219
  return false;
233
220
}
234
221
 
235
 
 
236
 
inline static void dashes_to_underscores(std::string &name_in,
237
 
                                         char from= '-', char to= '_')
238
 
{
239
 
  for (string::iterator p= name_in.begin();
240
 
       p != name_in.end();
241
 
       ++p)
242
 
  {
243
 
    if (*p == from)
244
 
    {
245
 
      *p= to;
246
 
    }
247
 
  }
248
 
}
249
 
 
250
 
inline static void underscores_to_dashes(std::string &name_in)
251
 
{
252
 
  return dashes_to_underscores(name_in, '_', '-');
253
 
}
254
 
 
255
222
static void compose_plugin_options(vector<string> &target,
256
223
                                   vector<string> options)
257
224
{
258
 
  for (vector<string>::iterator it= options.begin();
259
 
       it != options.end();
260
 
       ++it)
261
 
  {
262
 
    tokenize(*it, target, ",", true);
263
 
  }
264
 
  for (vector<string>::iterator it= target.begin();
265
 
       it != target.end();
266
 
       ++it)
267
 
  {
268
 
    dashes_to_underscores(*it);
269
 
  }
 
225
  BOOST_FOREACH(vector<string>::reference it, options)
 
226
    tokenize(it, target, ",", true);
 
227
  BOOST_FOREACH(vector<string>::reference it, target)
 
228
    std::replace(it.begin(), it.end(), '-', '_');
270
229
}
271
230
 
272
231
void compose_plugin_add(vector<string> options)
294
253
bool plugin_init(module::Registry &registry,
295
254
                 po::options_description &long_options)
296
255
{
297
 
  memory::Root tmp_root(4096);
298
 
 
299
256
  if (initialized)
300
257
    return false;
301
258
 
302
 
  initialized= 1;
 
259
  initialized= true;
303
260
 
304
261
  PluginOptions builtin_load_list;
305
262
  tokenize(builtin_load_plugins, builtin_load_list, ",", true);
333
290
    plugin_prune_list(builtin_load_list, opt_plugin_remove);
334
291
  }
335
292
 
336
 
 
 
293
  memory::Root tmp_root(4096);
337
294
  /*
338
295
    First we register builtin plugins
339
296
  */
370
327
  /*
371
328
    Now we initialize all remaining plugins
372
329
  */
373
 
  module::Registry::ModuleList module_list= registry.getList();
374
 
  module::Registry::ModuleList::iterator modules= module_list.begin();
375
 
    
376
 
  while (modules != module_list.end())
 
330
  BOOST_FOREACH(module::Registry::ModuleList::const_reference module, registry.getList())
377
331
  {
378
 
    module::Module *module= *modules;
379
 
    ++modules;
380
 
    if (module->isInited == false)
 
332
    if (not module->isInited && plugin_initialize(registry, module))
381
333
    {
382
 
      if (plugin_initialize(registry, module))
383
 
      {
384
 
        registry.remove(module);
385
 
        delete module;
386
 
        return true;
387
 
      }
 
334
      registry.remove(module);
 
335
      delete module;
 
336
      return true;
388
337
    }
389
338
  }
390
 
 
391
 
 
392
339
  BOOST_FOREACH(plugin::Plugin::map::value_type value, registry.getPluginsMap())
393
340
  {
394
341
    value.second->prime();
395
342
  }
396
 
 
397
343
  return false;
398
344
}
399
345
 
448
394
                             po::options_description &long_options,
449
395
                             bool builtin)
450
396
{
451
 
  module::Library *library= NULL;
452
 
 
453
 
  for (set<string>::const_iterator iter= plugin_list.begin();
454
 
       iter != plugin_list.end();
455
 
       ++iter)
 
397
  BOOST_FOREACH(const string& plugin_name, plugin_list)
456
398
  {
457
 
    const string plugin_name(*iter);
458
 
 
459
 
    library= registry.addLibrary(plugin_name, builtin);
 
399
    module::Library* library= registry.addLibrary(plugin_name, builtin);
460
400
    if (library == NULL)
461
401
    {
462
402
      errmsg_printf(error::ERROR,
473
413
                    _("Couldn't load plugin named '%s'.\n"),
474
414
                    plugin_name.c_str());
475
415
      return true;
476
 
 
477
416
    }
478
417
  }
479
418
  return false;