← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_plugin.cc

  • Committer: Monty Taylor
  • Date: 2009-07-15 21:00:16 UTC
  • mto: (1093.1.18 captain)
  • mto: This revision was merged to the branch mainline in revision 1098.
  • Revision ID: mordred@inaugust.com-20090715210016-r1p52ne1xs4jxu3g
Rename of plugin classes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_plugin.cc
43
43
#define REPORT_TO_USER 2
44
44
 
45
45
using namespace std;
 
46
using namespace drizzled;
 
47
using namespace drizzled::plugin;
46
48
 
47
 
typedef struct drizzled_plugin_manifest builtin_plugin[];
 
49
typedef Manifest builtin_plugin[];
48
50
extern builtin_plugin DRIZZLED_BUILTIN_LIST;
49
 
static drizzled_plugin_manifest *drizzled_builtins[]=
 
51
static Manifest *drizzled_builtins[]=
50
52
{
51
 
  DRIZZLED_BUILTIN_LIST,(struct drizzled_plugin_manifest *)0
 
53
  DRIZZLED_BUILTIN_LIST,(Manifest *)0
52
54
};
53
55
 
54
56
char *opt_plugin_load= NULL;
55
57
const char *opt_plugin_load_default= QUOTE_ARG(DRIZZLED_PLUGIN_LIST);
56
58
char *opt_plugin_dir_ptr;
57
59
char opt_plugin_dir[FN_REFLEN];
58
 
static const char *plugin_declarations_sym= "_mysql_plugin_declarations_";
 
60
static const char *plugin_declarations_sym= "_drizzled_plugin_declaration_";
59
61
 
60
62
/* Note that 'int version' must be the first field of every plugin
61
63
   sub-structure (plugin->info).
122
124
class sys_var_pluginvar: public sys_var
123
125
{
124
126
public:
125
 
  struct st_plugin_int *plugin;
 
127
  Handle *plugin;
126
128
  struct st_mysql_sys_var *plugin_var;
127
129
 
128
130
  static void *operator new(size_t size, MEM_ROOT *mem_root)
154
156
/* prototypes */
155
157
static bool plugin_load_list(MEM_ROOT *tmp_root, int *argc, char **argv,
156
158
                             const char *list);
157
 
