1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
|
/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
*
* Copyright (C) 2008-2009 Sun Microsystems
* Copyright (c) 2010 Jay Pipes <jaypipes@gmail.com>
*
* Authors:
*
* Jay Pipes <jaypipes@gmail.com.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
/**
* @file
*
* Transaction log module initialization and plugin
* registration.
*/
#include "config.h"
#include "transaction_log.h"
#include "transaction_log_applier.h"
#include "transaction_log_index.h"
#include "data_dictionary_schema.h"
#include "print_transaction_message.h"
#include "hexdump_transaction_message.h"
#include "background_worker.h"
#include <drizzled/plugin/plugin.h>
#include <drizzled/session.h>
#include <drizzled/set_var.h>
#include <drizzled/gettext.h>
using namespace std;
using namespace drizzled;
/**
* Transaction Log plugin system variable - Is the log enabled? Only used on init().
* The enable() and disable() methods of the TransactionLog class control online
* disabling.
*/
static bool sysvar_transaction_log_enabled= false;
/** Transaction Log plugin system variable - The path to the log file used */
static char* sysvar_transaction_log_file= NULL;
/**
* Transaction Log plugin system variable - A debugging variable to assist
* in truncating the log file.
*/
static bool sysvar_transaction_log_truncate_debug= false;
/**
* The name of the main transaction log file on disk. With no prefix,
* this goes into Drizzle's $datadir.
*/
static const char DEFAULT_LOG_FILE_PATH[]= "transaction.log"; /* In datadir... */
/**
* Transaction Log plugin system variable - Should we write a CRC32 checksum for
* each written Transaction message?
*/
static bool sysvar_transaction_log_checksum_enabled= false;
/**
* Numeric option controlling the sync/flush behaviour of the transaction
* log. Options are:
*
* TransactionLog::SYNC_METHOD_OS == 0 ... let OS do sync'ing
* TransactionLog::SYNC_METHOD_EVERY_WRITE == 1 ... sync on every write
* TransactionLog::SYNC_METHOD_EVERY_SECOND == 2 ... sync at most once a second
*/
static uint32_t sysvar_transaction_log_sync_method= 0;
/**
* Transaction Log plugin system variable - Number of slots to create
* for managing write buffers
*/
static uint32_t sysvar_transaction_log_num_write_buffers= 8;
/**
* Transaction Log plugin system variable - The name of the replicator plugin
* to pair the transaction log's applier with. Defaults to "default"
*/
static char *sysvar_transaction_log_use_replicator= NULL;
static const char DEFAULT_USE_REPLICATOR[]= "default";
/** DATA_DICTIONARY views */
static TransactionLogTool *transaction_log_tool;
static TransactionLogEntriesTool *transaction_log_entries_tool;
static TransactionLogTransactionsTool *transaction_log_transactions_tool;
/** Index defined in transaction_log_index.cc */
extern TransactionLogIndex *transaction_log_index;
/** Transaction Log descriptor defined in transaction_log.cc */
extern TransactionLog *transaction_log;
/** Transaction Log descriptor defined in transaction_log.cc */
extern TransactionLogApplier *transaction_log_applier;
/** Defined in print_transaction_message.cc */
extern plugin::Create_function<PrintTransactionMessageFunction> *print_transaction_message_func_factory;
extern plugin::Create_function<HexdumpTransactionMessageFunction> *hexdump_transaction_message_func_factory;
static int init(drizzled::plugin::Context &context)
{
/* Create and initialize the transaction log itself */
if (sysvar_transaction_log_enabled)
{
transaction_log= new (nothrow) TransactionLog(string(sysvar_transaction_log_file),
sysvar_transaction_log_sync_method,
sysvar_transaction_log_checksum_enabled);
if (transaction_log == NULL)
{
errmsg_printf(ERRMSG_LVL_ERROR, _("Failed to allocate the TransactionLog instance. Got error: %s\n"),
strerror(errno));
return 1;
}
else
{
/* Check to see if the log was not created properly */
if (transaction_log->hasError())
{
errmsg_printf(ERRMSG_LVL_ERROR, _("Failed to initialize the Transaction Log. Got error: %s\n"),
transaction_log->getErrorMessage().c_str());
return 1;
}
}
/* Create and initialize the transaction log index */
transaction_log_index= new (nothrow) TransactionLogIndex(*transaction_log);
if (transaction_log_index == NULL)
{
errmsg_printf(ERRMSG_LVL_ERROR, _("Failed to allocate the TransactionLogIndex instance. Got error: %s\n"),
strerror(errno));
return 1;
}
else
{
/* Check to see if the index was not created properly */
if (transaction_log_index->hasError())
{
errmsg_printf(ERRMSG_LVL_ERROR, _("Failed to initialize the Transaction Log Index. Got error: %s\n"),
transaction_log_index->getErrorMessage().c_str());
return 1;
}
}
/* Create the applier plugin and register it */
transaction_log_applier= new (nothrow) TransactionLogApplier("transaction_log_applier",
transaction_log,
transaction_log_index,
sysvar_transaction_log_num_write_buffers);
if (transaction_log_applier == NULL)
{
errmsg_printf(ERRMSG_LVL_ERROR, _("Failed to allocate the TransactionLogApplier instance. Got error: %s\n"),
strerror(errno));
return 1;
}
context.add(transaction_log_applier);
ReplicationServices &replication_services= ReplicationServices::singleton();
string replicator_name(sysvar_transaction_log_use_replicator);
replication_services.attachApplier(transaction_log_applier, replicator_name);
/* Setup DATA_DICTIONARY views */
transaction_log_tool= new (nothrow) TransactionLogTool;
context.add(transaction_log_tool);
transaction_log_entries_tool= new (nothrow) TransactionLogEntriesTool;
context.add(transaction_log_entries_tool);
transaction_log_transactions_tool= new (nothrow) TransactionLogTransactionsTool;
context.add(transaction_log_transactions_tool);
/* Setup the module's UDFs */
print_transaction_message_func_factory=
new plugin::Create_function<PrintTransactionMessageFunction>("print_transaction_message");
context.add(print_transaction_message_func_factory);
hexdump_transaction_message_func_factory=
new plugin::Create_function<HexdumpTransactionMessageFunction>("hexdump_transaction_message");
context.add(hexdump_transaction_message_func_factory);
/*
* Setup the background worker thread which maintains
* summary information about the transaction log.
*/
if (initTransactionLogBackgroundWorker())
return 1; /* Error message output handled in function above */
}
return 0;
}
static void set_truncate_debug(Session *,
drizzle_sys_var *,
void *,
const void *save)
{
/*
* The const void * save comes directly from the check function,
* which should simply return the result from the set statement.
*/
if (transaction_log)
{
if (*(bool *)save != false)
{
transaction_log->truncate();
transaction_log_index->clear();
}
}
}
static DRIZZLE_SYSVAR_BOOL(enable,
sysvar_transaction_log_enabled,
PLUGIN_VAR_NOCMDARG,
N_("Enable transaction log"),
NULL, /* check func */
NULL, /* update func */
false /* default */);
static DRIZZLE_SYSVAR_BOOL(truncate_debug,
sysvar_transaction_log_truncate_debug,
PLUGIN_VAR_NOCMDARG,
N_("DEBUGGING - Truncate transaction log"),
NULL, /* check func */
set_truncate_debug, /* update func */
false /* default */);
static DRIZZLE_SYSVAR_STR(file,
sysvar_transaction_log_file,
PLUGIN_VAR_READONLY,
N_("Path to the file to use for transaction log"),
NULL, /* check func */
NULL, /* update func*/
DEFAULT_LOG_FILE_PATH /* default */);
static DRIZZLE_SYSVAR_STR(use_replicator,
sysvar_transaction_log_use_replicator,
PLUGIN_VAR_READONLY,
N_("Name of the replicator plugin to use (default='default_replicator')"),
NULL, /* check func */
NULL, /* update func*/
DEFAULT_USE_REPLICATOR /* default */);
static DRIZZLE_SYSVAR_BOOL(enable_checksum,
sysvar_transaction_log_checksum_enabled,
PLUGIN_VAR_NOCMDARG,
N_("Enable CRC32 Checksumming of each written transaction log entry"),
NULL, /* check func */
NULL, /* update func */
false /* default */);
static DRIZZLE_SYSVAR_UINT(sync_method,
sysvar_transaction_log_sync_method,
PLUGIN_VAR_OPCMDARG,
N_("0 == rely on operating system to sync log file (default), "
"1 == sync file at each transaction write, "
"2 == sync log file once per second"),
NULL, /* check func */
NULL, /* update func */
0, /* default */
0,
2,
0);
static DRIZZLE_SYSVAR_UINT(num_write_buffers,
sysvar_transaction_log_num_write_buffers,
PLUGIN_VAR_OPCMDARG,
N_("Number of slots for in-memory write buffers (default=8)."),
NULL, /* check func */
NULL, /* update func */
8, /* default */
4,
8192,
0);
static drizzle_sys_var* sys_variables[]= {
DRIZZLE_SYSVAR(enable),
DRIZZLE_SYSVAR(truncate_debug),
DRIZZLE_SYSVAR(file),
DRIZZLE_SYSVAR(enable_checksum),
DRIZZLE_SYSVAR(sync_method),
DRIZZLE_SYSVAR(num_write_buffers),
DRIZZLE_SYSVAR(use_replicator),
NULL
};
DRIZZLE_PLUGIN(init, sys_variables);
|