← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/event_observer.cc

  • Committer: Monty Taylor
  • Date: 2010-08-03 18:21:58 UTC
  • mto: (1680.2.6 build)
  • mto: This revision was merged to the branch mainline in revision 1683.
  • Revision ID: mordred@inaugust.com-20100803182158-nkmgnlohodud4290
Made existence of intltool and gettext optional.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/event_observer.cc
21
21
 * 2010-05-12
22
22
 */
23
23
 
24
 
#include <config.h>
 
24
#include "config.h"
25
25
 
26
26
#include <string>
27
27
#include <vector>
28
28
 
29
 
#include <drizzled/session.h>
30
 
#include <drizzled/table_list.h>
31
 
#include <drizzled/table/instance.h>
32
 
#include <drizzled/module/registry.h>
33
 
#include <drizzled/plugin/event_observer.h>
 
29
#include "drizzled/session.h"
 
30
#include "drizzled/table_list.h"
 
31
#include "drizzled/table_share.h"
 
32
#include "drizzled/module/registry.h"
 
33
#include "drizzled/plugin/event_observer.h"
34
34
#include <drizzled/util/functors.h>
35
35
#include <algorithm>
36
36
 
37
37
 
38
38
 
 
39
using namespace std;
 
40
 
39
41
namespace drizzled
40
42
{
41
43
 
44
46
 
45
47
/*============================*/
46
48
  // Basic plugin registration stuff.
47
 
  EventObserverVector all_event_plugins;
48
 
 
49
 
  const EventObserverVector &EventObserver::getEventObservers(void)
50
 
  {
51
 
    return all_event_plugins;
52
 
  }
 
49
  static vector<EventObserver *> all_event_plugins;
53
50
 
54
51
  //---------
55
52
  bool EventObserver::addPlugin(EventObserver *handler)
63
60
  void EventObserver::removePlugin(EventObserver *handler)
64
61
  {
65
62
    if (handler != NULL)
66
 
      all_event_plugins.erase(std::find(all_event_plugins.begin(), all_event_plugins.end(), handler));
 
63
      all_event_plugins.erase(find(all_event_plugins.begin(), all_event_plugins.end(), handler));
67
64
  }
68
65
 
69
66
 
79
76
  {
80
77
 
81
78
  public:
82
 
    typedef std::multimap<uint32_t, EventObserver *> ObserverMap;
 
79
    typedef multimap<uint32_t, EventObserver *> ObserverMap;
83
80
 
84
81
  private:
85
82
    /* A list of lists indexed by event type. */
86
 
    std::vector<ObserverMap *> event_observer_lists;
 
83
    vector<ObserverMap *> event_observer_lists;
87
84
 
88
85
  public:
89
86
 
90
87
    EventObserverList()
91
88
    {
92
 
                        // Initialize the list with NULL pointers.
93
 
                        event_observer_lists.assign(EventObserver::MAX_EVENT_COUNT, NULL);
 
89
      uint32_t i;
 
90
 
 
91
      event_observer_lists.reserve(EventObserver::MAX_EVENT_COUNT);
 
92
      for (i=0; i < EventObserver::MAX_EVENT_COUNT; i++)
 
93
      {
 
94
        event_observer_lists[i]= NULL;
 
95
      }
94
96
    }
95
97
 
96
98
    ~EventObserverList()
97
99
    {
98
 
      std::for_each(event_observer_lists.begin(),
99
 
                    event_observer_lists.end(),
100
 
                    SafeDeletePtr());
101
 
      event_observer_lists.clear();
 
100
      clearAllObservers();
102
101
    }
103
102
 
104
103
    /* Add the observer to the observer list for the even, positioning it if required.
129
128
      {
130
129
        if (observers->find(event_pos) != observers->end())
131
130
        {
132
 
          errmsg_printf(error::WARN,
 
131
          errmsg_printf(ERRMSG_LVL_WARN,
133
132
                        _("EventObserverList::addEventObserver() Duplicate event position %d for event '%s' from EventObserver plugin '%s'"),
134
133
                        position,
135
134
                        EventObserver::eventName(event), 
137
136
        }
138
137
      }
139
138
 
140
 
      observers->insert(std::pair<uint32_t, EventObserver *>(event_pos, eventObserver) );
 
139
      observers->insert(pair<uint32_t, EventObserver *>(event_pos, eventObserver) );
 
140
    }
 
141
 
 
142
    /* Remove all observer from all lists. */
 
143
    void clearAllObservers()
 
144
    {
 
145
      for_each(event_observer_lists.begin(),
 
146
               event_observer_lists.end(),
 
147
               DeletePtr());
 
148
      event_observer_lists.clear();
141
149
    }
142
150
 
143
151
 
166
174
  /* For each EventObserver plugin call its registerTableEventsDo() meathod so that it can
167
175
   * register what events, if any, it is interested in on this table.
168
176
   */ 
169
 
  class RegisterTableEventsIterate : public std::unary_function<EventObserver *, void>
 
177
  class RegisterTableEventsIterate : public unary_function<EventObserver *, void>
170
178
  {
171
179
    TableShare &table_share;
172
180
    EventObserverList &observers;
194
202
 
195
203
    observers= table_share.getTableObservers();
196
204
 
197
 
    if (observers != NULL) 
198
 
                {
199
 
                        errmsg_printf(error::WARN,
200
 
                                                                        _("EventObserver::registerTableEvents(): Table already has events registered on it: probable programming error."));
201
 
                        table_share.setTableObservers(NULL);
202
 
      delete observers;
 
205
    if (observers == NULL) 
 
206
    {
 
207
      observers= new EventObserverList();
 
208
      table_share.setTableObservers(observers);
 
209
    } 
 
210
    else 
 
211
    {
 
212
      /* Calling registerTableEvents() for a table that already has
 
213
       * events registered on it is probably a programming error.
 
214
     */
 
215
      observers->clearAllObservers();
203
216
    }
204
217
 
205
 
                observers= new EventObserverList();
206
 
                table_share.setTableObservers(observers);
207
 
 
208
218
 
209
 
    std::for_each(all_event_plugins.begin(), all_event_plugins.end(),
210
 
                  RegisterTableEventsIterate(table_share, *observers));
 
219
    for_each(all_event_plugins.begin(), all_event_plugins.end(),
 
220
             RegisterTableEventsIterate(table_share, *observers));
211
221
 
212
222
  }
213
223
 
215
225
  /* Cleanup before freeing the TableShare object. */
216
226
  void EventObserver::deregisterTableEvents(TableShare &table_share)
217
227
  {
218
 
   if (all_event_plugins.empty())
 
228
    if (all_event_plugins.empty())
219
229
      return;
220
230
 
221
231
    EventObserverList *observers;
225
235
    if (observers) 
226
236
    {
227
237
      table_share.setTableObservers(NULL);
 
238
      observers->clearAllObservers();
228
239
      delete observers;
229
240
    }
230
241
  }
238
249
  /* For each EventObserver plugin call its registerSchemaEventsDo() meathod so that it can
239
250
   * register what events, if any, it is interested in on the schema.
240
251
   */ 
241
 
  class RegisterSchemaEventsIterate : public std::unary_function<EventObserver *, void>
 
252
  class RegisterSchemaEventsIterate : public unary_function<EventObserver *, void>
242
253
  {
243
254
    const std::string &db;
244
255
    EventObserverList &observers;
271
282
    {
272
283
      observers= new EventObserverList();
273
284
      session.setSchemaObservers(db, observers);
274
 
   }
 
285
    }
275
286
 
276
 
    std::for_each(all_event_plugins.begin(), all_event_plugins.end(),
277
 
                  RegisterSchemaEventsIterate(db, *observers));
 
287
    for_each(all_event_plugins.begin(), all_event_plugins.end(),
 
288
             RegisterSchemaEventsIterate(db, *observers));
278
289
 
279
290
  }
280
291
 
292
303
    if (observers) 
293
304
    {
294
305
      session.setSchemaObservers(db, NULL);
 
306
      observers->clearAllObservers();
295
307
      delete observers;
296
308
    }
297
309
  }
304
316
  /* For each EventObserver plugin call its registerSessionEventsDo() meathod so that it can
305
317
   * register what events, if any, it is interested in on this session.
306
318
   */ 
307
 
  class RegisterSessionEventsIterate : public std::unary_function<EventObserver *, void>
 
319
  class RegisterSessionEventsIterate : public unary_function<EventObserver *, void>
308
320
  {
309
321
    Session &session;
310
322
    EventObserverList &observers;
330
342
    EventObserverList *observers;
331
343
 
332
344
    observers= session.getSessionObservers();
333
 
                if (observers) { // This should not happed
334
 
                        errmsg_printf(error::WARN,
335
 
                                                                        _("EventObserver::registerSessionEvents(): Session already has events registered on it: probable programming error."));
336
 
                        session.setSessionObservers(NULL);
337
 
                        delete observers;
338
 
                }
339
 
 
340
 
        observers= new EventObserverList();
341
 
        session.setSessionObservers(observers);
342
 
 
343
 
  std::for_each(all_event_plugins.begin(), all_event_plugins.end(),
344
 
                RegisterSessionEventsIterate(session, *observers));
 
345
 
 
346
    if (observers == NULL) 
 
347
    {
 
348
      observers= new EventObserverList();
 
349
      session.setSessionObservers(observers);
 
350
    }
 
351
 
 
352
    observers->clearAllObservers();
 
353
 
 
354
    for_each(all_event_plugins.begin(), all_event_plugins.end(),
 
355
             RegisterSessionEventsIterate(session, *observers));
345
356
 
346
357
  }
347
358
 
359
370
    if (observers) 
360
371
    {
361
372
      session.setSessionObservers(NULL);
 
373
      observers->clearAllObservers();
362
374
      delete observers;
363
375
    }
364
376
  }