static int test_plugin_options(MEM_ROOT *, struct st_plugin_int *,
 
159
static int test_plugin_options(MEM_ROOT *, Handle *,
158
160
                               int *, char **);
159
 
static bool register_builtin(struct st_plugin_int *,
160
 
                             struct st_plugin_int **);
 
161
static bool register_builtin(Handle *,
 
162
                             Handle **);
161
163
static void unlock_variables(Session *session, struct system_variables *vars);
162
164
static void cleanup_variables(Session *session, struct system_variables *vars);
163
165
static void plugin_vars_free_values(sys_var *vars);
236
238
  Plugin support code
237
239
****************************************************************************/
238
240
 
239
 
static struct st_plugin_dl *plugin_dl_find(const LEX_STRING *dl)
 
241
static Library *plugin_dl_find(const LEX_STRING *dl)
240
242
{
241
243
  uint32_t i;
242
 
  struct st_plugin_dl *tmp;
 
244
  Library *tmp;
243
245
 
244
246
  for (i= 0; i < plugin_dl_array.elements; i++)
245
247
  {
246
 
    tmp= *dynamic_element(&plugin_dl_array, i, struct st_plugin_dl **);
 
248
    tmp= *dynamic_element(&plugin_dl_array, i, Library **);
247
249
    if (! my_strnncoll(files_charset_info,
248
250
                       (const unsigned char *)dl->str, dl->length,
249
251
                       (const unsigned char *)tmp->dl.str, tmp->dl.length))
252
254
  return(0);
253
255
}
254
256
 
255
 
static st_plugin_dl *plugin_dl_insert_or_reuse(struct st_plugin_dl *plugin_dl)
 
257
static Library *plugin_dl_insert_or_reuse(Library *plugin_dl)
256
258
{
257
259
  uint32_t i;
258
 
  struct st_plugin_dl *tmp;
 
260
  Library *tmp;
259
261
 
260
262
  for (i= 0; i < plugin_dl_array.elements; i++)
261
263
  {
262
 
    tmp= *dynamic_element(&plugin_dl_array, i, struct st_plugin_dl **);
 
264
    tmp= *dynamic_element(&plugin_dl_array, i, Library **);
263
265
    {
264
 
      memcpy(tmp, plugin_dl, sizeof(struct st_plugin_dl));
 
266
      memcpy(tmp, plugin_dl, sizeof(Library));
265
267
      return(tmp);
266
268
    }
267
269
  }
268
270
  if (insert_dynamic(&plugin_dl_array, (unsigned char*)&plugin_dl))
269
271
    return(0);
270
272
  tmp= *dynamic_element(&plugin_dl_array, plugin_dl_array.elements - 1,
271
 
                        struct st_plugin_dl **)=
272
 
      (struct st_plugin_dl *) memdup_root(&plugin_mem_root, (unsigned char*)plugin_dl,
273
 
                                           sizeof(struct st_plugin_dl));
 
273
                        Library **)=
 
274
      (Library *) memdup_root(&plugin_mem_root, (unsigned char*)plugin_dl,
 
275
                                           sizeof(Library));
274
276
  return(tmp);
275
277
}
276
278
 
277
 
static inline void free_plugin_mem(struct st_plugin_dl *p)
 
279
static inline void free_plugin_mem(Library *p)
278
280
{
279
281
  if (p->handle)
280
282
    dlclose(p->handle);
282
284
}
283
285
 
284
286
 
285
 
static st_plugin_dl *plugin_dl_add(const LEX_STRING *dl, int report)
 
287
static Library *plugin_dl_add(const LEX_STRING *dl, int report)
286
288
{
287
289
  string dlpath;
288
290
  uint32_t plugin_dir_len;
289
 
  struct st_plugin_dl *tmp, plugin_dl;
 
291
  Library *tmp, plugin_dl;
290
292
  void *sym;
291
293
  plugin_dir_len= strlen(opt_plugin_dir);
292
294
  dlpath.reserve(FN_REFLEN);
345
347
    return(0);
346
348
  }
347
349
 
348
 
  plugin_dl.plugins= (struct drizzled_plugin_manifest *)sym;
 
350
  plugin_dl.plugins= static_cast<Manifest *>(sym);
349
351
 
350
352
  /* Duplicate and convert dll name */
351
353
  plugin_dl.dl.length= dl->length * files_charset_info->mbmaxlen + 1;
364
366
  {
365
367
    free_plugin_mem(&plugin_dl);
366
368
    if (report & REPORT_TO_USER)
367
 
      my_error(ER_OUTOFMEMORY, MYF(0), sizeof(struct st_plugin_dl));
 
369
      my_error(ER_OUTOFMEMORY, MYF(0), sizeof(Library));
368
370
    if (report & REPORT_TO_LOG)
369
 
      errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_OUTOFMEMORY), sizeof(struct st_plugin_dl));
 
371
      errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_OUTOFMEMORY), sizeof(Library));
370
372
    return(0);
371
373
  }
372
374
  return(tmp);
379
381
 
380
382
  for (i= 0; i < plugin_dl_array.elements; i++)
381
383
  {
382
 
    struct st_plugin_dl *tmp= *dynamic_element(&plugin_dl_array, i,
383
 
                                               struct st_plugin_dl **);
 
384
    Library *tmp= *dynamic_element(&plugin_dl_array, i,
 
385
                                               Library **);
384
386
    if (! my_strnncoll(files_charset_info,
385
387
                       (const unsigned char *)dl->str, dl->length,
386
388
                       (const unsigned char *)tmp->dl.str, tmp->dl.length))
388
390
      /* Do not remove this element, unless no other plugin uses this dll. */
389
391
      {
390
392
        free_plugin_mem(tmp);
391
 
        memset(tmp, 0, sizeof(struct st_plugin_dl));
 
393
        memset(tmp, 0, sizeof(Library));
392
394
      }
393
395
      break;
394
396
    }
398
400
 
399
401
 
400
402
 
401
 
static st_plugin_int *plugin_insert_or_reuse(struct st_plugin_int *plugin)
 
