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
|
/* - 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 <errno.h>
#include <drizzled/plugin/plugin.h>
#include <drizzled/session.h>
#include <drizzled/gettext.h>
#include <boost/program_options.hpp>
#include <drizzled/module/option_map.h>
namespace po= boost::program_options;
using namespace std;
using namespace drizzled;
/**
* 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 - Is the log enabled? Only used on init().
*/
static bool sysvar_transaction_log_enabled= false;
/** Transaction Log plugin system variable - The path to the log file used */
static string sysvar_transaction_log_file;
/**
* Transaction Log plugin system variable - A debugging variable to assist
* in truncating the log file.
*/
static bool sysvar_transaction_log_truncate_debug= false;
/**
* 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::FLUSH_FREQUENCY_OS == 0 ... let OS do sync'ing
* TransactionLog::FLUSH_FREQUENCY_EVERY_WRITE == 1 ... sync on every write
* TransactionLog::FLUSH_FREQUENCY_EVERY_SECOND == 2 ... sync at most once a second
*/
typedef constrained_check<uint32_t, 2, 0> flush_constraint;
static flush_constraint sysvar_transaction_log_flush_frequency;
/**
* Transaction Log plugin system variable - Number of slots to create
* for managing write buffers
*/
typedef constrained_check<uint32_t, 8192, 4> write_buffers_constraint;
static write_buffers_constraint sysvar_transaction_log_num_write_buffers;
/**
* Transaction Log plugin system variable - The name of the replicator plugin
* to pair the transaction log's applier with. Defaults to "default"
*/
static const char DEFAULT_USE_REPLICATOR[]= "default";
static string sysvar_transaction_log_use_replicator;
/** 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;
TransactionLog::~TransactionLog()
{
/* Clear up any resources we've consumed */
if (log_file != -1)
{
(void) close(log_file);
}
}
static void set_truncate_debug(Session *, sql_var_t)
{
if (transaction_log)
{
if (sysvar_transaction_log_truncate_debug)
{
transaction_log->truncate();
transaction_log_index->clear();
sysvar_transaction_log_truncate_debug= false;
}
}
}
static int init(drizzled::module::Context &context)
{
context.registerVariable(new sys_var_bool_ptr_readonly("enable",
&sysvar_transaction_log_enabled));
context.registerVariable(new sys_var_bool_ptr("truncate-debug",
&sysvar_transaction_log_truncate_debug,
set_truncate_debug));
context.registerVariable(new sys_var_const_string("file",
sysvar_transaction_log_file));
context.registerVariable(new sys_var_const_string("use-replicator",
sysvar_transaction_log_use_replicator));
context.registerVariable(new sys_var_bool_ptr_readonly("enable-checksum",
&sysvar_transaction_log_checksum_enabled));
context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("flush-frequency", sysvar_transaction_log_flush_frequency));
context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("num-write-buffers",
sysvar_transaction_log_num_write_buffers));
/* Create and initialize the transaction log itself */
if (sysvar_transaction_log_enabled)
{
transaction_log= new (nothrow) TransactionLog(sysvar_transaction_log_file,
static_cast<int>(sysvar_transaction_log_flush_frequency),
sysvar_transaction_log_checksum_enabled);
if (transaction_log == NULL)
{
char errmsg[STRERROR_MAX];
strerror_r(errno, errmsg, sizeof(errmsg));
errmsg_printf(ERRMSG_LVL_ERROR, _("Failed to allocate the TransactionLog instance. Got error: %s\n"),
errmsg);
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)
{
char errmsg[STRERROR_MAX];
strerror_r(errno, errmsg, sizeof(errmsg));
errmsg_printf(ERRMSG_LVL_ERROR, _("Failed to allocate the TransactionLogIndex instance. Got error: %s\n"),
errmsg);
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,
static_cast<uint32_t>(sysvar_transaction_log_num_write_buffers));
if (transaction_log_applier == NULL)
{
char errmsg[STRERROR_MAX];
strerror_r(errno, errmsg, sizeof(errmsg));
errmsg_printf(ERRMSG_LVL_ERROR, _("Failed to allocate the TransactionLogApplier instance. Got error: %s\n"),
errmsg);
return 1;
}
context.add(transaction_log_applier);
ReplicationServices &replication_services= ReplicationServices::singleton();
replication_services.attachApplier(transaction_log_applier,
sysvar_transaction_log_use_replicator);
/* 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 init_options(drizzled::module::option_context &context)
{
context("truncate-debug",
po::value<bool>(&sysvar_transaction_log_truncate_debug)->default_value(false)->zero_tokens(),
N_("DEBUGGING - Truncate transaction log"));
context("enable-checksum",
po::value<bool>(&sysvar_transaction_log_checksum_enabled)->default_value(false)->zero_tokens(),
N_("Enable CRC32 Checksumming of each written transaction log entry"));
context("enable",
po::value<bool>(&sysvar_transaction_log_enabled)->default_value(false)->zero_tokens(),
N_("Enable transaction log"));
context("file",
po::value<string>(&sysvar_transaction_log_file)->default_value(DEFAULT_LOG_FILE_PATH),
N_("Path to the file to use for transaction log"));
context("use-replicator",
po::value<string>(&sysvar_transaction_log_use_replicator)->default_value(DEFAULT_USE_REPLICATOR),
N_("Name of the replicator plugin to use (default='default_replicator')"));
context("flush-frequency",
po::value<flush_constraint>(&sysvar_transaction_log_flush_frequency)->default_value(0),
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"));
context("num-write-buffers",
po::value<write_buffers_constraint>(&sysvar_transaction_log_num_write_buffers)->default_value(8),
N_("Number of slots for in-memory write buffers (default=8)."));
}
DRIZZLE_PLUGIN(init, NULL, init_options);
|