← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/module/loader.cc

  • Committer: Brian Aker
  • Date: 2010-05-21 18:25:00 UTC
  • mfrom: (1530.2.10)
  • Revision ID: brian@gaz-20100521182500-c30dbqd2ko56cf56
Merge Monty

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/module/loader.cc
28
28
#include "drizzled/internal/m_string.h"
29
29
 
30
30
#include "drizzled/plugin.h"
31
 
#include "drizzled/plugin/load_list.h"
 
31
#include "drizzled/module/load_list.h"
 
32
#include "drizzled/module/library.h"
 
33
#include "drizzled/module/registry.h"
32
34
#include "drizzled/sql_parse.h"
33
35
#include "drizzled/show.h"
34
36
#include "drizzled/cursor.h"
35
37
#include "drizzled/set_var.h"
36
38
#include "drizzled/session.h"
37
39
#include "drizzled/item/null.h"
38
 
#include "drizzled/plugin/registry.h"
39
40
#include "drizzled/error.h"
40
41
#include "drizzled/gettext.h"
41
42
#include "drizzled/errmsg_print.h"
42
 
#include "drizzled/plugin/library.h"
43
43
#include "drizzled/strfunc.h"
44
44
#include "drizzled/pthread_globals.h"
45
45
#include "drizzled/util/tokenize.h"
51
51
 
52
52
using namespace std;
53
53
 
54
 
typedef drizzled::plugin::Manifest drizzled_builtin_plugin[];
55
 
extern drizzled_builtin_plugin PANDORA_BUILTIN_LIST;
56
 
static drizzled::plugin::Manifest *drizzled_builtins[]=
 
54
/** These exist just to prevent symbols from being optimized out */
 
55
typedef drizzled::module::Manifest drizzled_builtin_list[];
 
56
extern drizzled_builtin_list PANDORA_BUILTIN_SYMBOLS_LIST;
 
57
drizzled::module::Manifest *drizzled_builtins[]=
57
58
{
58
 
  PANDORA_BUILTIN_LIST, NULL
 
59
  PANDORA_BUILTIN_SYMBOLS_LIST, NULL
59
60
};
60
61
 
61
62
namespace drizzled
71
72
char *opt_plugin_dir_ptr;
72
73
char opt_plugin_dir[FN_REFLEN];
73
74
const char *opt_plugin_load_default= PANDORA_PLUGIN_LIST;
 
75
const char *builtin_plugins= PANDORA_BUILTIN_LIST;
74
76
 
75
77
/* Note that 'int version' must be the first field of every plugin
76
78
   sub-structure (plugin->info).
126
128
class sys_var_pluginvar: public sys_var
127
129
{
128
130
public:
129
 
  plugin::Module *plugin;
 
131
  module::Module *plugin;
130
132
  drizzle_sys_var *plugin_var;
131
133
 
132
134
  sys_var_pluginvar(const std::string name_arg,
153
155
/* prototypes */
154
156
static void plugin_prune_list(vector<string> &plugin_list,
155
157
                              const vector<string> &plugins_to_remove);
156
 
