drizzle
C++ MySQL-protocol-compatible database server
Loading...
Searching...
No Matches
event_observer.cc
1/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2 * vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3 *
4 * Copyright (C) 2010 PrimeBase Technologies GmbH, Germany
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; version 2 of the License.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18 *
19 * Barry Leslie
20 *
21 * 2010-05-12
22 */
23
24#include <config.h>
25
26#include <string>
27#include <vector>
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>
34#include <drizzled/util/functors.h>
35#include <algorithm>
36
37namespace drizzled {
38namespace plugin {
39
40 EventObserverVector all_event_plugins;
41
42 const EventObserverVector &EventObserver::getEventObservers()
43 {
44 return all_event_plugins;
45 }
46
47 bool EventObserver::addPlugin(EventObserver &handler)
48 {
49 all_event_plugins.push_back(&handler);
50 return false;
51 }
52
53 void EventObserver::removePlugin(EventObserver &handler)
54 {
55 all_event_plugins.erase(std::find(all_event_plugins.begin(), all_event_plugins.end(), &handler));
56 }
57
58
59 /*
60 * The Event Observer list class in which plugins register which events they
61 * are interested in.
62 *
63 * Each table share for example, will have one of these hung on it to store
64 * a list off all event observers interested in it and which events they are
65 * interested in.
66 */
67 class EventObserverList
68 {
69
70 public:
71 typedef std::multimap<uint32_t, EventObserver *> ObserverMap;
72
73 private:
74 /* A list of lists indexed by event type. */
75 std::vector<ObserverMap *> event_observer_lists;
76
77 public:
78
79 EventObserverList()
80 {
81 // Initialize the list with NULL pointers.
82 event_observer_lists.assign(EventObserver::MAX_EVENT_COUNT, NULL);
83 }
84
85 ~EventObserverList()
86 {
87 std::for_each(event_observer_lists.begin(),
88 event_observer_lists.end(),
89 DeletePtr());
90 event_observer_lists.clear();
91 }
92
93 /* Add the observer to the observer list for the even, positioning it if required.
94 *
95 * Note: Event observers are storted in a multimap object so that the order in which
96 * they are called can be sorted based on the requested position. Lookups are never done
97 * on the multimap, once filled it is used as a vector.
98 */
99 void addObserver(EventObserver *eventObserver, enum EventObserver::EventType event, int32_t position)
100 {
101 uint32_t event_pos;
102 ObserverMap *observers;
103
104 observers= event_observer_lists[event];
105 if (observers == NULL)
106 {
107 observers= new ObserverMap();
108 event_observer_lists[event]= observers;
109 }
110
111 if (position == 0)
112 event_pos= INT32_MAX; // Set the event position to be in the middle.
113 else
114 event_pos= (uint32_t) position;
115
116 /* If positioned then check if the position is already taken. */
117 if (position)
118 {
119 if (observers->count(event_pos))
120 {
121 errmsg_printf(error::WARN,
122 _("EventObserverList::addEventObserver() Duplicate event position %d for event '%s' from EventObserver plugin '%s'"),
123 position,
124 EventObserver::eventName(event),
125 eventObserver->getName().c_str());
126 }
127 }
128
129 observers->insert(std::pair<uint32_t, EventObserver *>(event_pos, eventObserver) );
130 }
131
132
133 /* Get the observer list for an event type. Will return NULL if no observer exists.*/
134 ObserverMap *getObservers(enum EventObserver::EventType event)
135 {
136 return event_observer_lists[event];
137 }
138 };
139
140
141 //---------
142 /* registerEvent() is called from the event observer plugins to add themselves to
143 * the event observer list to be notified when the specified event takes place.
144 */
145 void EventObserver::registerEvent(EventObserverList &observers, EventType event, int32_t position)
146 {
147 observers.addObserver(this, event, position);
148 }
149
150 /*========================================================*/
151 /* Table Event Observer handling: */
152 /*========================================================*/
153
154 //----------
155 /* For each EventObserver plugin call its registerTableEventsDo() meathod so that it can
156 * register what events, if any, it is interested in on this table.
157 */
158 class RegisterTableEventsIterate
159 {
160 TableShare &table_share;
161 EventObserverList &observers;
162
163 public:
164 RegisterTableEventsIterate(TableShare &table_share_arg, EventObserverList &observers_arg):
165 table_share(table_share_arg), observers(observers_arg) {}
166 inline void operator() (EventObserver *eventObserver)
167 {
168 eventObserver->registerTableEventsDo(table_share, observers);
169 }
170 };
171
172 //----------
173 /*
174 * registerTableEvents() is called by drizzle to register all plugins that
175 * may be interested in table events on the newly created TableShare object.
176 */
177 void EventObserver::registerTableEvents(TableShare &table_share)
178 {
179 if (all_event_plugins.empty())
180 return;
181
182 EventObserverList *observers;
183
184 observers= table_share.getTableObservers();
185
186 if (observers != NULL)
187 {
188 errmsg_printf(error::WARN,
189 _("EventObserver::registerTableEvents(): Table already has events registered on it: probable programming error."));
190 table_share.setTableObservers(NULL);
191 delete observers;
192 }
193
194 observers= new EventObserverList();
195 table_share.setTableObservers(observers);
196
197
198 std::for_each(all_event_plugins.begin(), all_event_plugins.end(),
199 RegisterTableEventsIterate(table_share, *observers));
200
201 }
202
203 //----------
204 /* Cleanup before freeing the TableShare object. */
205 void EventObserver::deregisterTableEvents(TableShare &table_share)
206 {
207 if (all_event_plugins.empty())
208 return;
209
210 EventObserverList *observers= table_share.getTableObservers();
211
212 if (observers)
213 {
214 table_share.setTableObservers(NULL);
215 delete observers;
216 }
217 }
218
219
220 /*========================================================*/
221 /* Schema Event Observer handling: */
222 /*========================================================*/
223
224 //----------
225 /* For each EventObserver plugin call its registerSchemaEventsDo() meathod so that it can
226 * register what events, if any, it is interested in on the schema.
227 */
228 class RegisterSchemaEventsIterate
229 {
230 const std::string &db;
231 EventObserverList &observers;
232 public:
233 RegisterSchemaEventsIterate(const std::string &db_arg, EventObserverList &observers_arg) :
234 db(db_arg),
235 observers(observers_arg){}
236
237 inline void operator() (EventObserver *eventObserver)
238 {
239 eventObserver->registerSchemaEventsDo(db, observers);
240 }
241 };
242
243 //----------
244 /*
245 * registerSchemaEvents() is called by drizzle to register all plugins that
246 * may be interested in schema events on the database.
247 */
248 void EventObserver::registerSchemaEvents(Session &session, const std::string &db)
249 {
250 if (all_event_plugins.empty())
251 return;
252 EventObserverList *observers= session.getSchemaObservers(db);
253 if (observers == NULL)
254 observers= session.setSchemaObservers(db, new EventObserverList());
255
256 std::for_each(all_event_plugins.begin(), all_event_plugins.end(),
257 RegisterSchemaEventsIterate(db, *observers));
258
259 }
260
261 //----------
262 /* Cleanup before freeing the Session object. */
263 void EventObserver::deregisterSchemaEvents(EventObserverList *observers)
264 {
265 delete observers;
266 }
267
268 /*========================================================*/
269 /* Session Event Observer handling: */
270 /*========================================================*/
271
272 //----------
273 /* For each EventObserver plugin call its registerSessionEventsDo() meathod so that it can
274 * register what events, if any, it is interested in on this session.
275 */
276 class RegisterSessionEventsIterate
277 {
278 Session &session;
279 EventObserverList &observers;
280 public:
281 RegisterSessionEventsIterate(Session &session_arg, EventObserverList &observers_arg) :
282 session(session_arg), observers(observers_arg) {}
283 inline void operator() (EventObserver *eventObserver)
284 {
285 eventObserver->registerSessionEventsDo(session, observers);
286 }
287 };
288
289 //----------
290 /*
291 * registerSessionEvents() is called by drizzle to register all plugins that
292 * may be interested in session events on the newly created session.
293 */
294 void EventObserver::registerSessionEvents(Session &session)
295 {
296 if (all_event_plugins.empty())
297 return;
298
299 EventObserverList *observers;
300
301 observers= session.getSessionObservers();
302 if (observers) { // This should not happed
303 errmsg_printf(error::WARN,
304 _("EventObserver::registerSessionEvents(): Session already has events registered on it: probable programming error."));
305 session.setSessionObservers(NULL);
306 delete observers;
307 }
308
309 observers= new EventObserverList();
310 session.setSessionObservers(observers);
311
312 std::for_each(all_event_plugins.begin(), all_event_plugins.end(),
313 RegisterSessionEventsIterate(session, *observers));
314
315 }
316
317 //----------
318 /* Cleanup before freeing the session object. */
319 void EventObserver::deregisterSessionEvents(EventObserverList *observers)
320 {
321 delete observers;
322 }
323
324
325 /* Event observer list iterator: */
326 //----------
327 class EventIterate
328 {
329 EventData &data;
330
331 public:
332 EventIterate(EventData &data_arg) :
333 data(data_arg)
334 {}
335
336 inline bool operator()(std::pair<uint32_t, EventObserver *> handler)
337 {
338 bool result= handler.second->observeEventDo(data);
339 if (result)
340 {
341 /* TRANSLATORS: The leading word "EventObserver" is the name
342 of the plugin api, and so should not be translated. */
343 errmsg_printf(error::ERROR,
344 _("EventIterate event handler '%s' failed for event '%s'"),
345 handler.second->getName().c_str(), handler.second->eventName(data.event));
346
347 }
348 return result;
349 }
350 };
351
352
353 /*==========================================================*/
354 /* Generic meathods called by drizzle to notify all interested
355 * plugins of an event,
356 */
357
358 // Call all event observers interested in the event.
359 bool EventData::callEventObservers()
360 {
361 EventObserverList::ObserverMap *eventObservers;
362
363 if (observerList == NULL)
364 return false; // Nobody was interested in the event. :(
365
366 eventObservers = observerList->getObservers(event);
367
368 if (eventObservers == NULL)
369 return false; // Nobody was interested in the event. :(
370
371 /* Use find_if instead of foreach so that we can collect return codes */
372 EventObserverList::ObserverMap::iterator iter=
373 std::find_if(eventObservers->begin(), eventObservers->end(),
374 EventIterate(*this));
375 /* If iter is == end() here, that means that all of the plugins returned
376 * false, which in this case means they all succeeded. Since we want to
377 * return false on success, we return the value of the two being !=.
378 */
379 return iter != eventObservers->end();
380 }
381
382 //--------
383 bool SessionEventData::callEventObservers()
384 {
385 observerList= session.getSessionObservers();
386
387 return EventData::callEventObservers();
388 }
389
390 bool SessionEventData::hasEvents(Session &in_session)
391 {
392 return (in_session.getSessionObservers() != NULL);
393 }
394
395 //--------
396 bool SchemaEventData::callEventObservers()
397 {
398 observerList= session.getSchemaObservers(db);
399 if (!observerList)
400 {
401 EventObserver::registerSchemaEvents(session, db);
402 observerList= session.getSchemaObservers(db);
403 }
404
405 return EventData::callEventObservers();
406 }
407
408 //--------
409 bool TableEventData::callEventObservers()
410 {
411 observerList= table.getMutableShare()->getTableObservers();
412
413 return EventData::callEventObservers();
414 }
415
416 bool TableEventData::hasEvents(Table &in_table)
417 {
418 return (in_table.getMutableShare()->getTableObservers() != NULL);
419 }
420
421 /*==========================================================*/
422 /* Static meathods called by drizzle to notify interested plugins
423 * of a schema event.
424 */
425 bool EventObserver::beforeDropTable(Session &session, const drizzled::identifier::Table &table)
426 {
427 if (all_event_plugins.empty())
428 return false;
429
430 BeforeDropTableEventData eventData(session, table);
431 return eventData.callEventObservers();
432 }
433
434 bool EventObserver::afterDropTable(Session &session, const drizzled::identifier::Table &table, int err)
435 {
436 if (all_event_plugins.empty())
437 return false;
438
439 AfterDropTableEventData eventData(session, table, err);
440 return eventData.callEventObservers();
441 }
442
443 bool EventObserver::beforeRenameTable(Session &session, const drizzled::identifier::Table &from, const drizzled::identifier::Table &to)
444 {
445 if (all_event_plugins.empty())
446 return false;
447
448 BeforeRenameTableEventData eventData(session, from, to);
449 return eventData.callEventObservers();
450 }
451
452 bool EventObserver::afterRenameTable(Session &session, const drizzled::identifier::Table &from, const drizzled::identifier::Table &to, int err)
453 {
454 if (all_event_plugins.empty())
455 return false;
456
457 AfterRenameTableEventData eventData(session, from, to, err);
458 return eventData.callEventObservers();
459 }
460
461 /*==========================================================*/
462 /* Static meathods called by drizzle to notify interested plugins
463 * of a table event.
464 *
465 * A quick test is done first to see if there are any interested observers.
466 */
467 bool EventObserver::beforeInsertRecord(Table &table, unsigned char *buf)
468 {
469 if (all_event_plugins.empty() || !TableEventData::hasEvents(table))
470 return false;
471
472 BeforeInsertRecordEventData eventData(*(table.in_use), table, buf);
473 return eventData.callEventObservers();
474 }
475
476 bool EventObserver::afterInsertRecord(Table &table, const unsigned char *buf, int err)
477 {
478 if (all_event_plugins.empty() || !TableEventData::hasEvents(table))
479 return false;
480
481 AfterInsertRecordEventData eventData(*(table.in_use), table, buf, err);
482 return eventData.callEventObservers();
483 }
484
485 bool EventObserver::beforeDeleteRecord(Table &table, const unsigned char *buf)
486 {
487 if (all_event_plugins.empty() || !TableEventData::hasEvents(table))
488 return false;
489
490 BeforeDeleteRecordEventData eventData(*(table.in_use), table, buf);
491 return eventData.callEventObservers();
492 }
493
494 bool EventObserver::afterDeleteRecord(Table &table, const unsigned char *buf, int err)
495 {
496 if (all_event_plugins.empty() || !TableEventData::hasEvents(table))
497 return false;
498
499 AfterDeleteRecordEventData eventData(*(table.in_use), table, buf, err);
500 return eventData.callEventObservers();
501 }
502
503 bool EventObserver::beforeUpdateRecord(Table &table, const unsigned char *old_data, unsigned char *new_data)
504 {
505 if (all_event_plugins.empty() || !TableEventData::hasEvents(table))
506 return false;
507
508 BeforeUpdateRecordEventData eventData(*(table.in_use), table, old_data, new_data);
509 return eventData.callEventObservers();
510 }
511
512 bool EventObserver::afterUpdateRecord(Table &table, const unsigned char *old_data, unsigned char *new_data, int err)
513 {
514 if (all_event_plugins.empty() || !TableEventData::hasEvents(table))
515 return false;
516
517 AfterUpdateRecordEventData eventData(*(table.in_use), table, old_data, new_data, err);
518 return eventData.callEventObservers();
519 }
520
521 /*==========================================================*/
522 /* Static meathods called by drizzle to notify interested plugins
523 * of a session event.
524 *
525 * A quick test is done first to see if there are any interested observers.
526*/
527 bool EventObserver::beforeCreateDatabase(Session &session, const std::string &db)
528 {
529 if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
530 return false;
531
532 BeforeCreateDatabaseEventData eventData(session, db);
533 return eventData.callEventObservers();
534 }
535
536 bool EventObserver::afterCreateDatabase(Session &session, const std::string &db, int err)
537 {
538 if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
539 return false;
540
541 AfterCreateDatabaseEventData eventData(session, db, err);
542 return eventData.callEventObservers();
543 }
544
545 bool EventObserver::beforeDropDatabase(Session &session, const std::string &db)
546 {
547 if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
548 return false;
549
550 BeforeDropDatabaseEventData eventData(session, db);
551 return eventData.callEventObservers();
552 }
553
554 bool EventObserver::afterDropDatabase(Session &session, const std::string &db, int err)
555 {
556 if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
557 return false;
558
559 AfterDropDatabaseEventData eventData(session, db, err);
560 return eventData.callEventObservers();
561 }
562
563 bool EventObserver::connectSession(Session &session)
564 {
565 if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
566 return false;
567
568 ConnectSessionEventData eventData(session);
569 return eventData.callEventObservers();
570 }
571
572 bool EventObserver::disconnectSession(Session &session)
573 {
574 if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
575 return false;
576
577 DisconnectSessionEventData eventData(session);
578 return eventData.callEventObservers();
579 }
580
581 bool EventObserver::beforeStatement(Session &session)
582 {
583 if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
584 return false;
585
586 BeforeStatementEventData eventData(session);
587 return eventData.callEventObservers();
588 }
589
590 bool EventObserver::afterStatement(Session &session)
591 {
592 if (all_event_plugins.empty() || !SessionEventData::hasEvents(session))
593 return false;
594
595 AfterStatementEventData eventData(session);
596 return eventData.callEventObservers();
597 }
598
599
600} /* namespace plugin */
601} /* namespace drizzled */
TODO: Rename this file - func.h is stupid.