← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/command_log/command_log.cc

Renames serial event log to command log

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/command_log/command_log.cc
21
21
/**
22
22
 * @file
23
23
 *
24
 
 * Defines the implementation of the default serial event log.
 
24
 * Defines the implementation of the default command log.
25
25
 *
26
26
 * @see drizzled/plugin/replicator.h
27
27
 * @see drizzled/plugin/applier.h
36
36
 * When writing a Command to the log, we calculate the length of the 
37
37
 * Command to be written.  We then increment log_offset by the length
38
38
 * of the Command plus sizeof(uint64_t) and store this new offset in a 
39
 
 * local off_t called cur_offset (see SerialEventLog::apply().  This 
 
39
 * local off_t called cur_offset (see CommandLog::apply().  This 
40
40
 * compare and set is done in an atomic instruction.
41
41
 *
42
42
 * We then adjust the local off_t (cur_offset) back to the original
52
52
 * as a skeleton and a springboard.
53
53
 */
54
54
 
55
 
#include "serial_event_log.h"
 
55
#include "command_log.h"
56
56
 
57
57
#include <drizzled/session.h>
58
58
#include <drizzled/set_var.h>
66
66
using namespace std;
67
67
 
68
68
/** 
69
 
 * Serial Event Log plugin system variable - Is the log enabled? Only used on init().  
70
 
 * The enable() and disable() methods of the SerialEventLog class control online
 
69
 * Command Log plugin system variable - Is the log enabled? Only used on init().  
 
70
 * The enable() and disable() methods of the CommandLog class control online
71
71
 * disabling.
72
72
 */
73
 
static bool sysvar_serial_event_log_enabled= false;
74
 
/** Serial Event Log plugin system variable - The path to the log file used */
75
 
static char* sysvar_serial_event_log_file= NULL;
76
 
/** Serial Event Log plugin system variable - A debugging variable to assist in truncating the log file. */
77
 
static bool sysvar_serial_event_log_truncate_debug= false;
78
 
static const char DEFAULT_LOG_FILE_PATH[]= "event.log"; /* In datadir... */
 
73
static bool sysvar_command_log_enabled= false;
 
74
/** Command Log plugin system variable - The path to the log file used */
 
75
static char* sysvar_command_log_file= NULL;
 
76
/** Command Log plugin system variable - A debugging variable to assist in truncating the log file. */
 
77
static bool sysvar_command_log_truncate_debug= false;
 
78
static const char DEFAULT_LOG_FILE_PATH[]= "command.log"; /* In datadir... */
79
79
 
80
 
SerialEventLog::SerialEventLog(const char *in_log_file_path)
 
80
CommandLog::CommandLog(const char *in_log_file_path)
81
81
  : 
82
82
    drizzled::plugin::Applier(),
83
 
    state(SerialEventLog::OFFLINE),
 
83
    state(CommandLog::OFFLINE),
84
84
    log_file_path(in_log_file_path)
85
85
{
86
86
  is_enabled= true; /* If constructed, the plugin is enabled until taken offline with disable() */
90
90
  log_file= open(log_file_path, O_APPEND|O_CREAT|O_SYNC|O_WRONLY, S_IRWXU);
91
91
  if (log_file == -1)
92
92
  {
93
 
    errmsg_printf(ERRMSG_LVL_ERROR, _("Failed to open serial event log file.  Got error: %s"), strerror(errno));
 
93
    errmsg_printf(ERRMSG_LVL_ERROR, _("Failed to open command log file.  Got error: %s"), strerror(errno));
94
94
    is_active= false;
95
95
    return;
96
96
  }
101
101
   */
102
102
  log_offset= lseek(log_file, 0, SEEK_END);
103
103
 
104
 
  state= SerialEventLog::ONLINE;
 
104
  state= CommandLog::ONLINE;
105
105
  is_active= true;
106
106
}
107
107
 
108
 
SerialEventLog::~SerialEventLog()
 
108
CommandLog::~CommandLog()
109
109
{
110
110
  /* Clear up any resources we've consumed */
111
111
  if (isActive() && log_file != -1)
114
114
  }
115
115
}
116
116
 
117
 
bool SerialEventLog::isActive()
 
117
bool CommandLog::isActive()
118
118
{
119
119
  return is_enabled && is_active;
120
120
}
121
121
 
122
 
void SerialEventLog::apply(drizzled::message::Command *to_apply)
 