static bool plugin_load_list(plugin::Registry &registry,
 
158
static bool plugin_load_list(module::Registry &registry,
157
159
                             memory::Root *tmp_root, int *argc, char **argv,
158
 
                             const set<string> &plugin_list);
159
 
static int test_plugin_options(memory::Root *, plugin::Module *,
 
160
                             const set<string> &plugin_list,
 
161
                             bool builtin= false);
 
162
static int test_plugin_options(memory::Root *, module::Module *,
160
163
                               int *, char **);
161
164
static void unlock_variables(Session *session, struct system_variables *vars);
162
165
static void cleanup_variables(Session *session, struct system_variables *vars);
239
242
  NOTE
240
243
    Requires that a write-lock is held on LOCK_system_variables_hash
241
244
*/
242
 
static bool plugin_add(plugin::Registry &registry, memory::Root *tmp_root,
243
 
                       plugin::Library *library,
 
245
static bool plugin_add(module::Registry &registry, memory::Root *tmp_root,
 
246
                       module::Library *library,
244
247
                       int *argc, char **argv)
245
248
{
246
249
  if (! initialized)
253
256
    return false;
254
257
  }
255
258
 
256
 
  plugin::Module *tmp= NULL;
 
259
  module::Module *tmp= NULL;
257
260
  /* Find plugin by name */
258
 
  const plugin::Manifest *manifest= library->getManifest();
 
261
  const module::Manifest *manifest= library->getManifest();
259
262
 
260
263
  if (registry.find(manifest->name))
261
264
  {
267
270
    return true;
268
271
  }
269
272
 
270
 
  tmp= new (std::nothrow) plugin::Module(manifest, library);
 
273
  tmp= new (std::nothrow) module::Module(manifest, library);
271
274
  if (tmp == NULL)
272
275
    return true;
273
276
 
282
285
}
283
286
 
284
287
 
285
 
static void delete_module(plugin::Module *module)
 
288
static void delete_module(module::Module *module)
286
289
{
287
290
  /* Free allocated strings before deleting the plugin. */
288
291
  plugin_vars_free_values(module->system_vars);
294
297
}
295
298
 
296
299
 
297
 
static void reap_plugins(plugin::Registry &registry)
 
300
static void reap_plugins(module::Registry &registry)
298
301
{
299
 
  std::map<std::string, plugin::Module *>::const_iterator modules=
 
302
  std::map<std::string, module::Module *>::const_iterator modules=
300
303
    registry.getModulesMap().begin();
301
304
 
302
305
  while (modules != registry.getModulesMap().end())
303
306
  {
304
 
    plugin::Module *module= (*modules).second;
 
307
    module::Module *module= (*modules).second;
305
308
    delete_module(module);
306
309
    ++modules;
307
310
  }
310
313
}
311
314
 
312
315
 
313
 
static void plugin_initialize_vars(plugin::Module *module)
 
316
static void plugin_initialize_vars(module::Module *module)
314
317
{
315
318
  /*
316
319
    set the plugin attribute of plugin's sys vars so they are pointing
330
333
}
331
334
 
332
335
 
333
 
static bool plugin_initialize(plugin::Registry &registry,
334
 
                              plugin::Module *module)
 
336
static bool plugin_initialize(module::Registry &registry,
 
337
                              module::Module *module)
335
338
{
336
339
  assert(module->isInited == false);
337
340
 
338
 
  plugin::Context loading_context(registry, module);
 
341
  module::Context loading_context(registry, module);
339
342
  if (module->getManifest().init)
340
343
  {
341
344
    if (module->getManifest().init(loading_context))
369
372
 
370
373
  Finally we initialize everything, aka the dynamic that have yet to initialize.
371
374
*/
372
 
bool plugin_init(plugin::Registry &registry,
 
375
bool plugin_init(module::Registry &registry,
373
376
                 int *argc, char **argv,
374
377
                 bool skip_init)
375
378
{
376
 
  plugin::Manifest **builtins;
377
 
  plugin::Manifest *manifest;
378
 
  plugin::Module *module;
 
379
  module::Module *module;
379
380
  memory::Root tmp_root(4096);
380
381
 
381
382
  if (initialized)
391
392
 
392
393
  initialized= 1;
393
394
 
394
 
  /*
395
 
    First we register builtin plugins
396
 
  */
397
 
  for (builtins= drizzled_builtins; *builtins; builtins++)
398
 
  {
399
 
    manifest= *builtins;
400
 
    if (manifest->name != NULL)
401
 
    {
402
 
      module= new (std::nothrow) plugin::Module(manifest);
403
 
      if (module == NULL)
404
 
        return true;
405
 
 
406
 
      tmp_root.free_root(MYF(memory::MARK_BLOCKS_FREE));
407
 
      if (test_plugin_options(&tmp_root, module, argc, argv))
408
 
        continue;
409
 
 
410
 
      registry.add(module);
411
 
 
412
 
      plugin_initialize_vars(module);
413
 
 
414
 
      if (! skip_init)
415
 
      {
416
 
        if (plugin_initialize(registry, module))
417
 
        {
418
 
          tmp_root.free_root(MYF(0));
419
 
          return true;
420
 
        }
421
 
      }
422
 
    }
423
 
  }
424
 
 
 
395
  vector<string> builtin_list;
 
396
  tokenize(builtin_plugins, builtin_list, ",", true);
425
397
 
426
398
  bool load_failed= false;
427
399
  vector<string> plugin_list;
443
415
    vector<string> plugins_to_remove;
444
416
    tokenize(opt_plugin_remove, plugins_to_remove, ",", true);
445
417
    plugin_prune_list(plugin_list, plugins_to_remove);
 
418
    plugin_prune_list(builtin_list, plugins_to_remove);
 
419
  }
 
420
 
 
421
 
 
422
  /*
 
423
    First we register builtin plugins
 
424
  */
 
425
  const set<string> builtin_list_set(builtin_list.begin(), builtin_list.end());
 
426
  load_failed= plugin_load_list(registry, &tmp_root, argc, argv,
 
427
                                builtin_list_set, true);
 
428
  if (load_failed)
 
429
  {
 
430
    tmp_root.free_root(MYF(0));
 
431
    return true;
446
432
  }
447
433
 
448
434
  /* Uniquify the list */
466
452
  /*
467
453
    Now we initialize all remaining plugins
468
454
  */
469
 
  std::map<std::string, plugin::Module *>::const_iterator modules=
 
455
  std::map<std::string, module::Module *>::const_iterator modules=
470
456
    registry.getModulesMap().begin();
471
457
    
472
458
  while (modules != registry.getModulesMap().end())
522
508
/*
523
509
  called only by plugin_init()
524
510
*/
525
 
static bool plugin_load_list(plugin::Registry &registry,
 
511
static bool plugin_load_list(module::Registry &registry,
526
512
                             memory::Root *tmp_root, int *argc, char **argv,
527
 
                             const set<string> &plugin_list)
 
513
                             const set<string> &plugin_list,
 
514
                             bool builtin)
528
515
{
529
 
  plugin::Library *library= NULL;
 
516
  module::Library *library= NULL;
530
517
 
531
518
  for (set<string>::const_iterator iter= plugin_list.begin();
532
519
       iter != plugin_list.end();
533
520
       ++iter)
534
521
  {
535
522
    const string plugin_name(*iter);
536
 
    library= registry.addLibrary(plugin_name);
 
523
 
 
524
    library= registry.addLibrary(plugin_name, builtin);
537
525
    if (library == NULL)
538
526
    {
539
527
      errmsg_printf(ERRMSG_LVL_ERROR,
557
545
}
558
546
 
559
547
 
560
 
void plugin_shutdown(plugin::Registry &registry)
 
548
void module_shutdown(module::Registry &registry)
561
549
{
562
550
 
563
551
  if (initialized)
791
779
{
792
780
  sys_var *var;
793
781
  sys_var_pluginvar *pi= NULL;
794
 
  plugin::Module *module;
 
782
  module::Module *module;
795
783
 
796
784
  pthread_rwlock_rdlock(&LOCK_system_variables_hash);
797
785
  if ((var= intern_find_sys_var(str, length, false)) &&
1446
1434
}
1447
1435
 
1448
1436
 
1449
 
static int construct_options(memory::Root *mem_root, plugin::Module *tmp,
 
1437
static int construct_options(memory::Root *mem_root, module::Module *tmp,
1450
1438
                             option *options)
1451
1439
{
1452
1440
  
1616
1604
}
1617
1605
 
1618
1606
 
1619
 
static option *construct_help_options(memory::Root *mem_root, plugin::Module *p)
 
1607
static option *construct_help_options(memory::Root *mem_root, module::Module *p)
1620
1608
{
1621
1609
  drizzle_sys_var **opt;
1622
1610
  option *opts;
1665
1653
  NOTE:
1666
1654
    Requires that a write-lock is held on LOCK_system_variables_hash
1667
1655
*/
1668
 
static int test_plugin_options(memory::Root *tmp_root, plugin::Module *tmp,
 
1656
static int test_plugin_options(memory::Root *tmp_root, module::Module *tmp,
1669
1657
                               int *argc, char **argv)
1670
1658
{
1671
1659
  struct sys_var_chain chain= { NULL, NULL };
1781
1769
 
1782
1770
void my_print_help_inc_plugins(option *main_options)
1783
1771
{
1784
 
  plugin::Registry &registry= plugin::Registry::singleton();
 
1772
  module::Registry &registry= module::Registry::singleton();
1785
1773
  vector<option> all_options;
1786
 
  plugin::Module *p;
1787
1774
  memory::Root mem_root(4096);
1788
1775
  option *opt= NULL;
1789
1776
 
 
1777
 
1790
1778
  if (initialized)
1791
1779
  {
1792
 
    std::map<std::string, plugin::Module *>::const_iterator modules=
 
1780
    std::map<std::string, module::Module *>::const_iterator modules=
1793
1781
      registry.getModulesMap().begin();
1794
1782
    
1795
1783
    while (modules != registry.getModulesMap().end())
1796
1784
    {
1797
 
      p= (*modules).second;
 
1785
      module::Module *p= (*modules).second;
1798
1786
      ++modules;
1799
1787
 
1800
1788
      if (p->getManifest().system_vars == NULL)
1840
1828
}
1841
1829
 
1842
1830
} /* namespace drizzled */
 
1831
 
 
1832