← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/transaction_log/transaction_log.h

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/transaction_log/transaction_log.h
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
4
 *  Copyright (C) 2008-2009 Sun Microsystems
 
5
 *  Copyright (c) 2010 Jay Pipes <jaypipes@gmail.com>
5
6
 *
6
7
 *  Authors:
7
8
 *
8
 
 *  Jay Pipes <joinfu@sun.com>
 
9
 *  Jay Pipes <jaypipes@gmail.com.com>
9
10
 *
10
11
 *  This program is free software; you can redistribute it and/or modify
11
12
 *  it under the terms of the GNU General Public License as published by
25
26
/**
26
27
 * @file
27
28
 *
28
 
 * Defines the API of the default transaction log.
29
 
 *
30
 
 * @see drizzled/plugin/replicator.h
31
 
 * @see drizzled/plugin/applier.h
 
29
 * Defines the API of the transaction log file descriptor.
32
30
 *
33
31
 * @details
34
32
 *
35
 
 * The TransactionLog applies events it receives from the ReplicationServices
36
 
 * server component to a simple log file on disk.
37
 
 * 
38
 
 * Transactions are received in no guaranteed order and the command log
39
 
 * is in charge of writing these events to the log as they are received.
 
33
 * Basically, the TransactionLog is a descriptor for a log
 
34
 * file containing transaction messages that is written by
 
35
 * the TransactionLogApplier plugin(s).
40
36
 */
41
37
 
42
38
#ifndef PLUGIN_TRANSACTION_LOG_TRANSACTION_LOG_H
44
40
 
45
41
#include <drizzled/atomics.h>
46
42
#include <drizzled/replication_services.h>
47
 
#include <drizzled/plugin/transaction_replicator.h>
48
 
#include <drizzled/plugin/transaction_applier.h>
49
43
 
50
44
#include "transaction_log_entry.h"
51
45
 
52
46
#include <vector>
53
47
#include <string>
54
48
 
55
 
class TransactionLog: public drizzled::plugin::TransactionApplier 
 
49
class TransactionLog
56
50
{
57
51
public:
58
52
  static const uint32_t HEADER_TRAILER_BYTES= sizeof(uint32_t) + /* 4-byte msg type header */
75
69
  static const uint32_t SYNC_METHOD_EVERY_WRITE= 1; //< Sync on every write to the log file
76
70
  static const uint32_t SYNC_METHOD_EVERY_SECOND= 2; ///< Sync no more than once a second
77
71
public:
78
 
  TransactionLog(std::string name_arg,
79
 
                 const std::string &in_log_file_path,
80
 
                 bool in_do_checksum);
 
72
  TransactionLog(const std::string in_log_file_path,
 
73
                 uint32_t in_sync_method);
81
74
 
82
75
  /** Destructor */
83
76
  ~TransactionLog();
84
77
 
85
78
  /**
86
 
   * Applies a Transaction to the serial log
87
 
   *
88
 
   * @note
89
 
   *
90
 
   * It is important to note that memory allocation for the 
91
 
   * supplied pointer is not guaranteed after the completion 
92
 
   * of this function -- meaning the caller can dispose of the
93
 
   * supplied message.  Therefore, appliers which are
94
 
   * implementing an asynchronous replication system must copy
95
 
   * the supplied message to their own controlled memory storage
96
 
   * area.
97
 
   *
98
 
   * @param Transaction message to be replicated
99
 
   */
100
 
  void apply(const drizzled::message::Transaction &to_apply);
101
 
 
102
 
  /**
103
79
   * Returns the current offset into the log
104
80
   */
105
81
  inline off_t getLogOffset()
126
102
  }
127
103
 
128
104
  /**
 
105
   * Writes a chunk of data to the log file of a specified
 
106
   * length and returns the offset at which the chunk of
 
107
   * data was written.
 
108
   *
 
109
   * @param[in] Bytes to write
 
110
   * @param[in[ Length of bytes to write
 
111
   *
 
112
   * @retval
 
113
   *  Returns the write offset if the write succeeded, OFF_T_MAX otherwise.
 
114
   */
 
115
  off_t writeEntry(const uint8_t *data, size_t data_length);
 
116
 
 
117
  /**
129
118
   * Truncates the existing log file
130
119
   *
131
120
   * @note 
185
174
 
186
175
  int log_file; ///< Handle for our log file
187
176
  Status state; ///< The state the log is in
188
 
  drizzled::atomic<bool> do_checksum; ///< Do a CRC32 checksum when writing Transaction message to log?
189
177
  const std::string log_file_path; ///< Full path to the log file
190
178
  std::string log_file_name; ///< Name of the log file
191
179
  drizzled::atomic<off_t> log_offset; ///< Offset in log file where log will write next command
192
180
  bool has_error; ///< Is the log in error?
193
181
  std::string error_message; ///< Current error message
 
182
  uint32_t sync_method; ///< Determines behaviour of syncing log file
194
183
  time_t last_sync_time; ///< Last time the log file was synced (only set in SYNC_METHOD_EVERY_SECOND)
195
184
};
196
185