403
static Handle *plugin_insert_or_reuse(Handle *plugin)
402
404
{
403
 
  struct st_plugin_int *tmp;
 
405
  Handle *tmp;
404
406
  if (insert_dynamic(&plugin_array, (unsigned char*)&plugin))
405
407
    return(0);
406
408
  tmp= *dynamic_element(&plugin_array, plugin_array.elements - 1,
407
 
                        struct st_plugin_int **)=
408
 
       (struct st_plugin_int *) memdup_root(&plugin_mem_root, (unsigned char*)plugin,
409
 
                                            sizeof(struct st_plugin_int));
 
409
                        Handle **)=
 
410
       (Handle *) memdup_root(&plugin_mem_root, (unsigned char*)plugin,
 
411
                                            sizeof(Handle));
410
412
  return(tmp);
411
413
}
412
414
 
421
423
{
422
424
  PluginRegistry &registry= PluginRegistry::getPluginRegistry();
423
425
 
424
 
  struct st_plugin_int tmp;
425
 
  struct drizzled_plugin_manifest *plugin;
 
426
  Handle tmp;
 
427
  Manifest *plugin;
426
428
  if (! initialized)
427
429
    return(0);
428
430
 
447
449
                       (const unsigned char *)plugin->name,
448
450
                       name_len))
449
451
    {
450
 
      struct st_plugin_int *tmp_plugin_ptr;
 
452
      Handle *tmp_plugin_ptr;
451
453
 
452
454
      tmp.plugin= plugin;
453
455
      tmp.name.str= (char *)plugin->name;
479
481
}
480
482
 
481
483
 
482
 
static void plugin_del(struct st_plugin_int *plugin)
 
484
static void plugin_del(Handle *plugin)
483
485
{
484
486
  PluginRegistry &registry= PluginRegistry::getPluginRegistry();
485
487
  if (plugin->isInited)
508
510
{
509
511
  size_t count;
510
512
  uint32_t idx;
511
 
  struct st_plugin_int *plugin;
 
513
  drizzled::plugin::Handle *plugin;
512
514
 
513
515
  count= plugin_array.elements;
514
516
 
515
517
  for (idx= 0; idx < count; idx++)
516
518
  {
517
 
    plugin= *dynamic_element(&plugin_array, idx, struct st_plugin_int **);
 
519
    plugin= *dynamic_element(&plugin_array, idx, drizzled::plugin::Handle **);
518
520
    plugin_del(plugin);
519
521
  }
520
522
}
521
523
 
522
 
static bool plugin_initialize(struct st_plugin_int *plugin)
 
524
static bool plugin_initialize(drizzled::plugin::Handle *plugin)
523
525
{
524
526
  assert(plugin->isInited == false);
525
527
 
584
586
int plugin_init(int *argc, char **argv, int flags)
585
587
{
586
588
  uint32_t idx;
587
 
  struct drizzled_plugin_manifest **builtins;
588
 
  struct drizzled_plugin_manifest *plugin;
589
 
  struct st_plugin_int tmp, *plugin_ptr;
 
589
  Manifest **builtins;
 
590
  Manifest *plugin;
 
591
  Handle tmp, *plugin_ptr;
590
592
  MEM_ROOT tmp_root;
591
593
 
592
594
  if (initialized)
601
603
 
602
604
 
603
605
  if (my_init_dynamic_array(&plugin_dl_array,
604
 
                            sizeof(struct st_plugin_dl *),16,16) ||
 
606
                            sizeof(Library *),16,16) ||
605
607
      my_init_dynamic_array(&plugin_array,
606
 
                            sizeof(struct st_plugin_int *),16,16))
 
608
                            sizeof(Handle *),16,16))
607
609
    goto err;
608
610
 
609
611
  initialized= 1;
649
651
  */
650
652
  for (idx= 0; idx < plugin_array.elements; idx++)