366
378
 
367
379
  /* Event observer list iterator: */
368
380
  //----------
369
 
  class EventIterate : public std::unary_function<std::pair<uint32_t, EventObserver *>, bool>
 
381
  class EventIterate : public unary_function<pair<uint32_t, EventObserver *>, bool>
370
382
  {
371
383
    EventData &data;
372
384
 
373
385
  public:
374
386
    EventIterate(EventData &data_arg) :
375
 
      std::unary_function<std::pair<uint32_t, EventObserver *>, bool>(),
 
387
      unary_function<pair<uint32_t, EventObserver *>, bool>(),
376
388
      data(data_arg)
377
389
    {}
378
390
 
383
395
      {
384
396
        /* TRANSLATORS: The leading word "EventObserver" is the name
385
397
          of the plugin api, and so should not be translated. */
386
 
        errmsg_printf(error::ERROR,
 
398
        errmsg_printf(ERRMSG_LVL_ERROR,
387
399
                      _("EventIterate event handler '%s' failed for event '%s'"),
388
400
                      handler.second->getName().c_str(), handler.second->eventName(data.event));
389
401
 
403
415
  {
404
416
    EventObserverList::ObserverMap *eventObservers;
405
417
 
406
 
    if (observerList == NULL)
407
 
      return false; // Nobody was interested in the event. :(
408
 
 
409
418
    eventObservers = observerList->getObservers(event);
410
419
 
411
420
    if (eventObservers == NULL)
413
422
 
414
423
    /* Use find_if instead of foreach so that we can collect return codes */
415
424
    EventObserverList::ObserverMap::iterator iter=
416
 
      std::find_if(eventObservers->begin(), eventObservers->end(),
417
 
                   EventIterate(*this)); 
 
425
      find_if(eventObservers->begin(), eventObservers->end(),
 
426
              EventIterate(*this)); 
418
427
    /* If iter is == end() here, that means that all of the plugins returned
419
428
     * false, which in this case means they all succeeded. Since we want to 
420
429
     * return false on success, we return the value of the two being !=.
430
439
    return EventData::callEventObservers();
431
440
  }
432
441
 
433
 
  bool SessionEventData::hasEvents(Session &in_session)
434
 
  {
435
 
    return (in_session.getSessionObservers() != NULL);
436
 
  }
437
 
 
438
442
  //--------
439
443
  bool SchemaEventData::callEventObservers()
440
444
  {
451
455
  //--------
452
456
  bool TableEventData::callEventObservers()
453
457
  {
454
 
    observerList= table.getMutableShare()->getTableObservers();
 
458
    observerList= table.s->getTableObservers();
455
459
 
456
460
    return EventData::callEventObservers();
457
461
  }
458
462
 
459
 
  bool TableEventData::hasEvents(Table &in_table)
460
 
  {
461
 
    return (in_table.getMutableShare()->getTableObservers() != NULL);
462
 
  }
463
 
 
464
463
  /*==========================================================*/
465
464
  /* Static meathods called by drizzle to notify interested plugins 
466
 
   * of a schema event.
 
465
   * of a schema event,
467
466
 */
468
 
  bool EventObserver::beforeDropTable(Session &session, const drizzled::identifier::Table &table)
 
467
  bool EventObserver::beforeDropTable(Session &session, const drizzled::TableIdentifier &table)
469
468
  {
470
469
    if (all_event_plugins.empty())
471
470
      return false;
474
473
    return eventData.callEventObservers();
475
474
  }
476
475
 
477
 
  bool EventObserver::afterDropTable(Session &session, const drizzled::identifier::Table &table, int err)
 
476
  bool EventObserver::afterDropTable(Session &session, const drizzled::TableIdentifier &table, int err)
478
477
  {
479
478
    if (all_event_plugins.empty())
480
479
      return false;
483
482
    return eventData.callEventObservers();
484
483
  }
485
484
 
486
 
  bool EventObserver::beforeRenameTable(Session &session, const drizzled::identifier::Table &from, const drizzled::identifier::Table &to)
 
485
  bool EventObserver::beforeRenameTable(Session &session, const drizzled::TableIdentifier &from, const drizzled::TableIdentifier &to)
487
486
  {
488
487
    if (all_event_plugins.empty())
489
488
      return false;
492
491
    return eventData.callEventObservers();
493
492
  }
494
493
 
495
 
  bool EventObserver::afterRenameTable(Session &session, const drizzled::identifier::Table &from, const drizzled::identifier::Table &to, int err)
 
494
  bool EventObserver::afterRenameTable(Session &session, const drizzled::TableIdentifier &from, const drizzled::TableIdentifier &to, int err)
496
495
  {
497
496
    if (all_event_plugins.empty())
498
497
      return false;
503
502
 
504
503
  /*==========================================================*/
505
504
  /* Static meathods called by drizzle to notify interested plugins 
506
 
   * of a table event.
507
 
   *
508
 
   * A quick test is done first to see if there are any interested observers.
 
505
   * of a table event,
509
506
 */
510
507
  bool EventObserver::beforeInsertRecord(Table &table, unsigned char *buf)
511
508
  {
512
 
    if (all_event_plugins.empty() || !TableEventData::hasEvents(table))
 
509
    if (all_event_plugins.empty())
513
510
      return false;
514
511
 
515
512
    BeforeInsertRecordEventData eventData(*(table.in_use), table, buf);
518
515
 
519
516
  bool EventObserver::afterInsertRecord(Table &table, const unsigned char *buf, int err)
520
517
  {
521
 
    if (all_event_plugins.empty() || !TableEventData::hasEvents(table))
 
518
    if (all_event_plugins.empty())
522
519
      return false;
523
520
 
524
521
    AfterInsertRecordEventData eventData(*(table.in_use), table, buf, err);
527
524
 
528
525
  bool EventObserver::beforeDeleteRecord(Table &table, const unsigned char *buf)
529
526
  {
530
 
    if (all_event_plugins.empty() || !TableEventData::hasEvents(table))
 
527
    if (all_event_plugins.empty())
531
528
      return false;
532
529
 
533
530
    BeforeDeleteRecordEventData eventData(*(table.in_use), table, buf);
536
533
 
537
534
  bool EventObserver::afterDeleteRecord(Table &table, const unsigned char *buf, int err)
538
535
  {
539
 
    if (all_event_plugins.empty() || !TableEventData::hasEvents(table))
 
536
    if (all_event_plugins.empty())
540
537
      return false;
541
538
 
542
539
    AfterDeleteRecordEventData eventData(*(table.in_use), table, buf, err);
545
542
 
546
543
  bool EventObserver::beforeUpdateRecord(Table &table, const unsigned char *old_data, unsigned char *new_data)
547
544
  {
548
 
    if (all_event_plugins.empty() || !TableEventData::hasEvents(table))
 
545
    if (all_event_plugins.empty())
549
546
      return false;
550
547
 
551
548
    BeforeUpdateRecordEventData eventData(*(table.in_use), table, old_data, new_data);
554
551
 
555
552
  bool EventObserver::afterUpdateRecord(Table &table, const unsigned char *old_data, unsigned char *new_data, int err)
556
553
  {
557
 
    if (all_event_plugins.empty() || !TableEventData::hasEvents(table))
 
554
    if (all_event_plugins.empty())
558
555
      return false;
559
556
 
560
557
    AfterUpdateRecordEventData eventData(*(table.in_use), table, old_data, new_data, err);
563
560
 
564
561
  /*==========================================================*/
565
562
  /* Static meathods called by drizzle to notify interested plugins 
566
 
   * of a session event.
567
 
   *
568
 
   * A quick test is done first to see if there are any interested observers.
569
 
*/
 
563
   * of a session event,
 
564
 */
570
565
  bool EventObserver::beforeCreateDatabase(Session &session, const std::string &db)
571
566
  {
572
 
    if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
 
567
    if (all_event_plugins.empty())
573
568
      return false;
574
569
 
575
570
    BeforeCreateDatabaseEventData eventData(session, db);
578
573
 
579
574
  bool EventObserver::afterCreateDatabase(Session &session, const std::string &db, int err)
580
575
  {
581
 
    if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
 
576
    if (all_event_plugins.empty())
582
577
      return false;
583
578
 
584
579
    AfterCreateDatabaseEventData eventData(session, db, err);
587
582
 
588
583
  bool EventObserver::beforeDropDatabase(Session &session, const std::string &db)
589
584
  {
590
 
    if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
 
585
    if (all_event_plugins.empty())
591
586
      return false;
592
587
 
593
588
    BeforeDropDatabaseEventData eventData(session, db);
596
591
 
597
592
  bool EventObserver::afterDropDatabase(Session &session, const std::string &db, int err)
598
593
  {
599
 
    if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
 
594
    if (all_event_plugins.empty())
600
595
      return false;
601
596
 
602
597
    AfterDropDatabaseEventData eventData(session, db, err);
603
598
    return eventData.callEventObservers();
604
599
  }
605
600
 
606
 
  bool EventObserver::connectSession(Session &session)
607
 
  {
608
 
    if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
609
 
      return false;
610
 
 
611
 
    ConnectSessionEventData eventData(session);
612
 
    return eventData.callEventObservers();
613
 
  }
614
 
 
615
 
  bool EventObserver::disconnectSession(Session &session)
616
 
  {
617
 
    if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
618
 
      return false;
619
 
 
620
 
    DisconnectSessionEventData eventData(session);
621
 
    return eventData.callEventObservers();
622
 
  }
623
 
 
624
 
  bool EventObserver::beforeStatement(Session &session)
625
 
  {
626
 
    if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
627
 
      return false;
628
 
 
629
 
    BeforeStatementEventData eventData(session);
630
 
    return eventData.callEventObservers();
631
 
  }
632
 
 
633
 
  bool EventObserver::afterStatement(Session &session)
634
 
  {
635
 
    if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
636
 
      return false;
637
 
 
638
 
    AfterStatementEventData eventData(session);
639
 
    return eventData.callEventObservers();
640
 
  }
641
 
 
642
601
 
643
602
} /* namespace plugin */
644
603
} /* namespace drizzled */