122
void CommandLog::apply(drizzled::message::Command *to_apply)
123
123
{
124
124
  std::string buffer; /* Buffer we will write serialized command to */
125
125
  uint64_t length;
163
163
   * not be active, therefore a caller could have been ready
164
164
   * to write...but the log is crashed.
165
165
   */
166
 
  if (unlikely(state == SerialEventLog::CRASHED))
 
166
  if (unlikely(state == CommandLog::CRASHED))
167
167
    return;
168
168
 
169
169
  /* We always write in network byte order */
202
202
   * Quick safety...if an error occurs above in another writer, the log 
203
203
   * file will be in a crashed state.
204
204
   */
205
 
  if (unlikely(state == SerialEventLog::CRASHED))
 
205
  if (unlikely(state == CommandLog::CRASHED))
206
206
  {
207
207
    /* 
208
208
     * Reset the log's offset in case we want to produce a decent error message including
235
235
  }
236
236
}
237
237
 
238
 
void SerialEventLog::truncate()
 
238
void CommandLog::truncate()
239
239
{
240
240
  bool orig_is_enabled= is_enabled;
241
241
  is_enabled= false;
262
262
  is_enabled= orig_is_enabled;
263
263
}
264
264
 
265
 
static SerialEventLog *serial_event_log= NULL; /* The singleton serial log */
 
265
static CommandLog *command_log= NULL; /* The singleton command log */
266
266
 
267
267
static int init(PluginRegistry &registry)
268
268
{
269
 
  if (sysvar_serial_event_log_enabled)
 
269
  if (sysvar_command_log_enabled)
270
270
  {
271
 
    serial_event_log= new SerialEventLog(sysvar_serial_event_log_file);
272
 
    registry.add(serial_event_log);
 
271
    command_log= new CommandLog(sysvar_command_log_file);
 
272
    registry.add(command_log);
273
273
  }
274
274
  return 0;
275
275
}
276
276
 
277
277
static int deinit(PluginRegistry &registry)
278
278
{
279
 
  if (serial_event_log)
 
279
  if (command_log)
280
280
  {
281
 
    registry.remove(serial_event_log);
282
 
    delete serial_event_log;
 
281
    registry.remove(command_log);
 
282
    delete command_log;
283
283
  }
284
284
  return 0;
285
285
}
290
290
   * The const void * save comes directly from the check function, 
291
291
   * which should simply return the result from the set statement. 
292
292
   */
293
 
  fprintf(stdout, "Holy crap.\n");
294
 
  if (serial_event_log)
 
293
  if (command_log)
295
294
    if (*(bool *)save != false)
296
 
      serial_event_log->truncate();
 
295
      command_log->truncate();
297
296
}
298
297
 
299
298
static DRIZZLE_SYSVAR_BOOL(enable,
300
 
                          sysvar_serial_event_log_enabled,
 
299
                          sysvar_command_log_enabled,
301
300
                          PLUGIN_VAR_NOCMDARG,
302
 
                          N_("Enable serial event log"),
 
301
                          N_("Enable command log"),
303
302
                          NULL, /* check func */
304
303
                          NULL, /* update func */
305
304
                          false /* default */);
306
305
 
307
306
static DRIZZLE_SYSVAR_BOOL(truncate_debug,
308
 
                          sysvar_serial_event_log_truncate_debug,
 
307
                          sysvar_command_log_truncate_debug,
309
308
                          PLUGIN_VAR_NOCMDARG,
310
 
                          N_("DEBUGGING - Truncate serial event log"),
 
309
                          N_("DEBUGGING - Truncate command log"),
311
310
                          NULL, /* check func */
312
311
                          set_truncate_debug, /* update func */
313
312
                          false /* default */);
314
313
 
315
314
static DRIZZLE_SYSVAR_STR(log_file,
316
 
                          sysvar_serial_event_log_file,
 
315
                          sysvar_command_log_file,
317
316
                          PLUGIN_VAR_READONLY,
318
 
                          N_("Path to the file to use for serial event log."),
 
317
                          N_("Path to the file to use for command log."),
319
318
                          NULL, /* check func */
320
319
                          NULL, /* update func*/
321
320
                          DEFAULT_LOG_FILE_PATH /* default */);
327
326
  NULL
328
327
};
329
328
 
330
 
drizzle_declare_plugin(serial_event_log)
 
329
drizzle_declare_plugin(command_log)
331
330
{
332
 
  "serial_event_log",
 
331
  "command_log",
333
332
  "0.1",
334
333
  "Jay Pipes",
335
 
  N_("Default Serial Event Log"),
 
334
  N_("Simple Command Message Log"),
336
335
  PLUGIN_LICENSE_GPL,
337
336
  init, /* Plugin Init */
338
337
  deinit, /* Plugin Deinit */