← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/event_observer.h

Renamed namespace slot to namespace service.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/event_observer.h
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Definitions required for EventObserver plugin
5
 
 *
6
 
 *  Copyright (C) 2010 PrimeBase Technologies GmbH, Germany
7
 
 *
8
 
 *  This program is free software; you can redistribute it and/or modify
9
 
 *  it under the terms of the GNU General Public License as published by
10
 
 *  the Free Software Foundation; version 2 of the License.
11
 
 *
12
 
 *  This program is distributed in the hope that it will be useful,
13
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
 
 *  GNU General Public License for more details.
16
 
 *
17
 
 *  You should have received a copy of the GNU General Public License
18
 
 *  along with this program; if not, write to the Free Software
19
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20
 
 *
21
 
 * Barry Leslie
22
 
 *
23
 
 * 2010-05-12
24
 
 */
25
 
 
26
 
/*
27
 
 * How to add a new event:
28
 
 *
29
 
 * In event_observer.h
30
 
 * 1: Add your event to EventType.
31
 
 * 2: Add it to EventObserver::eventName().
32
 
 * 3: Cerate a EventData class for it based on SessionEventData, SchemaEventData, 
33
 
 *  or TableEventData depending on the event type class.
34
 
 * 4: Add a static method to the EventObserver class, similar to beforeInsertRecord() for example,
35
 
 *  that will be called by drizzle.
36
 
 *
37
 
 * In event_observer.cc
38
 
 * 5: Impliment your static event method, similar to beforeInsertRecord() for example.
39
 
 * 6: Depending on the event type class add an event vector for it to the SessionEventObservers,
40
 
 *  SchemaEventObservers, or TableEventObservers class.
41
 
 *
42
 
 */
43
 
#ifndef DRIZZLED_PLUGIN_EVENT_OBSERVER_H
44
 
#define DRIZZLED_PLUGIN_EVENT_OBSERVER_H
45
 
 
46
 
#include <drizzled/plugin/plugin.h>
47
 
 
48
 
#include <string>
49
 
 
50
 
#include <drizzled/visibility.h>
51
 
 
52
 
namespace drizzled
53
 
