← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/transaction_log/module.cc

  • Committer: Daniel Nichter
  • Date: 2011-10-23 16:01:37 UTC
  • mto: This revision was merged to the branch mainline in revision 2448.
  • Revision ID: daniel@percona.com-20111023160137-7ac3blgz8z4tf8za
Add Administration Getting Started and Logging.  Capitalize SQL clause keywords.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/transaction_log/module.cc
 
1
/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
3
 *
 
4
 *  Copyright (C) 2008-2009 Sun Microsystems, Inc.
 
5
 *  Copyright (C) 2010 Jay Pipes <jaypipes@gmail.com>
 
6
 *
 
7
 *  Authors:
 
8
 *
 
9
 *  Jay Pipes <jaypipes@gmail.com.com>
 
10
 *
 
11
 *  This program is free software; you can redistribute it and/or modify
 
12
 *  it under the terms of the GNU General Public License as published by
 
13
 *  the Free Software Foundation; either version 2 of the License, or
 
14
 *  (at your option) any later version.
 
15
 *
 
16
 *  This program is distributed in the hope that it will be useful,
 
17
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
18
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
19
 *  GNU General Public License for more details.
 
20
 *
 
21
 *  You should have received a copy of the GNU General Public License
 
22
 *  along with this program; if not, write to the Free Software
 
23
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
24
 */
 
25
 
 
26
/**
 
27
 * @file
 
28
 *
 
29
 * Transaction log module initialization and plugin
 
30
 * registration.
 
31
 */
 
32
 
 
33
#include <config.h>
 
34
 
 
35
#include "transaction_log.h"
 
36
#include "transaction_log_applier.h"
 
37
#include "transaction_log_index.h"
 
38
#include "data_dictionary_schema.h"
 
39
#include "print_transaction_message.h"
 
40
#include "hexdump_transaction_message.h"
 
41
 
 
42
#include <errno.h>
 
43
 
 
44
#include <drizzled/plugin/plugin.h>
 
45
#include <drizzled/session.h>
 
46
#include <drizzled/gettext.h>
 
47
#include <boost/program_options.hpp>
 
48
#include <drizzled/module/option_map.h>
 
49
#include <drizzled/plugin/function.h>
 
50
 
 
51
namespace po= boost::program_options;
 
52
using namespace std;
 
53
using namespace drizzled;
 
54
 
 
55
/**
 
56
 * The name of the main transaction log file on disk.  With no prefix,
 
57
 * this goes into Drizzle's $datadir.
 
58
 */
 
59
static const char DEFAULT_LOG_FILE_PATH[]= "transaction.log"; /* In datadir... */
 
60
/** 
 
61
 * Transaction Log plugin system variable - Is the log enabled? Only used on init().  
 
62
 */
 
63
static bool sysvar_transaction_log_enabled= false;
 
64
 
 
65
/** Transaction Log plugin system variable - The path to the log file used */
 
66
static string sysvar_transaction_log_file;
 
67
 
 
68
/** 
 
69
 * Transaction Log plugin system variable - A debugging variable to assist 
 
70
 * in truncating the log file. 
 
71
 */
 
72
static bool sysvar_transaction_log_truncate_debug= false;
 
73
/** 
 
74
 * Transaction Log plugin system variable - Should we write a CRC32 checksum for 
 
75
 * each written Transaction message?
 
76
 */
 
77
static bool sysvar_transaction_log_checksum_enabled= false;
 
78
/**
 
79
 * Numeric option controlling the sync/flush behaviour of the transaction
 
80
 * log.  Options are:
 
81
 *
 
82
 * TransactionLog::FLUSH_FREQUENCY_OS == 0            ... let OS do sync'ing
 
83
 * TransactionLog::FLUSH_FREQUENCY_EVERY_WRITE == 1   ... sync on every write
 
84
 * TransactionLog::FLUSH_FREQUENCY_EVERY_SECOND == 2  ... sync at most once a second
 
85
 */
 
86
typedef constrained_check<uint32_t, 2, 0> flush_constraint;
 
87
static flush_constraint sysvar_transaction_log_flush_frequency;
 
