Merge lp:~jaypipes/drizzle/refactor-trx-log-applier into lp:~drizzle-trunk/drizzle/development

[Jay Pipes]

Completes the blueprint for refactoring applier out of log descriptor.

1) Makes the TransactionLog class a simple descriptor for the actual transaction log file
2) Splits out the TransactionLogApplier into separate class with constructor taking a TransactionLog instance
3) Splits the module initialization stuff out into a file, /plugin/transaction_log/module.cc

[lp:~jaypipes/drizzle/refactor-trx-log-applier]

1307. By Jay Pipes <jpipes@serialcoder> on 2010-03-05

Make OSX/FreeBSD happy about size_t != uint64_t != int64_t...

=== modified file 'drizzled/plugin/transaction_reader.h'
--- drizzled/plugin/transaction_reader.h	2010-02-04 08:14:46 +0000
+++ drizzled/plugin/transaction_reader.h	2010-03-05 18:39:28 +0000
@@ -24,7 +24,8 @@
 #ifndef DRIZZLED_PLUGIN_TRANSACTION_READER_H
 #define DRIZZLED_PLUGIN_TRANSACTION_READER_H
 
-#include <drizzled/replication_services.h> /* For global transaction ID typedef */
+#include "drizzled/plugin/plugin.h"
+#include "drizzled/replication_services.h" /* For global transaction ID typedef */
 
 /**
  * @file Defines the API for a TransactionReader

=== modified file 'plugin/transaction_log/data_dictionary_schema.cc'
--- plugin/transaction_log/data_dictionary_schema.cc	2010-03-05 04:44:58 +0000
+++ plugin/transaction_log/data_dictionary_schema.cc	2010-03-05 18:39:28 +0000
@@ -121,7 +121,7 @@
   push(transaction_log_index->getMaxTransactionId());
   push(transaction_log_index->getMinEndTimestamp());
   push(transaction_log_index->getMaxEndTimestamp()); 
-  push(transaction_log_index->getSizeInBytes());
+  push(static_cast<uint64_t>(transaction_log_index->getSizeInBytes()));
 
   is_done= true;
   return true;

=== added file 'plugin/transaction_log/module.cc'
--- plugin/transaction_log/module.cc	1970-01-01 00:00:00 +0000
+++ plugin/transaction_log/module.cc	2010-03-05 18:39:28 +0000
@@ -0,0 +1,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 <[e-mail]>
+ *
+ *  Authors:
+ *
+ *  Jay Pipes <[e-mail]>
+ *
+ *  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;
+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;
+
+/** 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::Registry &registry)
+{
+  /* 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);
+
+    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 the applier plugin and register it */
+    transaction_log_applier= new (nothrow) TransactionLogApplier("transaction_log_applier",
+                                                                 *transaction_log, 
+                                                                 sysvar_transaction_log_checksum_enabled);
+    if (transaction_log_applier == NULL)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Failed to allocate the TransactionLogApplier instance.  Got error: %s\n"), 
+                    strerror(errno));
+      return 1;
+    }
+    registry.add(transaction_log_applier);
+
+    /* Setup DATA_DICTIONARY views */
+
+    transaction_log_tool= new (nothrow) TransactionLogTool;
+    registry.add(transaction_log_tool);
+    transaction_log_entries_tool= new (nothrow) TransactionLogEntriesTool;
+    registry.add(transaction_log_entries_tool);
+    transaction_log_transactions_tool= new (nothrow) TransactionLogTransactionsTool;
+    registry.add(transaction_log_transactions_tool);
+
+    /* Setup the module's UDFs */
+    print_transaction_message_func_factory=
+      new plugin::Create_function<PrintTransactionMessageFunction>("print_transaction_message");
+    registry.add(print_transaction_message_func_factory);
+
+    hexdump_transaction_message_func_factory=
+      new plugin::Create_function<HexdumpTransactionMessageFunction>("hexdump_transaction_message");
+    registry.add(hexdump_transaction_message_func_factory);
+
+    /* 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;
+      }
+    }
+
+    /* 
+     * 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 int deinit(drizzled::plugin::Registry &registry)
+{
+  /* Cleanup the transaction log itself */
+  if (transaction_log)
+  {
+    registry.remove(transaction_log_applier);
+    delete transaction_log;
+    delete transaction_log_index;
+
+    /* Cleanup the DATA_DICTIONARY views */
+    registry.remove(transaction_log_tool);
+    delete transaction_log_tool;
+    registry.remove(transaction_log_entries_tool);
+    delete transaction_log_entries_tool;
+    registry.remove(transaction_log_transactions_tool);
+    delete transaction_log_transactions_tool;
+
+    /* Cleanup module UDFs */
+    registry.remove(print_transaction_message_func_factory);
+    delete print_transaction_message_func_factory;
+    registry.remove(hexdump_transaction_message_func_factory);
+    delete hexdump_transaction_message_func_factory;
+  }
+
+  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(log_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_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_sys_var* sys_variables[]= {
+  DRIZZLE_SYSVAR(enable),
+  DRIZZLE_SYSVAR(truncate_debug),
+  DRIZZLE_SYSVAR(log_file),
+  DRIZZLE_SYSVAR(enable_checksum),
+  DRIZZLE_SYSVAR(sync_method),
+  NULL
+};
+
+DRIZZLE_PLUGIN(init, deinit, sys_variables);

=== modified file 'plugin/transaction_log/plugin.ini'
--- plugin/transaction_log/plugin.ini	2010-02-11 04:18:03 +0000
+++ plugin/transaction_log/plugin.ini	2010-03-05 18:39:28 +0000
@@ -1,13 +1,13 @@
 [plugin]
 name=transaction_log
-version=0.1
+version=0.1.1
 author=Jay Pipes
 license=PLUGIN_LICENSE_GPL
 title=Transaction Log
 description=Log of Transaction Messages
 load_by_default=yes
-sources= background_worker.cc hexdump_transaction_message.cc print_transaction_message.cc transaction_log.cc transaction_log_entry.cc transaction_log_index.cc transaction_log_reader.cc data_dictionary_schema.cc
-headers= background_worker.h hexdump_transaction_message.h print_transaction_message.h transaction_log.h transaction_log_entry.h transaction_log_index.h transaction_log_reader.h data_dictionary_schema.h
+sources= background_worker.cc hexdump_transaction_message.cc module.cc print_transaction_message.cc transaction_log.cc transaction_log_applier.cc transaction_log_entry.cc transaction_log_index.cc transaction_log_reader.cc data_dictionary_schema.cc
+headers= background_worker.h hexdump_transaction_message.h print_transaction_message.h transaction_log.h transaction_log_applier.h transaction_log_entry.h transaction_log_index.h transaction_log_reader.h data_dictionary_schema.h
 libs=${top_builddir}/drizzled/algorithm/libhash.la 
 libadd=$(LIBZ)
 cxxflags=${PROTOSKIP_WARNINGS}

=== modified file 'plugin/transaction_log/transaction_log.cc'
--- plugin/transaction_log/transaction_log.cc	2010-03-05 04:44:58 +0000
+++ plugin/transaction_log/transaction_log.cc	2010-03-05 18:39:28 +0000
@@ -2,10 +2,11 @@
  *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
  *
  *  Copyright (C) 2008-2009 Sun Microsystems
+ *  Copyright (c) 2010 Jay Pipes <[e-mail]>
  *
  *  Authors:
  *
- *  Jay Pipes <[e-mail]>
+ *  Jay Pipes <[e-mail]>
  *
  *  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
@@ -25,10 +26,7 @@
 /**
  * @file
  *
- * Defines the implementation of the default transaction log.
- *
- * @see drizzled/plugin/transaction_replicator.h
- * @see drizzled/plugin/transaction_applier.h
+ * Defines the implementation of the transaction log file descriptor.
  *
  * @details
  *
@@ -37,7 +35,7 @@
  * We have an atomic off_t called log_offset which keeps track of the 
  * offset into the log file for writing the next Transaction.
  *
- * We write Transaction message encapsulated in an 8-byte length header and a
+ * We write Transaction message encapsulated in an 8-byte length/type header and a
  * 4-byte checksum trailer.
  *
  * When writing a Transaction to the log, we calculate the length of the 
@@ -63,20 +61,10 @@
  * Possibly look at a scoreboard approach with multiple file segments.  For
  * right now, though, this is just a quick simple implementation to serve
  * as a skeleton and a springboard.
- *
- * @todo
- *
- * Move the Applier piece of this code out into its own source file and leave
- * this for all the glue code of the module.
  */
 
 #include "config.h"
 #include "transaction_log.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 <sys/stat.h>
 #include <fcntl.h>
@@ -85,71 +73,23 @@
 #include <vector>
 #include <string>
 
-#include "drizzled/internal/my_sys.h" /* for internal::my_sync */
-
-#include <drizzled/session.h>
-#include <drizzled/set_var.h>
+#include <drizzled/internal/my_sys.h> /* for internal::my_sync */
+#include <drizzled/errmsg_print.h>
 #include <drizzled/gettext.h>
-#include <drizzled/algorithm/crc32.h>
-#include <drizzled/message/transaction.pb.h>
-#include <google/protobuf/io/coded_stream.h>
 
 using namespace std;
 using namespace drizzled;
-using namespace google;
-
-/** 
- * 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;
-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;
-
-/** 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;
-
-/** 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(string name_arg,
-                               const string &in_log_file_path,
-                               bool in_do_checksum)
-  : plugin::TransactionApplier(name_arg),
+
+TransactionLog *transaction_log= NULL; /* The singleton transaction log */
+
+TransactionLog::TransactionLog(const string in_log_file_path,
+                               uint32_t in_sync_method) : 
     state(OFFLINE),
     log_file_path(in_log_file_path),
     has_error(false),
-    error_message()
+    error_message(),
+    sync_method(in_sync_method)
 {
-  do_checksum= in_do_checksum; /* Have to do here, not in initialization list b/c atomic<> */
-
   /* Setup our log file and determine the next write offset... */
   log_file= open(log_file_path.c_str(), O_APPEND|O_CREAT|O_SYNC|O_WRONLY, S_IRWXU);
   if (log_file == -1)
@@ -160,7 +100,6 @@
     error_message.append(strerror(errno));
     error_message.push_back('\n');
     has_error= true;
-    deactivate();
     return;
   }
 
@@ -187,74 +126,26 @@
 TransactionLog::~TransactionLog()
 {
   /* Clear up any resources we've consumed */
-  if (isEnabled() && log_file != -1)
+  if (log_file != -1)
   {
     (void) close(log_file);
   }
 }
 
-void TransactionLog::apply(const message::Transaction &to_apply)
+off_t TransactionLog::writeEntry(const uint8_t *data, size_t data_length)
 {
-  uint8_t *buffer; /* Buffer we will write serialized header, 
-                      message and trailing checksum to */
-  uint8_t *orig_buffer;
-
-  size_t message_byte_length= to_apply.ByteSize();
-  ssize_t written;
-  off_t cur_offset;
-  size_t total_envelope_length= HEADER_TRAILER_BYTES + message_byte_length;
-
-  /* 
-   * Attempt allocation of raw memory buffer for the header, 
-   * message and trailing checksum bytes.
-   */
-  buffer= static_cast<uint8_t *>(malloc(total_envelope_length));
-  if (buffer == NULL)
-  {
-    errmsg_printf(ERRMSG_LVL_ERROR, 
-                  _("Failed to allocate enough memory to buffer header, transaction message, and trailing checksum bytes. Tried to allocate %" PRId64
-                    " bytes.  Error: %s\n"), 
-                  static_cast<int64_t>(total_envelope_length),
-                  strerror(errno));
-    state= CRASHED;
-    deactivate();
-    return;
-  }
-  else
-    orig_buffer= buffer; /* We will free() orig_buffer, as buffer is moved during write */
+  ssize_t written= 0;
 
   /*
    * Do an atomic increment on the offset of the log file position
    */
-  cur_offset= log_offset.fetch_and_add(static_cast<off_t>(total_envelope_length));
+  off_t cur_offset= log_offset.fetch_and_add(static_cast<off_t>(data_length));
 
   /*
    * We adjust cur_offset back to the original log_offset before
    * the increment above...
    */
-  cur_offset-= static_cast<off_t>((total_envelope_length));
-
-  /*
-   * Write the header information, which is the message type and
-   * the length of the transaction message into the buffer
-   */
-  buffer= protobuf::io::CodedOutputStream::WriteLittleEndian32ToArray(static_cast<uint32_t>(ReplicationServices::TRANSACTION), buffer);
-  buffer= protobuf::io::CodedOutputStream::WriteLittleEndian32ToArray(static_cast<uint32_t>(message_byte_length), buffer);
-  
-  /*
-   * Now write the serialized transaction message, followed
-   * by the optional checksum into the buffer.
-   */
-  buffer= to_apply.SerializeWithCachedSizesToArray(buffer);
-
-  uint32_t checksum= 0;
-  if (do_checksum)
-  {
-    checksum= drizzled::algorithm::crc32(reinterpret_cast<char *>(buffer) - message_byte_length, message_byte_length);
-  }
-
-  /* We always write in network byte order */
-  buffer= protobuf::io::CodedOutputStream::WriteLittleEndian32ToArray(checksum, buffer);
+  cur_offset-= static_cast<off_t>(data_length);
 
   /* 
    * Quick safety...if an error occurs above in another writer, the log 
@@ -267,23 +158,22 @@
      * the original offset where an error occurred.
      */
     log_offset= cur_offset;
-    free(orig_buffer);
-    return;
+    return log_offset;
   }
 
   /* Write the full buffer in one swoop */
   do
   {
-    written= pwrite(log_file, orig_buffer, total_envelope_length, cur_offset);
+    written= pwrite(log_file, data, data_length, cur_offset);
   }
   while (written == -1 && errno == EINTR); /* Just retry the write when interrupted by a signal... */
 
-  if (unlikely(written != static_cast<ssize_t>(total_envelope_length)))
+  if (unlikely(written != static_cast<ssize_t>(data_length)))
   {
     errmsg_printf(ERRMSG_LVL_ERROR, 
-                  _("Failed to write full size of transaction.  Tried to write %" PRId64
+                  _("Failed to write full size of log entry.  Tried to write %" PRId64
                     " bytes at offset %" PRId64 ", but only wrote %" PRId32 " bytes.  Error: %s\n"), 
-                  static_cast<int64_t>(total_envelope_length),
+                  static_cast<int64_t>(data_length),
                   static_cast<int64_t>(cur_offset),
                   static_cast<int64_t>(written), 
                   strerror(errno));
@@ -293,29 +183,22 @@
      * the original offset where an error occurred.
      */
     log_offset= cur_offset;
-    deactivate();
   }
-  free(orig_buffer);
 
   int error_code= syncLogFile();
 
-  transaction_log_index->addEntry(TransactionLogEntry(ReplicationServices::TRANSACTION,
-                                                     cur_offset,
-                                                     total_envelope_length),
-                                  to_apply,
-                                  checksum);
-
   if (unlikely(error_code != 0))
   {
     errmsg_printf(ERRMSG_LVL_ERROR, 
                   _("Failed to sync log file. Got error: %s\n"), 
                   strerror(errno));
   }
+  return cur_offset;
 }
 
 int TransactionLog::syncLogFile()
 {
-  switch (sysvar_transaction_log_sync_method)
+  switch (sync_method)
   {
   case SYNC_METHOD_EVERY_WRITE:
     return internal::my_sync(log_file, 0);
@@ -347,20 +230,11 @@
 
 void TransactionLog::truncate()
 {
-  bool orig_is_enabled= isEnabled();
-  disable();
-  
   /* 
-   * Wait a short amount of time before truncating.  This just prevents error messages
-   * from being produced during a call to apply().  Calling disable() above
-   * means that once the current caller to apply() is done, no other calls are made to
-   * apply() before enable is reset to its original state
-   *
    * @note
    *
-   * This is DEBUG code only!
+   * This is NOT THREAD SAFE! DEBUG/TEST code only!
    */
-  usleep(500); /* Sleep for half a second */
   log_offset= (off_t) 0;
   int result;
   do
@@ -368,12 +242,6 @@
     result= ftruncate(log_file, log_offset);
   }
   while (result == -1 && errno == EINTR);
-
-  /* Clear the transaction log index data */
-  transaction_log_index->clear();
-
-  if (orig_is_enabled)
-    enable();
 }
 
 bool TransactionLog::findLogFilenameContainingTransactionId(const ReplicationServices::GlobalTransactionId&,
@@ -399,180 +267,7 @@
   error_message.clear();
 }
 
-const std::string &TransactionLog::getErrorMessage() const
+const string &TransactionLog::getErrorMessage() const
 {
   return error_message;
 }
-
-TransactionLog *transaction_log= NULL; /* The singleton transaction log */
-
-static int init(drizzled::plugin::Registry &registry)
-{
-  /* Create and initialize the transaction log itself */
-  if (sysvar_transaction_log_enabled)
-  {
-    transaction_log= new (nothrow) TransactionLog("transaction_log_applier",
-                                                  string(sysvar_transaction_log_file), 
-                                                  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;
-      }
-    }
-    registry.add(transaction_log);
-
-    /* Setup DATA_DICTIONARY views */
-
-    transaction_log_tool= new(std::nothrow)TransactionLogTool;
-    registry.add(transaction_log_tool);
-    transaction_log_entries_tool= new(std::nothrow)TransactionLogEntriesTool;
-    registry.add(transaction_log_entries_tool);
-    transaction_log_transactions_tool= new(std::nothrow)TransactionLogTransactionsTool;
-    registry.add(transaction_log_transactions_tool);
-
-    /* Setup the module's UDFs */
-    print_transaction_message_func_factory=
-      new plugin::Create_function<PrintTransactionMessageFunction>("print_transaction_message");
-    registry.add(print_transaction_message_func_factory);
-
-    hexdump_transaction_message_func_factory=
-      new plugin::Create_function<HexdumpTransactionMessageFunction>("hexdump_transaction_message");
-    registry.add(hexdump_transaction_message_func_factory);
-
-    /* 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;
-      }
-    }
-
-    /* 
-     * 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 int deinit(drizzled::plugin::Registry &registry)
-{
-  /* Cleanup the transaction log itself */
-  if (transaction_log)
-  {
-    registry.remove(transaction_log);
-    delete transaction_log;
-    delete transaction_log_index;
-
-    /* Cleanup the DATA_DICTIONARY views */
-    registry.remove(transaction_log_tool);
-    delete transaction_log_tool;
-    registry.remove(transaction_log_entries_tool);
-    delete transaction_log_entries_tool;
-    registry.remove(transaction_log_transactions_tool);
-    delete transaction_log_transactions_tool;
-
-    /* Cleanup module UDFs */
-    registry.remove(print_transaction_message_func_factory);
-    delete print_transaction_message_func_factory;
-    registry.remove(hexdump_transaction_message_func_factory);
-    delete hexdump_transaction_message_func_factory;
-  }
-
-  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();
-}
-
-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(log_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_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_sys_var* sys_variables[]= {
-  DRIZZLE_SYSVAR(enable),
-  DRIZZLE_SYSVAR(truncate_debug),
-  DRIZZLE_SYSVAR(log_file),
-  DRIZZLE_SYSVAR(enable_checksum),
-  DRIZZLE_SYSVAR(sync_method),
-  NULL
-};
-
-DRIZZLE_PLUGIN(init, deinit, sys_variables);

=== modified file 'plugin/transaction_log/transaction_log.h'
--- plugin/transaction_log/transaction_log.h	2009-12-11 18:39:37 +0000
+++ plugin/transaction_log/transaction_log.h	2010-03-05 18:39:28 +0000
@@ -2,10 +2,11 @@
  *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
  *
  *  Copyright (C) 2008-2009 Sun Microsystems
+ *  Copyright (c) 2010 Jay Pipes <[e-mail]>
  *
  *  Authors:
  *
- *  Jay Pipes <[e-mail]>
+ *  Jay Pipes <[e-mail]>
  *
  *  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
@@ -25,18 +26,13 @@
 /**
  * @file
  *
- * Defines the API of the default transaction log.
- *
- * @see drizzled/plugin/replicator.h
- * @see drizzled/plugin/applier.h
+ * Defines the API of the transaction log file descriptor.
  *
  * @details
  *
- * The TransactionLog applies events it receives from the ReplicationServices
- * server component to a simple log file on disk.
- * 
- * Transactions are received in no guaranteed order and the command log
- * is in charge of writing these events to the log as they are received.
+ * Basically, the TransactionLog is a descriptor for a log
+ * file containing transaction messages that is written by
+ * the TransactionLogApplier plugin(s).
  */
 
 #ifndef PLUGIN_TRANSACTION_LOG_TRANSACTION_LOG_H
@@ -44,15 +40,13 @@
 
 #include <drizzled/atomics.h>
 #include <drizzled/replication_services.h>
-#include <drizzled/plugin/transaction_replicator.h>
-#include <drizzled/plugin/transaction_applier.h>
 
 #include "transaction_log_entry.h"
 
 #include <vector>
 #include <string>
 
-class TransactionLog: public drizzled::plugin::TransactionApplier 
+class TransactionLog
 {
 public:
   static const uint32_t HEADER_TRAILER_BYTES= sizeof(uint32_t) + /* 4-byte msg type header */
@@ -75,31 +69,13 @@
   static const uint32_t SYNC_METHOD_EVERY_WRITE= 1; //< Sync on every write to the log file
   static const uint32_t SYNC_METHOD_EVERY_SECOND= 2; ///< Sync no more than once a second
 public:
-  TransactionLog(std::string name_arg,
-                 const std::string &in_log_file_path,
-                 bool in_do_checksum);
+  TransactionLog(const std::string in_log_file_path,
+                 uint32_t in_sync_method);
 
   /** Destructor */
   ~TransactionLog();
 
   /**
-   * Applies a Transaction to the serial log
-   *
-   * @note
-   *
-   * It is important to note that memory allocation for the 
-   * supplied pointer is not guaranteed after the completion 
-   * of this function -- meaning the caller can dispose of the
-   * supplied message.  Therefore, appliers which are
-   * implementing an asynchronous replication system must copy
-   * the supplied message to their own controlled memory storage
-   * area.
-   *
-   * @param Transaction message to be replicated
-   */
-  void apply(const drizzled::message::Transaction &to_apply);
-
-  /**
    * Returns the current offset into the log
    */
   inline off_t getLogOffset()
@@ -126,6 +102,19 @@
   }
 
   /**
+   * Writes a chunk of data to the log file of a specified
+   * length and returns the offset at which the chunk of
+   * data was written.
+   *
+   * @param[in] Bytes to write
+   * @param[in[ Length of bytes to write
+   *
+   * @retval
+   *  Returns the write offset if the write succeeded, OFF_T_MAX otherwise.
+   */
+  off_t writeEntry(const uint8_t *data, size_t data_length);
+
+  /**
    * Truncates the existing log file
    *
    * @note 
@@ -185,12 +174,12 @@
 
   int log_file; ///< Handle for our log file
   Status state; ///< The state the log is in
-  drizzled::atomic<bool> do_checksum; ///< Do a CRC32 checksum when writing Transaction message to log?
   const std::string log_file_path; ///< Full path to the log file
   std::string log_file_name; ///< Name of the log file
   drizzled::atomic<off_t> log_offset; ///< Offset in log file where log will write next command
   bool has_error; ///< Is the log in error?
   std::string error_message; ///< Current error message
+  uint32_t sync_method; ///< Determines behaviour of syncing log file
   time_t last_sync_time; ///< Last time the log file was synced (only set in SYNC_METHOD_EVERY_SECOND)
 };
 

=== added file 'plugin/transaction_log/transaction_log_applier.cc'
--- plugin/transaction_log/transaction_log_applier.cc	1970-01-01 00:00:00 +0000
+++ plugin/transaction_log/transaction_log_applier.cc	2010-03-05 18:39:28 +0000
@@ -0,0 +1,145 @@
+/* - 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 <[e-mail]>
+ *
+ *  Authors:
+ *
+ *  Jay Pipes <[e-mail]>
+ *
+ *  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
+ *
+ * Defines the implementation of the transaction applier plugin
+ * for the transaction log.
+ *
+ * @see drizzled/plugin/transaction_replicator.h
+ * @see drizzled/plugin/transaction_applier.h
+ *
+ * @details
+ *
+ * The TransactionLogApplier::apply() method constructs the entry
+ * in the transaction log from the supplied Transaction message and
+ * asks its associated TransactionLog object to write this entry.
+ *
+ * Upon a successful write, the applier adds some information about
+ * the written transaction to the transaction log index.
+ */
+
+#include "config.h"
+#include "transaction_log.h"
+#include "transaction_log_applier.h"
+#include "transaction_log_index.h"
+
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <drizzled/errmsg_print.h>
+#include <drizzled/gettext.h>
+#include <drizzled/algorithm/crc32.h>
+#include <drizzled/message/transaction.pb.h>
+#include <google/protobuf/io/coded_stream.h>
+
+using namespace std;
+using namespace drizzled;
+using namespace google;
+
+TransactionLogApplier *transaction_log_applier= NULL; /* The singleton transaction log applier */
+
+extern TransactionLogIndex *transaction_log_index;
+
+TransactionLogApplier::TransactionLogApplier(const string name_arg,
+                                             TransactionLog &in_transaction_log,
+                                             bool in_do_checksum) :
+  plugin::TransactionApplier(name_arg),
+  transaction_log(in_transaction_log),  
+  do_checksum(in_do_checksum)
+{
+}
+
+TransactionLogApplier::~TransactionLogApplier()
+{
+}
+
+void TransactionLogApplier::apply(const message::Transaction &to_apply)
+{
+  uint8_t *buffer; /* Buffer we will write serialized header, 
+                      message and trailing checksum to */
+  uint8_t *orig_buffer;
+
+  size_t message_byte_length= to_apply.ByteSize();
+  size_t total_envelope_length= TransactionLog::HEADER_TRAILER_BYTES + message_byte_length;
+
+  /* 
+   * Attempt allocation of raw memory buffer for the header, 
+   * message and trailing checksum bytes.
+   */
+  buffer= static_cast<uint8_t *>(malloc(total_envelope_length));
+  if (buffer == NULL)
+  {
+    errmsg_printf(ERRMSG_LVL_ERROR, 
+                  _("Failed to allocate enough memory to buffer header, "
+                    "transaction message, and trailing checksum bytes. Tried to allocate %" PRId64
+                    " bytes.  Error: %s\n"), 
+                  static_cast<int64_t>(total_envelope_length),
+                  strerror(errno));
+    return;
+  }
+  else
+    orig_buffer= buffer; /* We will free() orig_buffer, as buffer is moved during write */
+
+  /*
+   * Write the header information, which is the message type and
+   * the length of the transaction message into the buffer
+   */
+  buffer= protobuf::io::CodedOutputStream::WriteLittleEndian32ToArray(
+      static_cast<uint32_t>(ReplicationServices::TRANSACTION), buffer);
+  buffer= protobuf::io::CodedOutputStream::WriteLittleEndian32ToArray(
+      static_cast<uint32_t>(message_byte_length), buffer);
+  
+  /*
+   * Now write the serialized transaction message, followed
+   * by the optional checksum into the buffer.
+   */
+  buffer= to_apply.SerializeWithCachedSizesToArray(buffer);
+
+  uint32_t checksum= 0;
+  if (do_checksum)
+  {
+    checksum= drizzled::algorithm::crc32(
+        reinterpret_cast<char *>(buffer) - message_byte_length, message_byte_length);
+  }
+
+  /* We always write in network byte order */
+  buffer= protobuf::io::CodedOutputStream::WriteLittleEndian32ToArray(checksum, buffer);
+
+  /* Ask the transaction log to write the entry and return where it wrote it */
+  off_t written_to= transaction_log.writeEntry(orig_buffer, total_envelope_length);
+
+  free(orig_buffer);
+
+  /* Add an entry to the index describing what was just applied */
+  transaction_log_index->addEntry(TransactionLogEntry(ReplicationServices::TRANSACTION,
+                                                      written_to,
+                                                      total_envelope_length),
+                                  to_apply,
+                                  checksum);
+
+}

=== added file 'plugin/transaction_log/transaction_log_applier.h'
--- plugin/transaction_log/transaction_log_applier.h	1970-01-01 00:00:00 +0000
+++ plugin/transaction_log/transaction_log_applier.h	2010-03-05 18:39:28 +0000
@@ -0,0 +1,83 @@
+/* - 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 <[e-mail]>
+ *
+ *  Authors:
+ *
+ *  Jay Pipes <[e-mail]>
+ *
+ *  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
+ *
+ * Defines the API of the transaction log applier.
+ *
+ * @see drizzled/plugin/replicator.h
+ * @see drizzled/plugin/applier.h
+ */
+
+#ifndef PLUGIN_TRANSACTION_LOG_TRANSACTION_LOG_APPLIER_H
+#define PLUGIN_TRANSACTION_LOG_TRANSACTION_LOG_APPLIER_H
+
+#include <drizzled/replication_services.h>
+#include <drizzled/plugin/transaction_applier.h>
+
+#include "transaction_log_entry.h"
+
+#include <vector>
+#include <string>
+
+class TransactionLog;
+
+class TransactionLogApplier: public drizzled::plugin::TransactionApplier 
+{
+public:
+  TransactionLogApplier(const std::string name_arg,
+                        TransactionLog &in_transaction_log,
+                        bool in_do_checksum);
+
+  /** Destructor */
+  ~TransactionLogApplier();
+
+  /**
+   * Applies a Transaction to the serial log
+   *
+   * @note
+   *
+   * It is important to note that memory allocation for the 
+   * supplied pointer is not guaranteed after the completion 
+   * of this function -- meaning the caller can dispose of the
+   * supplied message.  Therefore, appliers which are
+   * implementing an asynchronous replication system must copy
+   * the supplied message to their own controlled memory storage
+   * area.
+   *
+   * @param Transaction message to be replicated
+   */
+  void apply(const drizzled::message::Transaction &to_apply);
+private:
+  /* Don't allows these */
+  TransactionLogApplier();
+  TransactionLogApplier(const TransactionLogApplier &other);
+  TransactionLogApplier &operator=(const TransactionLogApplier &other);
+  TransactionLog &transaction_log;
+  bool do_checksum; ///< Do a CRC32 checksum when writing Transaction message to log?
+};
+
+#endif /* PLUGIN_TRANSACTION_LOG_TRANSACTION_LOG_APPLIER_H */

=== modified file 'plugin/transaction_log/transaction_log_index.cc'
--- plugin/transaction_log/transaction_log_index.cc	2010-03-05 04:44:58 +0000
+++ plugin/transaction_log/transaction_log_index.cc	2010-03-05 18:39:28 +0000
@@ -42,7 +42,6 @@
 
 TransactionLogIndex::TransactionLogIndex(TransactionLog &in_log) :
   log(in_log),
-  log_file(-1),
   index_file(-1),
   index_file_path(),
   has_error(false),

=== modified file 'plugin/transaction_log/transaction_log_index.h'
--- plugin/transaction_log/transaction_log_index.h	2010-03-05 04:44:58 +0000
+++ plugin/transaction_log/transaction_log_index.h	2010-03-05 18:39:28 +0000
@@ -131,7 +131,6 @@
   void clearError();
 
   TransactionLog &log; ///< The transaction log instance
-  int log_file; ///< File descriptor for the transaction log file
   int index_file; ///< File descriptor for the transaction log on-disk index file
   const std::string index_file_path; ///< Filename of the on-disk transaction log index
   bool has_error; ///< Index is in error mode?

=== modified file 'plugin/transaction_log/transaction_log_reader.cc'
--- plugin/transaction_log/transaction_log_reader.cc	2010-01-06 02:20:42 +0000
+++ plugin/transaction_log/transaction_log_reader.cc	2010-03-05 18:39:28 +0000
@@ -49,6 +49,7 @@
 #include <cerrno>
 
 #include "transaction_log_reader.h"
+#include "transaction_log.h"
 
 #include <drizzled/gettext.h>
 #include <drizzled/message/transaction.pb.h>

=== modified file 'plugin/transaction_log/transaction_log_reader.h'
--- plugin/transaction_log/transaction_log_reader.h	2009-10-20 03:04:07 +0000
+++ plugin/transaction_log/transaction_log_reader.h	2010-03-05 18:39:28 +0000
@@ -38,10 +38,10 @@
 #ifndef PLUGIN_TRANSACTION_LOG_TRANSACTION_LOG_READER_H
 #define PLUGIN_TRANSACTION_LOG_TRANSACTION_LOG_READER_H
 
-#include "transaction_log.h"
-
 #include <drizzled/plugin/transaction_reader.h>
 
+class TransactionLog;
+
 /**
  * A class which reads Transaction messages from the Transaction log file
  */