{
54
 
 
55
 
class Table;
56
 
class TableShare;
57
 
class Session;
58
 
 
59
 
namespace plugin
60
 
{
61
 
class EventObserverList;
62
 
class EventData;
63
 
class EventObserver;
64
 
 
65
 
typedef std::vector<EventObserver *> EventObserverVector;
66
 
typedef EventObserver* EventObserverPtr;
67
 
 
68
 
class DRIZZLED_API EventObserver : public Plugin
69
 
{
70
 
  EventObserver();
71
 
  EventObserver(const EventObserver &);
72
 
  EventObserver& operator=(const EventObserver &);
73
 
public:
74
 
  explicit EventObserver(std::string name_arg)
75
 
    : Plugin(name_arg, "EventObserver")
76
 
  {}
77
 
  virtual ~EventObserver() {}
78
 
 
79
 
  enum EventType{
80
 
    /* Session events: */
81
 
    BEFORE_CREATE_DATABASE, AFTER_CREATE_DATABASE, 
82
 
    BEFORE_DROP_DATABASE,   AFTER_DROP_DATABASE,
83
 
    CONNECT_SESSION,
84
 
    DISCONNECT_SESSION,
85
 
    AFTER_STATEMENT,
86
 
    BEFORE_STATEMENT,
87
 
 
88
 
    /* Schema events: */
89
 
    BEFORE_DROP_TABLE,   AFTER_DROP_TABLE, 
90
 
    BEFORE_RENAME_TABLE, AFTER_RENAME_TABLE, 
91
 
 
92
 
    /* Table events: */
93
 
    BEFORE_INSERT_RECORD,   AFTER_INSERT_RECORD, 
94
 
    BEFORE_UPDATE_RECORD,   AFTER_UPDATE_RECORD, 
95
 
    BEFORE_DELETE_RECORD,   AFTER_DELETE_RECORD,
96
 
 
97
 
    /* The max event ID marker. */
98
 
    MAX_EVENT_COUNT
99
 
  };
100
 
 
101
 
  static const char *eventName(EventType event) 
102
 
  {
103
 
    switch(event) 
104
 
    {
105
 
    case BEFORE_DROP_TABLE:
106
 
      return "BEFORE_DROP_TABLE";
107
 
 
108
 
    case AFTER_DROP_TABLE:
109
 
      return "AFTER_DROP_TABLE";
110
 
 
111
 
    case BEFORE_RENAME_TABLE:
112
 
      return "BEFORE_RENAME_TABLE";
113
 
 
114
 
    case AFTER_RENAME_TABLE:
115
 
      return "AFTER_RENAME_TABLE";
116
 
 
117
 
    case BEFORE_INSERT_RECORD:
118
 
      return "BEFORE_INSERT_RECORD";
119
 
 
120
 
    case AFTER_INSERT_RECORD:
121
 
      return "AFTER_INSERT_RECORD";
122
 
 
123
 
    case BEFORE_UPDATE_RECORD:
124
 
      return "BEFORE_UPDATE_RECORD";
125
 
 
126
 
    case AFTER_UPDATE_RECORD:
127
 
      return "AFTER_UPDATE_RECORD";
128
 
 
129
 
    case BEFORE_DELETE_RECORD:
130
 
      return "BEFORE_DELETE_RECORD";
131
 
 
132
 
    case AFTER_DELETE_RECORD:
133
 
      return "AFTER_DELETE_RECORD";
134
 
 
135
 
    case BEFORE_CREATE_DATABASE:
136
 
      return "BEFORE_CREATE_DATABASE";
137
 
 
138
 
    case AFTER_CREATE_DATABASE:
139
 
      return "AFTER_CREATE_DATABASE";
140
 
 
141
 
    case BEFORE_DROP_DATABASE:
142
 
      return "BEFORE_DROP_DATABASE";
143
 
 
144
 
    case AFTER_DROP_DATABASE:
145
 
      return "AFTER_DROP_DATABASE";
146
 
 
147
 
    case CONNECT_SESSION:
148
 
      return "CONNECT_SESSION";
149
 
 
150
 
    case DISCONNECT_SESSION:
151
 
      return "DISCONNECT_SESSION";
152
 
 
153
 
    case AFTER_STATEMENT:
154
 
      return "AFTER_STATEMENT";
155
 
 
156
 
    case BEFORE_STATEMENT:
157
 
      return "BEFORE_STATEMENT";
158
 
 
159
 
    case MAX_EVENT_COUNT:
160
 
      break;
161
 
    }
162
 
 
163
 
    return "Unknown";
164
 
  }
165
 
 
166
 
  /*==========================================================*/
167
 
  /* registerEvents() must be implemented to allow the plugin to
168
 
   * register which events it is interested in.
169
 
 */
170
 
  virtual void registerTableEventsDo(TableShare &, EventObserverList &){}
171
 
  virtual void registerSchemaEventsDo(const std::string &/*db*/, EventObserverList &) {}
172
 
  virtual void registerSessionEventsDo(Session &, EventObserverList &) {}
173
 
 
174
 
  virtual bool observeEventDo(EventData &)= 0;
175
 
 
176
 
  /*==========================================================*/
177
 
  /* Static access methods called by drizzle: */
178
 
  static bool addPlugin(EventObserver *handler);
179
 
  static void removePlugin(EventObserver *handler);
180
 
 
181
 
  /*==========================================================*/
182
 
  /* Register an event of interest for this plugin. 
183
 
   * This is called from with in the plugin when registering itself.
184
 
   *
185
 
   * The position field is used to indicate the order the event observer is to be 
186
 
   * called. If the event observer must be called before any other observer then 
187
 
   * the position must be set to 1. If it must be called last then the position must be 
188
 
   * set to -1. A position of 0 indicated the position doesn't matter.
189
 
   *
190
 
   * If 2 plugins require the same position then which is called first in not guarenteed.
191
 
   * In this case a warrning will be logged but execution will continue.
192
 
   * 
193
 
   * It is good practice that if the event position matters not to hard code the position
194
 
   * but supply a systen variable so that it can be set at runtime so that the user can
195
 
   * decide which event should be called first.
196
 
 */
197
 
  void registerEvent(EventObserverList &observers, EventType event, int32_t position= 0); 
198
 
 
199
 
  /*==========================================================*/
200
 
  /* Called from drizzle to register all events for all event plugins 
201
 
   * interested in this table. 
202
 
 */
203
 
  static void registerTableEvents(TableShare &table_share); 
204
 
  static void deregisterTableEvents(TableShare &table_share); 
205
 
 
206
 
  /*==========================================================*/
207
 
  /* Called from drizzle to register all events for all event plugins 
208
 
   * interested in this database. 
209
 
 */
210
 
  static void registerSchemaEvents(Session &session, const std::string &db); 
211
 
  static void deregisterSchemaEvents(Session &session, const std::string &db); 
212
 
 
213
 
  /*==========================================================*/
214
 
  /* Called from drizzle to register all events for all event plugins 
215
 
   * interested in this session. 
216
 
 */
217
 
  static void registerSessionEvents(Session &session); 
218
 
  static void deregisterSessionEvents(Session &session); 
219
 
 
220
 
 
221
 
  /*==========================================================*/
222
 
  /* Static meathods called by drizzle to notify interested plugins 
223
 
   * of a schema an event,
224
 
 */
225
 
  static bool beforeDropTable(Session &session, const drizzled::identifier::Table &table);
226
 
  static bool afterDropTable(Session &session, const drizzled::identifier::Table &table, int err);
227
 
  static bool beforeRenameTable(Session &session, const drizzled::identifier::Table &from, const drizzled::identifier::Table &to);
228
 
  static bool afterRenameTable(Session &session, const drizzled::identifier::Table &from, const drizzled::identifier::Table &to, int err);
229
 
  static bool connectSession(Session &session);
230
 
  static bool disconnectSession(Session &session);
231
 
  static bool beforeStatement(Session &session);
232
 
  static bool afterStatement(Session &session);
233
 
 
234
 
  /*==========================================================*/
235
 
  /* Static meathods called by drizzle to notify interested plugins 
236
 
   * of a table an event,
237
 
 */
238
 
  static bool beforeInsertRecord(Table &table, unsigned char *buf);
239
 
  static bool afterInsertRecord(Table &table, const unsigned char *buf, int err);
240
 
  static bool beforeDeleteRecord(Table &table, const unsigned char *buf);
241
 
  static bool afterDeleteRecord(Table &table, const unsigned char *buf, int err);
242
 
  static bool beforeUpdateRecord(Table &table, const unsigned char *old_data, unsigned char *new_data);
243
 
  static bool afterUpdateRecord(Table &table, const unsigned char *old_data, unsigned char *new_data, int err);
244
 
 
245
 
  /*==========================================================*/
246
 
  /* Static meathods called by drizzle to notify interested plugins 
247
 
   * of a table an event,
248
 
 */
249
 
  static bool beforeCreateDatabase(Session &session, const std::string &db);
250
 
  static bool afterCreateDatabase(Session &session, const std::string &db, int err);
251
 
  static bool beforeDropDatabase(Session &session, const std::string &db);
252
 
  static bool afterDropDatabase(Session &session, const std::string &db, int err);
253
 
 
254
 
  static const EventObserverVector &getEventObservers(void);
255
 
 
256
 
};
257
 
 
258
 
 
259
 
 
260
 
 
261
 
/* EventObserver data classes: */
262
 
//======================================
263
 
class EventData
264
 
{
265
 
public:
266
 
  EventObserver::EventType event;
267
 
 
268
 
  EventData(EventObserver::EventType event_arg): 
269
 
    event(event_arg),
270
 
    observerList(NULL)
271
 
  {}
272
 
  virtual ~EventData(){}
273
 
 
274
 
  // Call all the event observers that are registered for this event.
275
 
  virtual bool callEventObservers();
276
 
 
277
 
protected:
278
 
  EventObserverList *observerList;
279
 
 
280
 
};
281
 
 
282
 
//-----
283
 
class SessionEventData: public EventData
284
 
{
285
 
public:
286
 
  Session &session;
287
 
 
288
 
  SessionEventData(EventObserver::EventType event_arg, Session &session_arg): 
289
 
    EventData(event_arg),
290
 
    session(session_arg)
291
 
  {}
292
 
  virtual ~SessionEventData(){}
293
 
 
294
 
 
295
 
  // Call all the event observers that are registered for this event.
296
 
  virtual bool callEventObservers();
297
 
  
298
 
  static bool hasEvents(Session &in_session);
299
 
};
300
 
 
301
 
//-----
302
 
class SchemaEventData: public EventData
303
 
{
304
 
public:
305
 
  Session &session;
306
 
  const std::string &db;
307
 
 
308
 
  SchemaEventData(EventObserver::EventType event_arg, Session &session_arg, const std::string &db_arg): 
309
 
    EventData(event_arg),
310
 
    session(session_arg),
311
 
    db(db_arg)
312
 
  {}
313
 
  virtual ~SchemaEventData(){}
314
 
 
315
 
 
316
 
  // Call all the event observers that are registered for this event.
317
 
  virtual bool callEventObservers();
318
 
  
319
 
};
320
 
 
321
 
//-----
322
 
class TableEventData: public EventData
323
 
{
324
 
public:
325
 
  Session &session;
326
 
  Table &table;  
327
 
 
328
 
  TableEventData(EventObserver::EventType event_arg, Session &session_arg, Table &table_arg): 
329
 
    EventData(event_arg),
330
 
    session(session_arg),
331
 
    table(table_arg)
332
 
  {}
333
 
  virtual ~TableEventData(){}
334
 
 
335
 
 
336
 
  // Call all the event observers that are registered for this event.
337
 
  virtual bool callEventObservers();
338
 
  
339
 
  static bool hasEvents(Table &in_table);
340
 
};
341
 
 
342
 
//-----
343
 
class BeforeCreateDatabaseEventData: public SessionEventData
344
 
{
345
 
public:
346
 
  const std::string &db;
347
 
 
348
 
  BeforeCreateDatabaseEventData(Session &session_arg, const std::string &db_arg): 
349
 
    SessionEventData(EventObserver::BEFORE_CREATE_DATABASE, session_arg), 
350
 
    db(db_arg)
351
 
  {}  
352
 
};
353
 
 
354
 
//-----
355
 
class AfterCreateDatabaseEventData: public SessionEventData
356
 
{
357
 
public:
358
 
  const std::string &db;
359
 
  int err;
360
 
 
361
 
  AfterCreateDatabaseEventData(Session &session_arg, const std::string &db_arg, int err_arg): 
362
 
    SessionEventData(EventObserver::AFTER_CREATE_DATABASE, session_arg), 
363
 
    db(db_arg), 
364
 
    err(err_arg)
365
 
  {}  
366
 
};
367
 
 
368
 
//-----
369
 
class BeforeDropDatabaseEventData: public SessionEventData
370
 
{
371
 
public:
372
 
  const std::string &db;
373
 
 
374
 
  BeforeDropDatabaseEventData(Session &session_arg, const std::string &db_arg): 
375
 
    SessionEventData(EventObserver::BEFORE_DROP_DATABASE, session_arg), 
376
 
    db(db_arg)
377
 
  {}  
378
 
};
379
 
 
380
 
//-----
381
 
class AfterDropDatabaseEventData: public SessionEventData
382
 
{
383
 
public:
384
 
  const std::string &db;
385
 
  int err;
386
 
 
387
 
  AfterDropDatabaseEventData(Session &session_arg, const std::string &db_arg, int err_arg): 
388
 
    SessionEventData(EventObserver::AFTER_DROP_DATABASE, session_arg), 
389
 
    db(db_arg), 
390
 
    err(err_arg) 
391
 
  {}  
392
 
};
393
 
 
394
 
//-----
395
 
class ConnectSessionEventData: public SessionEventData
396
 
{
397
 
public:
398
 
 
399
 
  ConnectSessionEventData(Session &session_arg):
400
 
    SessionEventData(EventObserver::CONNECT_SESSION, session_arg)
401
 
  {}  
402
 
};
403
 
 
404
 
//-----
405
 
class DisconnectSessionEventData: public SessionEventData
406
 
{
407
 
public:
408
 
 
409
 
  DisconnectSessionEventData(Session &session_arg):
410
 
    SessionEventData(EventObserver::DISCONNECT_SESSION, session_arg)
411
 
  {}  
412
 
};
413
 
 
414
 
//-----
415
 
class BeforeStatementEventData: public SessionEventData
416
 
{
417
 
public:
418
 
 
419
 
  BeforeStatementEventData(Session &session_arg):
420
 
    SessionEventData(EventObserver::BEFORE_STATEMENT, session_arg)
421
 
  {}  
422
 
};
423
 
 
424
 
//-----
425
 
class AfterStatementEventData: public SessionEventData
426
 
{
427
 
public:
428
 
 
429
 
  AfterStatementEventData(Session &session_arg):
430
 
    SessionEventData(EventObserver::AFTER_STATEMENT, session_arg)
431
 
  {}  
432
 
};
433
 
 
434
 
//-----
435
 
class BeforeDropTableEventData: public SchemaEventData
436
 
{
437
 
public:
438
 
  const drizzled::identifier::Table &table;
439
 
 
440
 
  BeforeDropTableEventData(Session &session_arg, const drizzled::identifier::Table &table_arg): 
441
 
    SchemaEventData(EventObserver::BEFORE_DROP_TABLE, session_arg, table_arg.getSchemaName()), 
442
 
    table(table_arg)
443
 
  {}  
444
 
};
445
 
 
446
 
//-----
447
 
class AfterDropTableEventData: public SchemaEventData
448
 
{
449
 
public:
450
 
  const drizzled::identifier::Table &table;
451
 
  int err;
452
 
 
453
 
  AfterDropTableEventData(Session &session_arg, const drizzled::identifier::Table &table_arg, int err_arg): 
454
 
    SchemaEventData(EventObserver::AFTER_DROP_TABLE, session_arg, table_arg.getSchemaName()), 
455
 
    table(table_arg), 
456
 
    err(err_arg)
457
 
  {}  
458
 
};
459
 
 
460
 
//-----
461
 
class BeforeRenameTableEventData: public SchemaEventData
462
 
{
463
 
public:
464
 
  const drizzled::identifier::Table &from;
465
 
  const drizzled::identifier::Table &to;
466
 
 
467
 
  BeforeRenameTableEventData(Session &session_arg, const drizzled::identifier::Table &from_arg, const drizzled::identifier::Table &to_arg): 
468
 
    SchemaEventData(EventObserver::BEFORE_RENAME_TABLE, session_arg, from_arg.getSchemaName()), 
469
 
    from(from_arg), 
470
 
    to(to_arg)
471
 
  {}  
472
 
};
473
 
 
474
 
//-----
475
 
class AfterRenameTableEventData: public SchemaEventData
476
 
{
477
 
public:
478
 
  const drizzled::identifier::Table &from;
479
 
  const drizzled::identifier::Table &to;
480
 
  int err;
481
 
 
482
 
  AfterRenameTableEventData(Session &session_arg, const drizzled::identifier::Table &from_arg, const drizzled::identifier::Table &to_arg, int err_arg): 
483
 
    SchemaEventData(EventObserver::AFTER_RENAME_TABLE, session_arg, from_arg.getSchemaName()), 
484
 
    from(from_arg), 
485
 
    to(to_arg), 
486
 
    err(err_arg)
487
 
  {}  
488
 
};
489
 
 
490
 
//-----
491
 
class BeforeInsertRecordEventData: public TableEventData
492
 
{
493
 
public:
494
 
  unsigned char *row;
495
 
 
496
 
  BeforeInsertRecordEventData(Session &session_arg, Table &table_arg, unsigned char *row_arg): 
497
 
    TableEventData(EventObserver::BEFORE_INSERT_RECORD, session_arg, table_arg), 
498
 
    row(row_arg)
499
 
  {}  
500
 
};
501
 
 
502
 
//-----
503
 
class AfterInsertRecordEventData: public TableEventData
504
 
{
505
 
public:
506
 
  const unsigned char *row;
507
 
  int err;
508
 
 
509
 
  AfterInsertRecordEventData(Session &session_arg, Table &table_arg, const unsigned char *row_arg, int err_arg): 
510
 
    TableEventData(EventObserver::AFTER_INSERT_RECORD, session_arg, table_arg), 
511
 
    row(row_arg),
512
 
    err(err_arg)
513
 
  {}  
514
 
};
515
 
 
516
 
//-----
517
 
class BeforeDeleteRecordEventData: public TableEventData
518
 
{
519
 
public:
520
 
  const unsigned char *row;
521
 
 
522
 
  BeforeDeleteRecordEventData(Session &session_arg, Table &table_arg, const unsigned char *row_arg): 
523
 
    TableEventData(EventObserver::BEFORE_DELETE_RECORD, session_arg, table_arg), 
524
 
    row(row_arg)
525
 
  {}  
526
 
};
527
 
 
528
 
//-----
529
 
class AfterDeleteRecordEventData: public TableEventData
530
 
{
531
 
public:
532
 
  const unsigned char *row;
533
 
  int err;
534
 
 
535
 
  AfterDeleteRecordEventData(Session &session_arg, Table &table_arg, const unsigned char *row_arg, int err_arg): 
536
 
    TableEventData(EventObserver::AFTER_DELETE_RECORD, session_arg, table_arg), 
537
 
    row(row_arg),
538
 
    err(err_arg)
539
 
  {}  
540
 
};
541
 
 
542
 
//-----
543
 
class BeforeUpdateRecordEventData: public TableEventData
544
 
{
545
 
public:
546
 
  const unsigned char *old_row;
547
 
  unsigned char *new_row;
548
 
 
549
 
  BeforeUpdateRecordEventData(Session &session_arg, Table &table_arg,  
550
 
                              const unsigned char *old_row_arg, 
551
 
                              unsigned char *new_row_arg): 
552
 
    TableEventData(EventObserver::BEFORE_UPDATE_RECORD, session_arg, table_arg), 
553
 
    old_row(old_row_arg),
554
 
    new_row(new_row_arg)      
555
 
  {}  
556
 
};
557
 
 
558
 
//-----
559
 
class AfterUpdateRecordEventData: public TableEventData
560
 
{
561
 
public:
562
 
  const unsigned char *old_row;
563
 
  const unsigned char *new_row;
564
 
  int err;
565
 
 
566
 
  AfterUpdateRecordEventData(Session &session_arg, Table &table_arg, 
567
 
                             const unsigned char *old_row_arg, 
568
 
                             const unsigned char *new_row_arg, 
569
 
                             int err_arg): 
570
 
    TableEventData(EventObserver::AFTER_UPDATE_RECORD, session_arg, table_arg), 
571
 
    old_row(old_row_arg),
572
 
    new_row(new_row_arg),
573
 
    err(err_arg)
574
 
  {}  
575
 
};
576
 
 
577
 
//=======================================================
578
 
 
579
 
} /* namespace plugin */
580
 
} /* namespace drizzled */
581
 
 
582
 
#endif /* DRIZZLED_PLUGIN_EVENT_OBSERVER_H */