Merge lp:~jaypipes/drizzle/split-xa-resource-manager into lp:~drizzle-trunk/drizzle/development

[Jay Pipes]

[Jay Pipes (jaypipes)]

    * Completes the blueprint for splitting the XA Resource Manager
      API from the storage engine API:

    We add a new plugin::XaResourceManager abstract interface class
    which exposes the X/Open XA distributed transaction protocol for
    resource managers.

    We add a new plugin::MonitoredInTransaction base class from
    which all plugins that need monitored by Drizzle's transaction
    manager (drizzled::TransactionServices component) derive.

    All plugin::StorageEngine's now derive from plugin::MonitoredInTransaction
    since all storage engines a monitored by the transaction manager
    and the Session keeps a "slot" available for keeping the engine's
    per-session data state. In a future patch, the transaction log's
    XaApplier plugin will also derive from MonitoredInTransaction, as
    the transaction log, in XA mode, is also monitored by Drizzle's
    transaction manager and automatically enlisted in XA transactions.

    * Updates all documentation in /drizzled/transaction_services.cc
      to accurately reflect Drizzle's new transaction management
      process and explicit transaction and statement boundaries.

    * Kills off dead code:

      binlog_format_names
      ha_init()
      total_ha, total_ha_2pc (no longer necessary, as the above-mentioned
      abstract base classes provide all of this functionality)
      StorageEngine::slot (now plugin::MonitoredInTransaction::getId())
      TransactionalStorageEngine::two_phase_commit (same as above)

[lp:~jaypipes/drizzle/split-xa-resource-manager]

1304. By Jay Pipes <jpipes@serialcoder> on 2010-03-04

Merge trunk

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

Merge fixes for LP Bug 530870

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

Merge trunk and add in data dictionary fix for OSX/FreeBSD

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

Add errno.h to a few files. Apparently, this is necessary on OSX.

=== 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 19:18:29 +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 19:18:29 +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 19:18:29 +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 19:18:29 +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 19:18:29 +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,93 +61,36 @@
  * 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>
 #include <unistd.h>
+#include <errno.h>
 
 #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 +101,6 @@
     error_message.append(strerror(errno));
     error_message.push_back('\n');
     has_error= true;
-    deactivate();
     return;
   }
 
@@ -187,74 +127,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 +159,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 +184,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 +231,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 +243,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 +268,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 19:18:29 +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 19:18:29 +0000
@@ -0,0 +1,146 @@
+/* - 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 <errno.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 19:18:29 +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 19:18:29 +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 19:18:29 +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 19:18:29 +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 19:18:29 +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
  */