← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/hello_events/hello_events.cc

  • Committer: Brian Aker
  • Date: 2010-10-28 17:12:01 UTC
  • mfrom: (1887.1.3 merge)
  • Revision ID: brian@tangent.org-20101028171201-baj6l1bnntn1s4ad
Merge in POTFILES changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/hello_events/hello_events.cc
38
38
#include <drizzled/module/option_map.h>
39
39
#include "drizzled/session.h"
40
40
#include "hello_events.h"
41
 
 
42
41
namespace po= boost::program_options;
43
42
using namespace drizzled;
44
43
using namespace plugin;
46
45
 
47
46
#define PLUGIN_NAME "hello_events1"
48
47
 
49
 
static bool sysvar_hello_events_enabled;
 
48
static bool sysvar_hello_events_enabled= true;
50
49
static HelloEvents *hello_events= NULL;
51
 
static string sysvar_db_list;
52
 
static string sysvar_table_list;
 
50
static char *sysvar_table_list= NULL;
 
51
static char *sysvar_db_list= NULL;
53
52
 
54
53
/*
55
54
 * Event observer positions are used to set the order in which
65
64
 * or the last position (-1) in the calling order, for example it makes no sence 
66
65
 * to initially ask to be called in position 13.
67
66
 */
68
 
typedef constrained_check<uint64_t, INT32_MAX-1, 1> position_constraint;
69
 
typedef constrained_check<int32_t, -1, INT32_MIN+1> post_drop_constraint;
70
 
 
71
 
static position_constraint sysvar_before_write_position;      // Call this event observer first.
72
 
static position_constraint sysvar_before_update_position;
73
 
static post_drop_constraint sysvar_post_drop_db_position;  // I want my event observer to be called last. No reason, I just do!
 
67
static int32_t sysvar_before_write_position= 1;      // Call this event observer first.
 
68
static int32_t sysvar_before_update_position= 1;
 
69
static int32_t sysvar_post_drop_db_position= -1;  // I want my event observer to be called last. No reason, I just do!
74
70
 
75
71
 
76
72
//==================================
192
188
}
193
189
 
194
190
HelloEvents::~HelloEvents()
195
 
{ }
 
191
{
 
192
  /* These are strdup'd in option processing */
 
193
  if (sysvar_table_list) {
 
194
        free(sysvar_table_list);
 
195
        sysvar_table_list = NULL;
 
196
  }
 
197
  
 
198
  if (sysvar_db_list) {
 
199
        free(sysvar_db_list);
 
200
        sysvar_db_list = NULL;
 
201
  }
 
202
  
 
203
}
196
204
 
197
205
//==================================
198
206
/* This is where I register which table events my pluggin is interested in.*/
203
211
    || !isDatabaseInteresting(table_share.getSchemaName()))
204
212
    return;
205
213
    
206
 
  registerEvent(observers, BEFORE_INSERT_RECORD, sysvar_before_write_position.get());
207
 
  // I want to be called first if passible
 
214
  registerEvent(observers, BEFORE_INSERT_RECORD, sysvar_before_write_position); // I want to be called first if passible
208
215
  registerEvent(observers, AFTER_INSERT_RECORD);
209
 
  registerEvent(observers, BEFORE_UPDATE_RECORD, sysvar_before_update_position.get());
 
216
  registerEvent(observers, BEFORE_UPDATE_RECORD, sysvar_before_update_position);
210
217
  registerEvent(observers, AFTER_UPDATE_RECORD);
211
218
  registerEvent(observers, BEFORE_DELETE_RECORD);
212
219
  registerEvent(observers, AFTER_DELETE_RECORD);
233
240
    return;
234
241
    
235
242
  registerEvent(observers, AFTER_CREATE_DATABASE);
236
 
  registerEvent(observers, AFTER_DROP_DATABASE, sysvar_post_drop_db_position.get());
 
243
  registerEvent(observers, AFTER_DROP_DATABASE, sysvar_post_drop_db_position);
237
244
  registerEvent(observers, DISCONNECT_SESSION);
238
245
  registerEvent(observers, CONNECT_SESSION);
239
246
  registerEvent(observers, BEFORE_STATEMENT);
318
325
 
319
326
/* Plugin initialization and system variables */
320
327
 
321
 
static void enable(Session*, sql_var_t)
 
328
static void enable(Session *,
 
329
                   drizzle_sys_var *,
 
330
                   void *var_ptr,
 
331
                   const void *save)
322
332
{
323
333
  if (hello_events)
324
334
  {
325
 
    if (sysvar_hello_events_enabled)
 
335
    if (*(bool *)save != false)
326
336
    {
327
337
      hello_events->enable();
 
338
      *(bool *) var_ptr= (bool) true;
328
339
    }
329
340
    else
330
341
    {
331
342
      hello_events->disable();
 
343
      *(bool *) var_ptr= (bool) false;
332
344
    }
333
345
  }
334
346
}
335
347
 
