← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/event_observer.h

Merged vcol stuff.

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