88
/**
 
89
 * Transaction Log plugin system variable - Number of slots to create
 
90
 * for managing write buffers
 
91
 */
 
92
typedef constrained_check<uint32_t, 8192, 4> write_buffers_constraint;
 
93
static write_buffers_constraint sysvar_transaction_log_num_write_buffers;
 
94
/**
 
95
 * Transaction Log plugin system variable - The name of the replicator plugin
 
96
 * to pair the transaction log's applier with.  Defaults to "default"
 
97
 */
 
98
static const char DEFAULT_USE_REPLICATOR[]= "default";
 
99
static string sysvar_transaction_log_use_replicator;
 
100
 
 
101
/** DATA_DICTIONARY views */
 
102
static TransactionLogTool *transaction_log_tool;
 
103
static TransactionLogEntriesTool *transaction_log_entries_tool;
 
104
static TransactionLogTransactionsTool *transaction_log_transactions_tool;
 
105
 
 
106
/** Index defined in transaction_log_index.cc */
 
107
extern TransactionLogIndex *transaction_log_index;
 
108
/** Transaction Log descriptor defined in transaction_log.cc */
 
109
extern TransactionLog *transaction_log;
 
110
/** Transaction Log descriptor defined in transaction_log.cc */
 
111
extern TransactionLogApplier *transaction_log_applier;
 
112
 
 
113
/** Defined in print_transaction_message.cc */
 
114
extern plugin::Create_function<PrintTransactionMessageFunction> *print_transaction_message_func_factory;
 
115
extern plugin::Create_function<HexdumpTransactionMessageFunction> *hexdump_transaction_message_func_factory;
 
116
 
 
117
TransactionLog::~TransactionLog()
 
118
{
 
119
  /* Clear up any resources we've consumed */
 
120
  if (log_file != -1)
 
121
  {
 
122
    (void) close(log_file);
 
123
  }
 
124
}
 
125
 
 
126
static void set_truncate_debug(Session *, sql_var_t)
 
127
{
 
128
  if (transaction_log)
 
129
  {
 
130
    if (sysvar_transaction_log_truncate_debug)
 
131
    {
 
132
      transaction_log->truncate();
 
133
      transaction_log_index->clear();
 
134
      sysvar_transaction_log_truncate_debug= false;
 
135
    }
 
136
  }
 
137
}
 
138
 
 
139
static int init(drizzled::module::Context &context)
 
140
{
 
141
  context.registerVariable(new sys_var_bool_ptr_readonly("enable",
 
142
                                                         &sysvar_transaction_log_enabled));
 
143
  context.registerVariable(new sys_var_bool_ptr("truncate-debug",
 
144
                                                &sysvar_transaction_log_truncate_debug,
 
145
                                                set_truncate_debug));
 
146
 
 
147
  context.registerVariable(new sys_var_const_string("file",
 
148
                                                    sysvar_transaction_log_file));
 
149
  context.registerVariable(new sys_var_const_string("use-replicator",
 
150
                                                    sysvar_transaction_log_use_replicator));
 
151
  context.registerVariable(new sys_var_bool_ptr_readonly("enable-checksum",
 
152
                                                         &sysvar_transaction_log_checksum_enabled));
 
153
  context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("flush-frequency", sysvar_transaction_log_flush_frequency));
 
154
 
 
155
  context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("num-write-buffers",
 
156
                                                                            sysvar_transaction_log_num_write_buffers));
 
157
 
 
158
 
 
159
  /* Create and initialize the transaction log itself */
 
160
  if (sysvar_transaction_log_enabled)
 