651
653
  {
652
 
    plugin_ptr= *dynamic_element(&plugin_array, idx, struct st_plugin_int **);
 
654
    plugin_ptr= *dynamic_element(&plugin_array, idx, Handle **);
653
655
    if (plugin_ptr->isInited == false)
654
656
    {
655
657
      if (plugin_initialize(plugin_ptr))
670
672
}
671
673
 
672
674
 
673
 
static bool register_builtin(struct st_plugin_int *tmp,
674
 
                             struct st_plugin_int **ptr)
 
675
static bool register_builtin(Handle *tmp,
 
676
                             Handle **ptr)
675
677
{
676
678
 
677
679
  PluginRegistry &registry= PluginRegistry::getPluginRegistry();
683
685
    return(1);
684
686
 
685
687
  *ptr= *dynamic_element(&plugin_array, plugin_array.elements - 1,
686
 
                         struct st_plugin_int **)=
687
 
        (struct st_plugin_int *) memdup_root(&plugin_mem_root, (unsigned char*)tmp,
688
 
                                             sizeof(struct st_plugin_int));
 
688
                         Handle **)=
 
689
        (Handle *) memdup_root(&plugin_mem_root, (unsigned char*)tmp,
 
690
                                             sizeof(Handle));
689
691
 
690
692
  registry.add(*ptr);
691
693
 
701
703
{
702
704
  char buffer[FN_REFLEN];
703
705
  LEX_STRING name= {buffer, 0}, dl= {NULL, 0}, *str= &name;
704
 
  struct st_plugin_dl *plugin_dl;
705
 
  struct drizzled_plugin_manifest *plugin;
 
706
  Library *plugin_dl;
 
707
  Manifest *plugin;
706
708
  char *p= buffer;
707
709
  while (list)
708
710
  {
778
780
{
779
781
  uint32_t idx;
780
782
  size_t count= plugin_array.elements;
781
 
  vector<st_plugin_int *> plugins;
782
 
  vector<st_plugin_dl *> dl;
 
783
  vector<Handle *> plugins;
 
784
  vector<Library *> dl;
783
785
 
784
786
  if (initialized)
785
787
  {
803
805
  dl.reserve(count);
804
806
  for (idx= 0; idx < count; idx++)
805
807
    dl.push_back(*dynamic_element(&plugin_dl_array, idx,
806
 
                 struct st_plugin_dl **));
 
808
                 Library **));
807
809
  for (idx= 0; idx < count; idx++)
808
810
    free_plugin_mem(dl[idx]);
809
811
  delete_dynamic(&plugin_dl_array);
1123
1125
{
1124
1126
  sys_var *var;
1125
1127
  sys_var_pluginvar *pi= NULL;
1126
 
  st_plugin_int *plugin;
 
1128
  Handle *plugin;
1127
1129
 
1128
1130
  pthread_rwlock_rdlock(&LOCK_system_variables_hash);
1129
1131
  if ((var= intern_find_sys_var(str, length, false)) &&
1867
1869
}
1868
1870
 
1869
1871
 
1870
 
static int construct_options(MEM_ROOT *mem_root, struct st_plugin_int *tmp,
 
1872
static int construct_options(MEM_ROOT *mem_root, Handle *tmp,
1871
1873
                             my_option *options, bool can_disable)
1872
1874
{
1873
1875
  const char *plugin_name= tmp->plugin->name;
2083
2085
 
2084
2086
 
2085
2087
static my_option *construct_help_options(MEM_ROOT *mem_root,
2086
 
                                         struct st_plugin_int *p)
 
2088
                                         Handle *p)
2087
2089
{
2088
2090
  st_mysql_sys_var **opt;
2089
2091
  my_option *opts;
2125
2127
  NOTE:
2126
2128
    Requires that a write-lock is held on LOCK_system_variables_hash
2127
2129
*/
2128
 
static int test_plugin_options(MEM_ROOT *tmp_root, struct st_plugin_int *tmp,
 
2130
static int test_plugin_options(MEM_ROOT *tmp_root, Handle *tmp,
2129
2131
                               int *argc, char **argv)
2130
2132
{
2131
2133
  struct sys_var_chain chain= { NULL, NULL };
2244
2246
void my_print_help_inc_plugins(my_option *main_options, uint32_t size)
2245
2247
{
2246
2248
  DYNAMIC_ARRAY all_options;
2247
 
  struct st_plugin_int *p;
 
2249
  Handle *p;
2248
2250
  MEM_ROOT mem_root;
2249
2251
  my_option *opt;
2250
2252
 
2254
2256
  if (initialized)
2255
2257
    for (uint32_t idx= 0; idx < plugin_array.elements; idx++)
2256
2258
    {
2257
 
      p= *dynamic_element(&plugin_array, idx, struct st_plugin_int **);
 
2259
      p= *dynamic_element(&plugin_array, idx, Handle **);
2258
2260
 
2259
2261
      if (!p->plugin->system_vars ||
2260
2262
          !(opt= construct_help_options(&mem_root, p)))