336
348
 
337
 
static int set_db_list(Session *, set_var *var)
 
349
static void set_db_list(Session *,
 
350
                   drizzle_sys_var *, 
 
351
                   void *var_ptr,     
 
352
                   const void *save)
338
353
{
339
 
  const char *db_list= var->value->str_value.ptr();
340
 
  if (db_list == NULL)
341
 
    return 1;
342
 
 
343
354
  if (hello_events)
344
355
  {
345
 
    hello_events->setDatabasesOfInterest(db_list);
346
 
    sysvar_db_list.assign(db_list);
 
356
    hello_events->setDatabasesOfInterest(*(const char **) save);
 
357
    *(const char **) var_ptr= hello_events->getDatabasesOfInterest();
347
358
  }
348
 
  return 0;
349
359
}
350
360
 
351
 
static int set_table_list(Session *, set_var *var)
 
361
static void set_table_list(Session *,
 
362
                   drizzle_sys_var *, 
 
363
                   void *var_ptr,     
 
364
                   const void *save)
352
365
{
353
 
  const char *table_list= var->value->str_value.ptr();
354
 
  if (table_list == NULL)
355
 
    return 1;
356
 
 
357
366
  if (hello_events)
358
367
  {
359
 
    hello_events->setTablesOfInterest(table_list);
360
 
    sysvar_table_list.assign(table_list);
 
368
    hello_events->setTablesOfInterest(*(const char **) save);
 
369
    *(const char **) var_ptr= hello_events->getTablesOfInterest();
361
370
  }
362
 
  return 0;
363
371
}
364
372
 
365
373
 
366
374
static int init(module::Context &context)
367
375
{
 
376
  const module::option_map &vm= context.getOptions();
 
377
  if (vm.count("before-write-position"))
 
378
  { 
 
379
    if (sysvar_before_write_position < 1 || sysvar_before_write_position > INT32_MAX -1)
 
380
    {
 
381
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value of before-write-position\n"));
 
382
      exit(-1);
 
383
    }
 
384
  }
 
385
 
 
386
  if (vm.count("before-update-position"))
 
387
  { 
 
388
    if (sysvar_before_update_position < 1 || sysvar_before_update_position > INT32_MAX -1)
 
389
    {
 
390
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value of before-update-position\n"));
 
391
      exit(-1);
 
392
    }
 
393
  }
 
394
 
 
395
  if (vm.count("post-drop-db-position"))
 
396
  { 
 
397
    if (sysvar_post_drop_db_position > -1 || sysvar_post_drop_db_position < INT32_MIN+1)
 
398
    {
 
399
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value of before-update-position\n"));
 
400
      exit(-1);
 
401
    }
 
402
  }
 
403
 
 
404
  if (vm.count("watch-databases"))
 
405
  {
 
406
    sysvar_db_list= strdup(vm["watch-databases"].as<string>().c_str());
 
407
  }
 
408
 
 
409
  else
 
410
  {
 
411
    sysvar_db_list= strdup("");
 
412
  }
 
413
 
 
414
  if (vm.count("watch-tables"))
 
415
  {
 
416
    sysvar_table_list= strdup(vm["watch-tables"].as<string>().c_str());
 
417
  }
 
418
 
 
419
  else
 
420
  {
 
421
    sysvar_table_list= strdup("");
 
422
  }
368
423
  hello_events= new HelloEvents(PLUGIN_NAME);
369
424
 
370
425
  context.add(hello_events);
374
429
    hello_events->enable();
375
430
  }
376
431
 
377
 
  context.registerVariable(new sys_var_bool_ptr("enable",
378
 
                                                &sysvar_hello_events_enabled,
379
 
                                                enable));
380
 
  context.registerVariable(new sys_var_std_string("watch_databases",
381
 
                                                  sysvar_db_list,
382
 
                                                  set_db_list));
383
 
  context.registerVariable(new sys_var_std_string("watch_tables",
384
 
                                                  sysvar_table_list,
385
 
                                                  set_table_list));
386
 
  context.registerVariable(new sys_var_constrained_value<uint64_t>("before_write_position",
387
 
                                                         sysvar_before_write_position));
388
 
  context.registerVariable(new sys_var_constrained_value<uint64_t>("before_update_position",
389
 
                                                         sysvar_before_update_position));
390
 
  context.registerVariable(new sys_var_constrained_value<int32_t>("post_drop_position",
391
 
                                                         sysvar_post_drop_db_position));
392
 
 
393
 
 
394
432
  return 0;
395
433
}
396
434
 