161
  {
 
162
  
 
163
    transaction_log= new TransactionLog(sysvar_transaction_log_file,
 
164
                                                  static_cast<int>(sysvar_transaction_log_flush_frequency),
 
165
                                                  sysvar_transaction_log_checksum_enabled);
 
166
 
 
167
    if (transaction_log == NULL)
 
168
    {
 
169
      sql_perror(_("Failed to allocate the TransactionLog instance"), sysvar_transaction_log_file);
 
170
      return 1;
 
171
    }
 
172
    else
 
173
    {
 
174
      /* Check to see if the log was not created properly */
 
175
      if (transaction_log->hasError())
 
176
      {
 
177
        errmsg_printf(error::ERROR, _("Failed to initialize the Transaction Log.  Got error: %s\n"), 
 
178
                      transaction_log->getErrorMessage().c_str());
 
179
        return 1;
 
180
      }
 
181
    }
 
182
 
 
183
    /* Create and initialize the transaction log index */
 
184
    transaction_log_index= new TransactionLogIndex(*transaction_log);
 
185
      /* Check to see if the index was not created properly */
 
186
      if (transaction_log_index->hasError())
 
187
      {
 
188
        errmsg_printf(error::ERROR, _("Failed to initialize the Transaction Log Index.  Got error: %s\n"), 
 
189
                      transaction_log_index->getErrorMessage().c_str());
 
190
        return 1;
 
191
      }
 
192
 
 
193
    /* Create the applier plugin and register it */
 
194
    transaction_log_applier= new TransactionLogApplier("transaction_log_applier",
 
195
                                                                 transaction_log, 
 
196
                                                                 transaction_log_index, 
 
197
                                                                 static_cast<uint32_t>(sysvar_transaction_log_num_write_buffers));
 
198
    context.add(transaction_log_applier);
 
199
    ReplicationServices::attachApplier(transaction_log_applier, sysvar_transaction_log_use_replicator);
 
200
 
 
201
    /* Setup DATA_DICTIONARY views */
 
202
 
 
203
    transaction_log_tool= new TransactionLogTool;
 
204
    context.add(transaction_log_tool);
 
205
    transaction_log_entries_tool= new TransactionLogEntriesTool;
 
206
    context.add(transaction_log_entries_tool);
 
207
    transaction_log_transactions_tool= new TransactionLogTransactionsTool;
 
208
    context.add(transaction_log_transactions_tool);
 
209
 
 
210
    /* Setup the module's UDFs */
 
211
    print_transaction_message_func_factory=
 
212
      new plugin::Create_function<PrintTransactionMessageFunction>("print_transaction_message");
 
213
    context.add(print_transaction_message_func_factory);
 
214
 
 
215
    hexdump_transaction_message_func_factory=
 
216
      new plugin::Create_function<HexdumpTransactionMessageFunction>("hexdump_transaction_message");
 
217
    context.add(hexdump_transaction_message_func_factory);
 
218
  }
 
219
  return 0;
 
220
}
 
221
 
 
222
 
 
223
static void init_options(drizzled::module::option_context &context)
 
224
{
 
225
  context("truncate-debug",
 
226
          po::value<bool>(&sysvar_transaction_log_truncate_debug)->default_value(false)->zero_tokens(),
 
227
          _("DEBUGGING - Truncate transaction log"));
 
228
  context("enable-checksum",
 
229
          po::value<bool>(&sysvar_transaction_log_checksum_enabled)->default_value(false)->zero_tokens(),
 
230
          _("Enable CRC32 Checksumming of each written transaction log entry"));  
 
231
  context("enable",
 
232
          po::value<bool>(&sysvar_transaction_log_enabled)->default_value(false)->zero_tokens(),
 
233
          _("Enable transaction log"));
 
234
  context("file",
 
235
          po::value<string>(&sysvar_transaction_log_file)->default_value(DEFAULT_LOG_FILE_PATH),
 
236
          _("Path to the file to use for transaction log"));
 
237
  context("use-replicator",
 
238
          po::value<string>(&sysvar_transaction_log_use_replicator)->default_value(DEFAULT_USE_REPLICATOR),
 
239
          _("Name of the replicator plugin to use (default='default_replicator')")); 
 
240
  context("flush-frequency",
 
241
          po::value<flush_constraint>(&sysvar_transaction_log_flush_frequency)->default_value(0),
 
242
          _("0 == rely on operating system to sync log file (default), 1 == sync file at each transaction write, 2 == sync log file once per second"));
 
243
  context("num-write-buffers",
 
244
          po::value<write_buffers_constraint>(&sysvar_transaction_log_num_write_buffers)->default_value(8),
 
245
          _("Number of slots for in-memory write buffers (default=8)."));
 
246
}
 
247
 
 
248
DRIZZLE_PLUGIN(init, NULL, init_options);