← Back to branch summary

~ubuntu-branches/ubuntu/trusty/drizzle/trusty

« back to all changes in this revision

Viewing changes to plugin/transaction_log/module.cc

  • Committer: Package Import Robot
  • Author(s): Clint Byrum
  • Date: 2012-06-19 10:46:49 UTC
  • mfrom: (1.1.6)
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20120619104649-e2l0ggd4oz3um0f4
Tags: upstream-7.1.36-stable
Import upstream version 7.1.36-stable

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 (nothrow) 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 (nothrow) TransactionLogIndex(*transaction_log);
185
 
    if (transaction_log_index == NULL)
186
 
    {
187
 
      sql_perror(_("Failed to allocate the TransactionLogIndex instance"), sysvar_transaction_log_file);
188
 
      return 1;
189
 
    }
190
 
    else
191
 
    {
192
 
      /* Check to see if the index was not created properly */
193
 
      if (transaction_log_index->hasError())
194
 
      {
195
 
        errmsg_printf(error::ERROR, _("Failed to initialize the Transaction Log Index.  Got error: %s\n"), 
196
 
                      transaction_log_index->getErrorMessage().c_str());
197
 
        return 1;
198
 
      }
199
 
    }
200
 
 
201
 
    /* Create the applier plugin and register it */
202
 
    transaction_log_applier= new (nothrow) TransactionLogApplier("transaction_log_applier",
203
 
                                                                 transaction_log, 
204
 
                                                                 transaction_log_index, 
205
 
                                                                 static_cast<uint32_t>(sysvar_transaction_log_num_write_buffers));
206
 
    if (transaction_log_applier == NULL)
207
 
    {
208
 
      sql_perror(_("Failed to allocate the TransactionLogApplier instance"), sysvar_transaction_log_file);
209
 
      return 1;
210
 
    }
211
 
    context.add(transaction_log_applier);
212
 
    ReplicationServices &replication_services= ReplicationServices::singleton();
213
 
    replication_services.attachApplier(transaction_log_applier,
214
 
                                       sysvar_transaction_log_use_replicator);
215
 
 
216
 
    /* Setup DATA_DICTIONARY views */
217
 
 
218
 
    transaction_log_tool= new (nothrow) TransactionLogTool;
219
 
    context.add(transaction_log_tool);
220
 
    transaction_log_entries_tool= new (nothrow) TransactionLogEntriesTool;
221
 
    context.add(transaction_log_entries_tool);
222
 
    transaction_log_transactions_tool= new (nothrow) TransactionLogTransactionsTool;
223
 
    context.add(transaction_log_transactions_tool);
224
 
 
225
 
    /* Setup the module's UDFs */
226
 
    print_transaction_message_func_factory=
227
 
      new plugin::Create_function<PrintTransactionMessageFunction>("print_transaction_message");
228
 
    context.add(print_transaction_message_func_factory);
229
 
 
230
 
    hexdump_transaction_message_func_factory=
231
 
      new plugin::Create_function<HexdumpTransactionMessageFunction>("hexdump_transaction_message");
232
 
    context.add(hexdump_transaction_message_func_factory);
233
 
  }
234
 
  return 0;
235
 
}
236
 
 
237
 
 
238
 
static void init_options(drizzled::module::option_context &context)
239
 
{
240
 
  context("truncate-debug",
241
 
          po::value<bool>(&sysvar_transaction_log_truncate_debug)->default_value(false)->zero_tokens(),
242
 
          _("DEBUGGING - Truncate transaction log"));
243
 
  context("enable-checksum",
244
 
          po::value<bool>(&sysvar_transaction_log_checksum_enabled)->default_value(false)->zero_tokens(),
245
 
          _("Enable CRC32 Checksumming of each written transaction log entry"));  
246
 
  context("enable",
247
 
          po::value<bool>(&sysvar_transaction_log_enabled)->default_value(false)->zero_tokens(),
248
 
          _("Enable transaction log"));
249
 
  context("file",
250
 
          po::value<string>(&sysvar_transaction_log_file)->default_value(DEFAULT_LOG_FILE_PATH),
251
 
          _("Path to the file to use for transaction log"));
252
 
  context("use-replicator",
253
 
          po::value<string>(&sysvar_transaction_log_use_replicator)->default_value(DEFAULT_USE_REPLICATOR),
254
 
          _("Name of the replicator plugin to use (default='default_replicator')")); 
255
 
  context("flush-frequency",
256
 
          po::value<flush_constraint>(&sysvar_transaction_log_flush_frequency)->default_value(0),
257
 
          _("0 == rely on operating system to sync log file (default), 1 == sync file at each transaction write, 2 == sync log file once per second"));
258
 
  context("num-write-buffers",
259
 
          po::value<write_buffers_constraint>(&sysvar_transaction_log_num_write_buffers)->default_value(8),
260
 
          _("Number of slots for in-memory write buffers (default=8)."));
261
 
}
262
 
 
263
 
DRIZZLE_PLUGIN(init, NULL, init_options);