397
435
static void init_options(drizzled::module::option_context &context)
398
436
{
 
437
  context("watch-databases",
 
438
          po::value<string>(),
 
439
          N_("A comma delimited list of databases to watch"));
 
440
  context("watch-tables",
 
441
          po::value<string>(),
 
442
          N_("A comma delimited list of databases to watch"));
399
443
  context("enable",
400
444
          po::value<bool>(&sysvar_hello_events_enabled)->default_value(false)->zero_tokens(),
401
445
          N_("Enable Example Events Plugin"));
402
 
  context("watch-databases",
403
 
          po::value<string>(&sysvar_db_list)->default_value(""),
404
 
          N_("A comma delimited list of databases to watch"));
405
 
  context("watch-tables",
406
 
          po::value<string>(&sysvar_table_list)->default_value(""),
407
 
          N_("A comma delimited list of databases to watch"));
408
446
  context("before-write-position",
409
 
          po::value<position_constraint>(&sysvar_before_write_position)->default_value(1),
 
447
          po::value<int32_t>(&sysvar_before_write_position)->default_value(1),
410
448
          N_("Before write row event observer call position"));
411
449
  context("before-update-position",
412
 
          po::value<position_constraint>(&sysvar_before_update_position)->default_value(1),
 
450
          po::value<int32_t>(&sysvar_before_update_position)->default_value(1),
413
451
          N_("Before update row event observer call position"));
414
452
  context("post-drop-db-position",
415
 
          po::value<post_drop_constraint>(&sysvar_post_drop_db_position)->default_value(-1),
 
453
          po::value<int32_t>(&sysvar_post_drop_db_position)->default_value(-1),
416
454
          N_("After drop database event observer call position"));
417
455
}
418
456
 
419
 
 
 
457
static DRIZZLE_SYSVAR_STR(watch_databases,
 
458
                           sysvar_db_list,
 
459
                           PLUGIN_VAR_OPCMDARG,
 
460
                           N_("A comma delimited list of databases to watch"),
 
461
                           NULL, /* check func */
 
462
                           set_db_list, /* update func */
 
463
                           "" /* default */);
 
464
 
 
465
static DRIZZLE_SYSVAR_STR(watch_tables,
 
466
                           sysvar_table_list,
 
467
                           PLUGIN_VAR_OPCMDARG,
 
468
                           N_("A comma delimited list of tables to watch"),
 
469
                           NULL, /* check func */
 
470
                           set_table_list, /* update func */
 
471
                           "" /* default */);
 
472
 
 
473
static DRIZZLE_SYSVAR_BOOL(enable,
 
474
                           sysvar_hello_events_enabled,
 
475
                           PLUGIN_VAR_NOCMDARG,
 
476
                           N_("Enable Example Events Plugin"),
 
477
                           NULL, /* check func */
 
478
                           enable, /* update func */
 
479
                           false /* default */);
 
480
 
 
481
static DRIZZLE_SYSVAR_INT(before_write_position,
 
482
                           sysvar_before_write_position,
 
483
                           PLUGIN_VAR_NOCMDARG,
 
484
                           N_("Before write row event observer call position"),
 
485
                           NULL, /* check func */
 
486
                           NULL, /* update func */
 
487
                           1, /* default */
 
488
                           1, /* min */
 
489
                           INT32_MAX -1, /* max */
 
490
                           0 /* blk */);
 
491
 
 
492
static DRIZZLE_SYSVAR_INT(before_update_position,
 
493
                           sysvar_before_update_position,
 
494
                           PLUGIN_VAR_NOCMDARG,
 
495
                           N_("Before update row event observer call position"),
 
496
                           NULL, /* check func */
 
497
                           NULL, /* update func */
 
498
                           1, /* default */
 
499
                           1, /* min */
 
500
                           INT32_MAX -1, /* max */
 
501
                           0 /* blk */);
 
502
 
 
503
static drizzle_sys_var* system_var[]= {
 
504
  DRIZZLE_SYSVAR(watch_databases),
 
505
  DRIZZLE_SYSVAR(watch_tables),
 
506
  DRIZZLE_SYSVAR(enable),
 
507
  DRIZZLE_SYSVAR(before_write_position),
 
508
  DRIZZLE_SYSVAR(before_update_position),
 
509
  NULL
 
510
};
420
511
 
421
512
DRIZZLE_DECLARE_PLUGIN
422
513
{
427
518
  N_("An example events Plugin"),
428
519
  PLUGIN_LICENSE_BSD,
429
520
  init,   /* Plugin Init      */
430
 
  NULL, /* depends */
 
521
  system_var, /* system variables */
431
522
  init_options    /* config options   */
432
523
}
433
524
DRIZZLE_DECLARE_PLUGIN_END;