1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
4
* Copyright (C) 2008 Sun Microsystems
6
* This program is free software; you can redistribute it and/or modify
7
* it under the terms of the GNU General Public License as published by
8
* the Free Software Foundation; version 2 of the License.
10
* This program is distributed in the hope that it will be useful,
11
* but WITHOUT ANY WARRANTY; without even the implied warranty of
12
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13
* GNU General Public License for more details.
15
* You should have received a copy of the GNU General Public License
16
* along with this program; if not, write to the Free Software
17
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
23
#include <drizzled/replication/tblmap.h>
24
#include <drizzled/replication/reporting.h>
25
#include <drizzled/replication/utility.h>
31
/****************************************************************************
33
Replication SQL Thread
35
Relay_log_info contains:
36
- the current relay log
37
- the current relay log offset
39
- master log sequence corresponding to the last update
40
- misc information specific to the SQL thread
42
Relay_log_info is initialized from the slave.info file if such
43
exists. Otherwise, data members are intialized with defaults. The
44
initialization is done with init_relay_log_info() call.
46
The format of slave.info file:
53
To clean up, call end_relay_log_info()
55
*****************************************************************************/
57
class Relay_log_info : public Slave_reporting_capability
61
Flags for the state of the replication.
63
enum enum_state_flag {
64
/** The replication thread is inside a statement */
67
/** Flag counter. Should always be last */
72
If flag set, then rli does not store its state in any info file.
73
This is the case only when we execute BINLOG SQL commands inside
74
a client, non-replication thread.
79
If true, events with the same server id should be replicated. This
80
field is set on creation of a relay log info structure by copying
81
the value of ::replicate_same_server_id and can be overridden if
82
necessary. For example of when this is done, check sql_binlog.cc,
83
where the BINLOG statement can be used to execute "raw" events.
85
bool replicate_same_server_id;
87
/*** The following variables can only be read when protect by data lock ****/
90
info_fd - file descriptor of the info file. set only during
91
initialization or clean up - safe to read anytime
92
cur_log_fd - file descriptor of the current read relay log
94
File info_fd,cur_log_fd;
97
Protected with internal locks.
98
Must get data_lock when resetting the logs.
100
DRIZZLE_BIN_LOG relay_log;
102
IO_CACHE cache_buf,*cur_log;
104
/* The following variables are safe to read any time */
106
/* IO_CACHE of the info file - set only during init or end */
110
When we restart slave thread we need to have access to the previously
111
created temporary tables. Modified only on init/end and by the SQL
112
thread, read only by SQL thread.
114
Table *save_temporary_tables;
117
standard lock acquistion order to avoid deadlocks:
118
run_lock, data_lock, relay_log.LOCK_log, relay_log.LOCK_index
120
pthread_mutex_t data_lock,run_lock;
123
start_cond is broadcast when SQL thread is started
124
stop_cond - when stopped
125
data_cond - when data protected by data_lock changes
127
pthread_cond_t start_cond, stop_cond, data_cond;
129
/* parent Master_info structure */
133
Needed to deal properly with cur_log getting closed and re-opened with
134
a different log under our feet
136
uint32_t cur_log_old_open_count;
139
Let's call a group (of events) :
142
- an autocommiting query + its associated events (INSERT_ID,
144
We need these rli coordinates :
145
- relay log name and position of the beginning of the group we currently are
146
executing. Needed to know where we have to restart when replication has
147
stopped in the middle of a group (which has been rolled back by the slave).
148
- relay log name and position just after the event we have just
149
executed. This event is part of the current group.
150
Formerly we only had the immediately above coordinates, plus a 'pending'
151
variable, but this dealt wrong with the case of a transaction starting on a
152
relay log and finishing (commiting) on another relay log. Case which can
153
happen when, for example, the relay log gets rotated because of
156
std::string group_relay_log_name;
157
uint64_t group_relay_log_pos;
158
std::string event_relay_log_name;
159
uint64_t event_relay_log_pos;
160
uint64_t future_event_relay_log_pos;
163
bool is_fake; /* Mark that this is a fake relay log info structure */
167
Original log name and position of the group we're currently executing
168
(whose coordinates are group_relay_log_name/pos in the relay log)
169
in the master's binlog. These concern the *group*, because in the master's
170
binlog the log_pos that comes with each event is the position of the
171
beginning of the group.
173
std::string group_master_log_name;
174
volatile my_off_t group_master_log_pos;
177
Handling of the relay_log_space_limit optional constraint.
178
ignore_log_space_limit is used to resolve a deadlock between I/O and SQL
179
threads, the SQL thread sets it to unblock the I/O thread and make it
180
temporarily forget about the constraint.
182
uint64_t log_space_limit,log_space_total;
183
bool ignore_log_space_limit;
186
When it commits, InnoDB internally stores the master log position it has
187
processed so far; the position to store is the one of the end of the
188
committing event (the COMMIT query event, or the event if in autocommit
191
uint64_t future_group_master_log_pos;
193
time_t last_master_timestamp;
195
void clear_until_condition();
198
Needed for problems when slave stops and we want to restart it
199
skipping one or more events in the master log that have caused
200
errors, and have been manually applied by DBA already.
202
volatile uint32_t slave_skip_counter;
203
volatile uint32_t abort_pos_wait; /* Incremented on change master */
204
volatile uint32_t slave_run_id; /* Incremented on slave start */
205
pthread_mutex_t log_space_lock;
206
pthread_cond_t log_space_cond;
207
Session * sql_session;
208
int32_t events_till_abort;
210
/* if not set, the value of other members of the structure are undefined */
212
volatile bool abort_slave;
213
volatile uint32_t slave_running;
216
Condition and its parameters from START SLAVE UNTIL clause.
218
UNTIL condition is tested with is_until_satisfied() method that is
219
called by exec_relay_log_event(). is_until_satisfied() caches the result
220
of the comparison of log names because log names don't change very often;
221
this cache is invalidated by parts of code which change log names with
222
notify_*_log_name_updated() methods. (They need to be called only if SQL
226
enum {UNTIL_NONE= 0, UNTIL_MASTER_POS, UNTIL_RELAY_POS} until_condition;
227
char until_log_name[FN_REFLEN];
228
uint64_t until_log_pos;
229
/* extension extracted from log_name and converted to int32_t */
230
uint32_t until_log_name_extension;
232
Cached result of comparison of until_log_name and current log name
233
-2 means unitialised, -1,0,1 are comarison results
237
UNTIL_LOG_NAMES_CMP_UNKNOWN= -2, UNTIL_LOG_NAMES_CMP_LESS= -1,
238
UNTIL_LOG_NAMES_CMP_EQUAL= 0, UNTIL_LOG_NAMES_CMP_GREATER= 1
239
} until_log_names_cmp_result;
242
trans_retries varies between 0 to slave_transaction_retries and counts how
243
many times the slave has retried the present transaction; gets reset to 0
244
when the transaction finally succeeds. retried_trans is a cumulative
245
counter: how many times the slave has retried a transaction (any) since
248
uint32_t trans_retries, retried_trans;
251
If the end of the hot relay log is made of master's events ignored by the
252
slave I/O thread, these two keep track of the coords (in the master's
253
binlog) of the last of these events seen by the slave I/O thread. If not,
254
ign_master_log_name_end[0] == 0.
255
As they are like a Rotate event read/written from/to the relay log, they
256
are both protected by rli->relay_log.LOCK_log.
258
char ign_master_log_name_end[FN_REFLEN];
259
uint64_t ign_master_log_pos_end;
265
Invalidate cached until_log_name and group_relay_log_name comparison
266
result. Should be called after any update of group_realy_log_name if
267
there chances that sql_thread is running.
269
inline void notify_group_relay_log_name_update()
271
if (until_condition==UNTIL_RELAY_POS)
272
until_log_names_cmp_result= UNTIL_LOG_NAMES_CMP_UNKNOWN;
276
The same as previous but for group_master_log_name.
278
inline void notify_group_master_log_name_update()
280
if (until_condition==UNTIL_MASTER_POS)
281
until_log_names_cmp_result= UNTIL_LOG_NAMES_CMP_UNKNOWN;
284
inline void inc_event_relay_log_pos()
286
event_relay_log_pos= future_event_relay_log_pos;
289
void inc_group_relay_log_pos(uint64_t log_pos,
292
int32_t wait_for_pos(Session* session, String* log_name, int64_t log_pos,
294
void close_temporary_tables();
296
/* Check if UNTIL condition is satisfied. See slave.cc for more. */
297
bool is_until_satisfied(my_off_t master_beg_pos);
298
inline uint64_t until_pos()
300
return ((until_condition == UNTIL_MASTER_POS) ? group_master_log_pos :
301
group_relay_log_pos);
304
RPL_TableList *tables_to_lock; /* RBR: Tables to lock */
305
uint32_t tables_to_lock_count; /* RBR: Count of tables to lock */
306
table_mapping m_table_map; /* RBR: Mapping table-id to table */
308
inline table_def *get_tabledef(Table *tbl)
311
for (TableList *ptr= tables_to_lock; ptr && !td; ptr= ptr->next_global)
312
if (ptr->table == tbl)
313
td= &((RPL_TableList *)ptr)->m_tabledef;
317
void cleanup_context(Session *, bool);
318
void clear_tables_to_lock();
321
Used by row-based replication to detect that it should not stop at
322
this event, but give it a chance to send more events. The time
323
where the last event inside a group started is stored here. If the
324
variable is zero, we are not in a group (but may be in a
327
time_t last_event_start_time;
330
Helper function to do after statement completion.
332
This function is called from an event to complete the group by
333
either stepping the group position, if the "statement" is not
334
inside a transaction; or increase the event position, if the
335
"statement" is inside a transaction.
338
Master log position of the event. The position is recorded in the
339
relay log info and used to produce information for <code>SHOW
342
@param event_creation_time
343
Timestamp for the creation of the event on the master side. The
344
time stamp is recorded in the relay log info and used to compute
345
the <code>Seconds_behind_master</code> field.
347
void stmt_done(my_off_t event_log_pos,
348
time_t event_creation_time);
352
Set the value of a replication state flag.
354
@param flag Flag to set
356
void set_flag(enum_state_flag flag)
358
m_flags |= (1UL << flag);
362
Get the value of a replication state flag.
364
@param flag Flag to get value of
366
@return @c true if the flag was set, @c false otherwise.
368
bool get_flag(enum_state_flag flag)
370
return m_flags & (1UL << flag);
374
Clear the value of a replication state flag.
376
@param flag Flag to clear
378
void clear_flag(enum_state_flag flag)
380
m_flags &= ~(1UL << flag);
384
Is the replication inside a group?
386
Replication is inside a group if either:
387
- The OPTION_BEGIN flag is set, meaning we're inside a transaction
388
- The RLI_IN_STMT flag is set, meaning we're inside a statement
390
@retval true Replication thread is currently inside a group
391
@retval false Replication thread is currently not inside a group
393
bool is_in_group() const;
400
// Defined in rpl_rli.cc
401
int32_t init_relay_log_info(Relay_log_info* rli, const char* info_fname);
404
#endif /* RPL_RLI_H */
added
removed
drizzled/replication/rli.h
