#At file:///home/acorreia/workspace.sun/repository.mysql/bzrwork/wl-2775/mysql-5.1-rep%2B3/ based on revid:alfranio.correia@stripped
3120 Alfranio Correia 2009-11-05
WL#5125 (Relay log)
modified:
sql/ha_ndbcluster.cc
sql/log.cc
sql/log_event.cc
sql/repl_failsafe.cc
sql/rpl_rli.cc
sql/rpl_rli.h
sql/slave.cc
sql/slave.h
sql/sql_repl.cc
=== modified file 'sql/ha_ndbcluster.cc'
--- a/sql/ha_ndbcluster.cc 2009-11-05 02:30:41 +0000
+++ b/sql/ha_ndbcluster.cc 2009-11-05 19:55:02 +0000
@@ -4416,17 +4416,17 @@ static int ndbcluster_update_apply_statu
// log_name
char tmp_buf[FN_REFLEN];
ndb_pack_varchar(ndbtab->getColumn(2u), tmp_buf,
- active_mi->rli->group_master_log_name,
- strlen(active_mi->rli->group_master_log_name));
+ active_mi->rli->get_group_master_log_name(),
+ strlen(active_mi->rli->get_group_master_log_name()));
r|= op->setValue(2u, tmp_buf);
DBUG_ASSERT(r == 0);
// start_pos
- r|= op->setValue(3u, (Uint64)active_mi->rli->group_master_log_pos);
+ r|= op->setValue(3u, (Uint64)active_mi->rli->get_group_master_log_pos());
DBUG_ASSERT(r == 0);
// end_pos
- r|= op->setValue(4u, (Uint64)active_mi->rli->group_master_log_pos +
- ((Uint64)active_mi->rli->future_event_relay_log_pos -
- (Uint64)active_mi->rli->group_relay_log_pos));
+ r|= op->setValue(4u, (Uint64)active_mi->rli->get_group_master_log_pos() +
+ ((Uint64)active_mi->rli->get_future_event_relay_log_pos() -
+ (Uint64)active_mi->rli->get_group_relay_log_pos()));
DBUG_ASSERT(r == 0);
return 0;
}
=== modified file 'sql/log.cc'
--- a/sql/log.cc 2009-11-05 02:30:41 +0000
+++ b/sql/log.cc 2009-11-05 19:55:02 +0000
@@ -3125,23 +3125,23 @@ int MYSQL_BIN_LOG::purge_first_log(Relay
DBUG_ASSERT(is_open());
DBUG_ASSERT(rli->slave_running == 1);
- DBUG_ASSERT(!strcmp(rli->linfo.log_file_name,rli->event_relay_log_name));
+ DBUG_ASSERT(!strcmp(rli->linfo.log_file_name,rli->get_event_relay_log_name()));
pthread_mutex_lock(&LOCK_index);
- to_purge_if_included= my_strdup(rli->group_relay_log_name, MYF(0));
+ to_purge_if_included= my_strdup(rli->get_group_relay_log_name(), MYF(0));
/*
Read the next log file name from the index file and pass it back to
the caller.
*/
- if((error=find_log_pos(&rli->linfo, rli->event_relay_log_name, 0)) ||
+ if((error=find_log_pos(&rli->linfo, rli->get_event_relay_log_name(), 0)) ||
(error=find_next_log(&rli->linfo, 0)))
{
char buff[22];
sql_print_error("next log error: %d offset: %s log: %s included: %d",
error,
llstr(rli->linfo.index_file_offset,buff),
- rli->event_relay_log_name,
+ rli->get_event_relay_log_name(),
included);
goto err;
}
@@ -3149,9 +3149,8 @@ int MYSQL_BIN_LOG::purge_first_log(Relay
/*
Reset rli's coordinates to the current log.
*/
- rli->event_relay_log_pos= BIN_LOG_HEADER_SIZE;
- strmake(rli->event_relay_log_name,rli->linfo.log_file_name,
- sizeof(rli->event_relay_log_name)-1);
+ rli->set_event_relay_log_pos(BIN_LOG_HEADER_SIZE);
+ rli->set_event_relay_log_name(rli->linfo.log_file_name);
/*
If we removed the rli->group_relay_log_name file,
@@ -3160,12 +3159,10 @@ int MYSQL_BIN_LOG::purge_first_log(Relay
*/
if (included)
{
- rli->group_relay_log_pos = BIN_LOG_HEADER_SIZE;
- strmake(rli->group_relay_log_name,rli->linfo.log_file_name,
- sizeof(rli->group_relay_log_name)-1);
+ rli->set_group_relay_log_pos(BIN_LOG_HEADER_SIZE);
+ rli->set_group_relay_log_name(rli->linfo.log_file_name);
rli->notify_group_relay_log_name_update();
}
-
/* Store where we are in the new file for the execution thread */
rli->flush_info();
@@ -3189,13 +3186,13 @@ int MYSQL_BIN_LOG::purge_first_log(Relay
* Need to update the log pos because purge logs has been called
* after fetching initially the log pos at the begining of the method.
*/
- if((error=find_log_pos(&rli->linfo, rli->event_relay_log_name, 0)))
+ if((error=find_log_pos(&rli->linfo, rli->get_event_relay_log_name(), 0)))
{
char buff[22];
sql_print_error("next log error: %d offset: %s log: %s included: %d",
error,
llstr(rli->linfo.index_file_offset,buff),
- rli->group_relay_log_name,
+ rli->get_group_relay_log_name(),
included);
goto err;
}
=== modified file 'sql/log_event.cc'
--- a/sql/log_event.cc 2009-11-05 02:30:41 +0000
+++ b/sql/log_event.cc 2009-11-05 19:55:02 +0000
@@ -3088,7 +3088,7 @@ int Query_log_event::do_apply_event(Rela
END of the current log event (COMMIT). We save it in rli so that InnoDB can
access it.
*/
- const_cast<Relay_log_info*>(rli)->future_group_master_log_pos= log_pos;
+ const_cast<Relay_log_info*>(rli)->set_future_group_master_log_pos(log_pos);
DBUG_PRINT("info", ("log_pos: %lu", (ulong) log_pos));
clear_all_errors(thd, const_cast<Relay_log_info*>(rli));
@@ -3106,8 +3106,8 @@ int Query_log_event::do_apply_event(Rela
const_cast<Relay_log_info*>(rli)->report(ERROR_LEVEL, error,
"Error in cleaning up after an event preceeding the commit; "
"the group log file/position: %s %s",
- const_cast<Relay_log_info*>(rli)->group_master_log_name,
- llstr(const_cast<Relay_log_info*>(rli)->group_master_log_pos,
+ const_cast<Relay_log_info*>(rli)->get_group_master_log_name(),
+ llstr(const_cast<Relay_log_info*>(rli)->get_group_master_log_pos(),
llbuff));
}
/*
@@ -4623,7 +4623,7 @@ int Load_log_event::do_apply_event(NET*
Saved for InnoDB, see comment in
Query_log_event::do_apply_event()
*/
- const_cast<Relay_log_info*>(rli)->future_group_master_log_pos= log_pos;
+ const_cast<Relay_log_info*>(rli)->set_future_group_master_log_pos(log_pos);
DBUG_PRINT("info", ("log_pos: %lu", (ulong) log_pos));
}
@@ -4786,7 +4786,7 @@ int Load_log_event::do_apply_event(NET*
"log position %s in log '%s' produced %ld "
"warning(s). Default database: '%s'",
(char*) table_name,
- llstr(log_pos,llbuff), RPL_LOG_NAME,
+ llstr(log_pos,llbuff), RPL_LOG_NAME,
(ulong) thd->cuted_fields,
print_slave_db_safe(thd->db));
}
@@ -5020,15 +5020,17 @@ int Rotate_log_event::do_update_pos(Rela
pthread_mutex_lock(&rli->data_lock);
DBUG_PRINT("info", ("old group_master_log_name: '%s' "
"old group_master_log_pos: %lu",
- rli->group_master_log_name,
- (ulong) rli->group_master_log_pos));
- memcpy(rli->group_master_log_name, new_log_ident, ident_len+1);
+ rli->get_group_master_log_name(),
+ (ulong) rli->get_group_master_log_pos()));
+ memcpy((void *)const_cast<Relay_log_info*>(rli)->get_group_master_log_name(),
+ new_log_ident, ident_len + 1);
rli->notify_group_master_log_name_update();
rli->inc_group_relay_log_pos(pos, TRUE /* skip_lock */);
+
DBUG_PRINT("info", ("new group_master_log_name: '%s' "
"new group_master_log_pos: %lu",
- rli->group_master_log_name,
- (ulong) rli->group_master_log_pos));
+ rli->get_group_master_log_name(),
+ (ulong) rli->get_group_master_log_pos()));
pthread_mutex_unlock(&rli->data_lock);
rli->flush_info();
@@ -5853,7 +5855,7 @@ Slave_log_event::Slave_log_event(THD* th
pthread_mutex_lock(&mi->data_lock);
pthread_mutex_lock(&rli->data_lock);
master_host_len = strlen(mi->host);
- master_log_len = strlen(rli->group_master_log_name);
+ master_log_len = strlen(rli->get_group_master_log_name());
// on OOM, just do not initialize the structure and print the error
if ((mem_pool = (char*)my_malloc(get_data_size() + 1,
MYF(MY_WME))))
@@ -5861,9 +5863,9 @@ Slave_log_event::Slave_log_event(THD* th
master_host = mem_pool + SL_MASTER_HOST_OFFSET ;
memcpy(master_host, mi->host, master_host_len + 1);
master_log = master_host + master_host_len + 1;
- memcpy(master_log, rli->group_master_log_name, master_log_len + 1);
+ memcpy(master_log, rli->get_group_master_log_name(), master_log_len + 1);
master_port = mi->port;
- master_pos = rli->group_master_log_pos;
+ master_pos = rli->get_group_master_log_pos();
DBUG_PRINT("info", ("master_log: %s pos: %lu", master_log,
(ulong) master_pos));
}
@@ -6669,8 +6671,7 @@ int Execute_load_log_event::do_apply_eve
lev->do_apply_event is the place where the table is loaded (it
calls mysql_load()).
*/
-
- const_cast<Relay_log_info*>(rli)->future_group_master_log_pos= log_pos;
+ const_cast<Relay_log_info*>(rli)->set_future_group_master_log_pos(log_pos);
if (lev->do_apply_event(0,rli,1))
{
/*
=== modified file 'sql/repl_failsafe.cc'
--- a/sql/repl_failsafe.cc 2009-11-05 02:30:41 +0000
+++ b/sql/repl_failsafe.cc 2009-11-05 19:55:02 +0000
@@ -986,9 +986,8 @@ bool load_master_data(THD* thd)
return TRUE;
}
pthread_mutex_lock(&active_mi->rli->data_lock);
- active_mi->rli->group_master_log_pos = active_mi->master_log_pos;
- strmake(active_mi->rli->group_master_log_name,active_mi->master_log_name,
- sizeof(active_mi->rli->group_master_log_name)-1);
+ active_mi->rli->set_group_master_log_pos(active_mi->master_log_pos);
+ active_mi->rli->set_group_master_log_name(active_mi->master_log_name);
/*
Cancel the previous START SLAVE UNTIL, as the fact to download
a new copy logically makes UNTIL irrelevant.
=== modified file 'sql/rpl_rli.cc'
--- a/sql/rpl_rli.cc 2009-11-05 02:30:41 +0000
+++ b/sql/rpl_rli.cc 2009-11-05 19:55:02 +0000
@@ -187,7 +187,8 @@ int init_relay_log_pos(Relay_log_info* r
rli->cur_log_fd = -1;
}
- rli->group_relay_log_pos = rli->event_relay_log_pos = pos;
+ rli->set_group_relay_log_pos(pos);
+ rli->set_event_relay_log_pos(pos);
/*
Test to see if the previous run was with the skip of purging
@@ -204,10 +205,9 @@ int init_relay_log_pos(Relay_log_info* r
*errmsg="Could not find target log during relay log initialization";
goto err;
}
- strmake(rli->group_relay_log_name,rli->linfo.log_file_name,
- sizeof(rli->group_relay_log_name)-1);
- strmake(rli->event_relay_log_name,rli->linfo.log_file_name,
- sizeof(rli->event_relay_log_name)-1);
+ rli->set_group_relay_log_name(rli->linfo.log_file_name);
+ rli->set_event_relay_log_name(rli->linfo.log_file_name);
+
if (rli->relay_log.is_active(rli->linfo.log_file_name))
{
/*
@@ -304,7 +304,7 @@ int init_relay_log_pos(Relay_log_info* r
char llbuf1[22], llbuf2[22];
DBUG_PRINT("info", ("my_b_tell(rli->cur_log)=%s rli->event_relay_log_pos=%s",
llstr(my_b_tell(rli->cur_log),llbuf1),
- llstr(rli->event_relay_log_pos,llbuf2)));
+ llstr(rli->get_event_relay_log_pos(),llbuf2)));
}
#endif
@@ -529,7 +529,6 @@ improper_arguments: %d timed_out: %d",
DBUG_RETURN( error ? error : event_count );
}
-
void Relay_log_info::inc_group_relay_log_pos(ulonglong log_pos,
bool skip_lock)
{
@@ -644,9 +643,8 @@ int purge_relay_logs(Relay_log_info* rli
In other words, we reinit rli->master_log_* for SHOW SLAVE STATUS
to display fine in any case.
*/
-
- rli->group_master_log_name[0]= 0;
- rli->group_master_log_pos= 0;
+ rli->set_group_master_log_name("\0");
+ rli->set_group_master_log_pos(0);
if (!rli->inited)
{
@@ -680,11 +678,10 @@ int purge_relay_logs(Relay_log_info* rli
goto err;
}
/* Save name of used relay log file */
- strmake(rli->group_relay_log_name, rli->relay_log.get_log_fname(),
- sizeof(rli->group_relay_log_name)-1);
- strmake(rli->event_relay_log_name, rli->relay_log.get_log_fname(),
- sizeof(rli->event_relay_log_name)-1);
- rli->group_relay_log_pos= rli->event_relay_log_pos= BIN_LOG_HEADER_SIZE;
+ rli->set_group_relay_log_name(rli->relay_log.get_log_fname());
+ rli->set_event_relay_log_name(rli->relay_log.get_log_fname());
+ rli->set_group_relay_log_pos(BIN_LOG_HEADER_SIZE);
+ rli->set_event_relay_log_pos(BIN_LOG_HEADER_SIZE);
if (rli->count_relay_log_space())
{
*errmsg= "Error counting relay log space";
@@ -692,8 +689,8 @@ int purge_relay_logs(Relay_log_info* rli
goto err;
}
if (!just_reset)
- error= init_relay_log_pos(rli, rli->group_relay_log_name,
- rli->group_relay_log_pos,
+ error= init_relay_log_pos(rli, rli->get_group_relay_log_name(),
+ rli->get_group_relay_log_pos(),
0 /* do not need data lock */, errmsg, 0);
err:
@@ -876,6 +873,7 @@ void Relay_log_info::stmt_done(my_off_t
else
{
inc_group_relay_log_pos(event_master_log_pos);
+ // Alfranio --> Maybe we don't nee this call.
do_flush_info();
/*
Note that Rotate_log_event::do_apply_event() does not call this
=== modified file 'sql/rpl_rli.h'
--- a/sql/rpl_rli.h 2009-11-05 12:29:18 +0000
+++ b/sql/rpl_rli.h 2009-11-05 19:55:02 +0000
@@ -134,16 +134,13 @@ public:
happen when, for example, the relay log gets rotated because of
max_binlog_size.
*/
+protected:
char group_relay_log_name[FN_REFLEN];
ulonglong group_relay_log_pos;
char event_relay_log_name[FN_REFLEN];
ulonglong event_relay_log_pos;
ulonglong future_event_relay_log_pos;
-#ifdef HAVE_purify
- bool is_fake; /* Mark that this is a fake relay log info structure */
-#endif
-
/*
Original log name and position of the group we're currently executing
(whose coordinates are group_relay_log_name/pos in the relay log)
@@ -155,15 +152,6 @@ public:
volatile my_off_t group_master_log_pos;
/*
- Handling of the relay_log_space_limit optional constraint.
- ignore_log_space_limit is used to resolve a deadlock between I/O and SQL
- threads, the SQL thread sets it to unblock the I/O thread and make it
- temporarily forget about the constraint.
- */
- ulonglong log_space_limit,log_space_total;
- bool ignore_log_space_limit;
-
- /*
When it commits, InnoDB internally stores the master log position it has
processed so far; the position to store is the one of the end of the
committing event (the COMMIT query event, or the event if in autocommit
@@ -175,6 +163,20 @@ public:
ulonglong future_group_master_log_pos;
#endif
+public:
+#ifdef HAVE_purify
+ bool is_fake; /* Mark that this is a fake relay log info structure */
+#endif
+
+ /*
+ Handling of the relay_log_space_limit optional constraint.
+ ignore_log_space_limit is used to resolve a deadlock between I/O and SQL
+ threads, the SQL thread sets it to unblock the I/O thread and make it
+ temporarily forget about the constraint.
+ */
+ ulonglong log_space_limit,log_space_total;
+ bool ignore_log_space_limit;
+
time_t last_master_timestamp;
void clear_until_condition();
@@ -397,6 +399,67 @@ public:
int flush_current_log();
void inject_master_info(Master_info *info);
+ inline ulonglong get_future_event_relay_log_pos() { return future_event_relay_log_pos; }
+ inline void set_future_event_relay_log_pos(ulonglong log_pos)
+ {
+ future_event_relay_log_pos= log_pos;
+ }
+
+ inline const char* get_group_master_log_name() { return group_master_log_name; }
+ inline ulonglong get_group_master_log_pos() { return group_master_log_pos; }
+ inline void set_group_master_log_name(const char *log_file_name)
+ {
+ strmake(group_master_log_name,log_file_name, sizeof(group_master_log_name)-1);
+ }
+ inline void set_group_master_log_name(const char *log_file_name, size_t len)
+ {
+ strmake(group_master_log_name, log_file_name, len);
+ }
+ inline void set_group_master_log_pos(ulonglong log_pos)
+ {
+ group_master_log_pos= log_pos;
+ }
+
+ inline const char* get_group_relay_log_name() { return group_relay_log_name; }
+ inline ulonglong get_group_relay_log_pos() { return group_relay_log_pos; }
+ inline void set_group_relay_log_name(const char *log_file_name)
+ {
+ strmake(group_relay_log_name,log_file_name, sizeof(group_relay_log_name)-1);
+ }
+ inline void set_group_relay_log_name(const char *log_file_name, size_t len)
+ {
+ strmake(group_relay_log_name, log_file_name, len);
+ }
+ inline void set_group_relay_log_pos(ulonglong log_pos)
+ {
+ group_relay_log_pos= log_pos;
+ }
+
+ inline const char* get_event_relay_log_name() { return event_relay_log_name; }
+ inline ulonglong get_event_relay_log_pos() { return event_relay_log_pos; }
+ inline void set_event_relay_log_name(const char *log_file_name)
+ {
+ strmake(event_relay_log_name,log_file_name, sizeof(event_relay_log_name)-1);
+ }
+ inline void set_event_relay_log_name(const char *log_file_name, size_t len)
+ {
+ strmake(event_relay_log_name,log_file_name, len);
+ }
+ inline void set_event_relay_log_pos(ulonglong log_pos)
+ {
+ event_relay_log_pos= log_pos;
+ }
+
+#if MYSQL_VERSION_ID < 40100
+ inline ulonglong get_future_master_log_pos() { return future_master_log_pos; }
+#else
+ inline ulonglong get_future_group_master_log_pos() { return future_group_master_log_pos; }
+ inline void set_future_group_master_log_pos(ulonglong log_pos)
+ {
+ future_group_master_log_pos= log_pos;
+ }
+#endif
+
private:
virtual int do_check()= 0;
virtual int do_init_info()= 0;
=== modified file 'sql/slave.cc'
--- a/sql/slave.cc 2009-11-05 11:38:10 +0000
+++ b/sql/slave.cc 2009-11-05 19:55:02 +0000
@@ -345,24 +345,23 @@ err:
int init_recovery(Master_info* mi, const char** errmsg)
{
DBUG_ENTER("init_recovery");
-
+
Relay_log_info *rli= mi->rli;
- if (rli->group_master_log_name[0])
+ const char *group_master_log_name= rli->get_group_master_log_name();
+ if (group_master_log_name[0])
{
mi->master_log_pos= max(BIN_LOG_HEADER_SIZE,
- rli->group_master_log_pos);
- strmake(mi->master_log_name, rli->group_master_log_name,
+ rli->get_group_master_log_pos());
+ strmake(mi->master_log_name, rli->get_group_master_log_name(),
sizeof(mi->master_log_name)-1);
sql_print_warning("Recovery from master pos %ld and file %s.",
(ulong) mi->master_log_pos, mi->master_log_name);
- strmake(rli->group_relay_log_name, rli->relay_log.get_log_fname(),
- sizeof(rli->group_relay_log_name)-1);
- strmake(rli->event_relay_log_name, rli->relay_log.get_log_fname(),
- sizeof(mi->rli->event_relay_log_name)-1);
-
- rli->group_relay_log_pos= rli->event_relay_log_pos= BIN_LOG_HEADER_SIZE;
+ rli->set_group_relay_log_name(rli->relay_log.get_log_fname());
+ rli->set_event_relay_log_name(rli->relay_log.get_log_fname());
+ rli->set_group_relay_log_pos(BIN_LOG_HEADER_SIZE);
+ rli->set_event_relay_log_pos(BIN_LOG_HEADER_SIZE);
}
DBUG_RETURN(0);
@@ -2030,11 +2029,11 @@ bool show_master_info(THD* thd, Master_i
protocol->store((uint32) mi->connect_retry);
protocol->store(mi->master_log_name, &my_charset_bin);
protocol->store((ulonglong) mi->master_log_pos);
- protocol->store(mi->rli->group_relay_log_name +
- dirname_length(mi->rli->group_relay_log_name),
+ protocol->store(mi->rli->get_group_relay_log_name() +
+ dirname_length(mi->rli->get_group_relay_log_name()),
&my_charset_bin);
- protocol->store((ulonglong) mi->rli->group_relay_log_pos);
- protocol->store(mi->rli->group_master_log_name, &my_charset_bin);
+ protocol->store((ulonglong) mi->rli->get_group_relay_log_pos());
+ protocol->store(mi->rli->get_group_master_log_name(), &my_charset_bin);
protocol->store(mi->slave_running == MYSQL_SLAVE_RUN_CONNECT ?
"Yes" : (mi->slave_running == MYSQL_SLAVE_RUN_NOT_CONNECT ?
"Connecting" : "No"), &my_charset_bin);
@@ -2056,7 +2055,7 @@ bool show_master_info(THD* thd, Master_i
protocol->store(mi->rli->last_error().number);
protocol->store(mi->rli->last_error().message, &my_charset_bin);
protocol->store((uint32) mi->rli->slave_skip_counter);
- protocol->store((ulonglong) mi->rli->group_master_log_pos);
+ protocol->store((ulonglong) mi->rli->get_group_master_log_pos());
protocol->store((ulonglong) mi->rli->log_space_total);
protocol->store(
@@ -2602,11 +2601,11 @@ int apply_event_and_update_pos(Log_event
#endif
DBUG_PRINT("info", ("update_pos error = %d", error));
DBUG_PRINT("info", ("group %s %s",
- llstr(rli->group_relay_log_pos, buf),
- rli->group_relay_log_name));
+ llstr(rli->get_group_relay_log_pos(), buf),
+ rli->get_group_relay_log_name()));
DBUG_PRINT("info", ("event %s %s",
- llstr(rli->event_relay_log_pos, buf),
- rli->event_relay_log_name));
+ llstr(rli->get_event_relay_log_pos(), buf),
+ rli->get_event_relay_log_name()));
}
/*
The update should not fail, so print an error message and
@@ -2623,8 +2622,8 @@ int apply_event_and_update_pos(Log_event
" of the relay log information: the slave may"
" be in an inconsistent state."
" Stopped in %s position %s",
- rli->group_relay_log_name,
- llstr(rli->group_relay_log_pos, buf));
+ rli->get_group_relay_log_name(),
+ llstr(rli->get_group_relay_log_pos(), buf));
DBUG_RETURN(2);
}
}
@@ -2692,7 +2691,7 @@ static int exec_relay_log_event(THD* thd
*/
if (rli->until_condition != Relay_log_info::UNTIL_NONE &&
rli->is_until_satisfied((rli->is_in_group() || !ev->log_pos) ?
- rli->group_master_log_pos :
+ rli->get_group_master_log_pos() :
ev->log_pos - ev->data_written))
{
char buf[22];
@@ -2777,8 +2776,8 @@ static int exec_relay_log_event(THD* thd
if (init_info(rli->mi, FALSE, SLAVE_SQL))
sql_print_error("Failed to initialize the master info structure");
else if (init_relay_log_pos(rli,
- rli->group_relay_log_name,
- rli->group_relay_log_pos,
+ rli->get_group_relay_log_name(),
+ rli->get_group_relay_log_pos(),
1, &errmsg, 1))
sql_print_error("Error initializing relay log position: %s",
errmsg);
@@ -2805,7 +2804,7 @@ static int exec_relay_log_event(THD* thd
}
else if ((exec_res && !temp_err) ||
(opt_using_transactions &&
- rli->group_relay_log_pos == rli->event_relay_log_pos))
+ rli->get_group_relay_log_pos() == rli->get_event_relay_log_pos()))
{
/*
Only reset the retry counter if the entire group succeeded
@@ -3407,8 +3406,8 @@ pthread_handler_t handle_slave_sql(void
DBUG_PRINT("info", ("rli->trans_retries: %lu", rli->trans_retries));
if (init_relay_log_pos(rli,
- rli->group_relay_log_name,
- rli->group_relay_log_pos,
+ rli->get_group_relay_log_name(),
+ rli->get_group_relay_log_pos(),
1 /*need data lock*/, &errmsg,
1 /*look for a description_event*/))
{
@@ -3422,8 +3421,8 @@ pthread_handler_t handle_slave_sql(void
char llbuf1[22], llbuf2[22];
DBUG_PRINT("info", ("my_b_tell(rli->cur_log)=%s rli->event_relay_log_pos=%s",
llstr(my_b_tell(rli->cur_log),llbuf1),
- llstr(rli->event_relay_log_pos,llbuf2)));
- DBUG_ASSERT(rli->event_relay_log_pos >= BIN_LOG_HEADER_SIZE);
+ llstr(rli->get_event_relay_log_pos(),llbuf2)));
+ DBUG_ASSERT(rli->get_event_relay_log_pos() >= BIN_LOG_HEADER_SIZE);
/*
Wonder if this is correct. I (Guilhem) wonder if my_b_tell() returns the
correct position when it's called just after my_b_seek() (the questionable
@@ -3437,20 +3436,20 @@ pthread_handler_t handle_slave_sql(void
DBUG_ASSERT().
*/
#ifdef SHOULD_BE_CHECKED
- DBUG_ASSERT(my_b_tell(rli->cur_log) == rli->event_relay_log_pos);
+ DBUG_ASSERT(my_b_tell(rli->cur_log) == rli->get_event_relay_log_pos());
#endif
}
#endif
DBUG_ASSERT(rli->info_thd == thd);
DBUG_PRINT("master_info",("log_file_name: %s position: %s",
- rli->group_master_log_name,
- llstr(rli->group_master_log_pos,llbuff)));
+ rli->get_group_master_log_name(),
+ llstr(rli->get_group_master_log_pos(),llbuff)));
if (global_system_variables.log_warnings)
sql_print_information("Slave SQL thread initialized, starting replication in \
log '%s' at position %s, relay log '%s' position: %s", RPL_LOG_NAME,
- llstr(rli->group_master_log_pos,llbuff),rli->group_relay_log_name,
- llstr(rli->group_relay_log_pos,llbuff1));
+ llstr(rli->get_group_master_log_pos(),llbuff),rli->get_group_relay_log_name(),
+ llstr(rli->get_group_relay_log_pos(),llbuff1));
if (check_temp_dir(rli->slave_patternload_file))
{
@@ -3478,7 +3477,7 @@ log '%s' at position %s, relay log '%s'
*/
pthread_mutex_lock(&rli->data_lock);
if (rli->until_condition != Relay_log_info::UNTIL_NONE &&
- rli->is_until_satisfied(rli->group_master_log_pos))
+ rli->is_until_satisfied(rli->get_group_master_log_pos()))
{
char buf[22];
sql_print_information("Slave SQL thread stopped because it reached its"
@@ -3554,13 +3553,13 @@ log '%s' at position %s, relay log '%s'
sql_print_error("Error loading user-defined library, slave SQL "
"thread aborted. Install the missing library, and restart the "
"slave SQL thread with \"SLAVE START\". We stopped at log '%s' "
- "position %s", RPL_LOG_NAME, llstr(rli->group_master_log_pos,
+ "position %s", RPL_LOG_NAME, llstr(rli->get_group_master_log_pos(),
llbuff));
else
sql_print_error("\
Error running query, slave SQL thread aborted. Fix the problem, and restart \
the slave SQL thread with \"SLAVE START\". We stopped at log \
-'%s' position %s", RPL_LOG_NAME, llstr(rli->group_master_log_pos, llbuff));
+'%s' position %s", RPL_LOG_NAME, llstr(rli->get_group_master_log_pos(), llbuff));
}
goto err;
}
@@ -3569,7 +3568,7 @@ the slave SQL thread with \"SLAVE START\
/* Thread stopped. Print the current replication position to the log */
sql_print_information("Slave SQL thread exiting, replication stopped in log "
"'%s' at position %s",
- RPL_LOG_NAME, llstr(rli->group_master_log_pos,llbuff));
+ RPL_LOG_NAME, llstr(rli->get_group_master_log_pos(),llbuff));
err:
@@ -4502,7 +4501,7 @@ static IO_CACHE *reopen_relay_log(Relay_
DBUG_ASSERT(rli->cur_log_fd == -1);
IO_CACHE *cur_log = rli->cur_log=&rli->cache_buf;
- if ((rli->cur_log_fd=open_binlog(cur_log,rli->event_relay_log_name,
+ if ((rli->cur_log_fd=open_binlog(cur_log,rli->get_event_relay_log_name(),
errmsg)) <0)
DBUG_RETURN(0);
/*
@@ -4510,8 +4509,9 @@ static IO_CACHE *reopen_relay_log(Relay_
relay_log_pos Current log pos
pending Number of bytes already processed from the event
*/
- rli->event_relay_log_pos= max(rli->event_relay_log_pos, BIN_LOG_HEADER_SIZE);
- my_b_seek(cur_log,rli->event_relay_log_pos);
+ rli->set_event_relay_log_pos(max(rli->get_event_relay_log_pos(),
+ BIN_LOG_HEADER_SIZE));
+ my_b_seek(cur_log,rli->get_event_relay_log_pos());
DBUG_RETURN(cur_log);
}
@@ -4597,9 +4597,9 @@ static Log_event* next_event(Relay_log_i
char llbuf1[22], llbuf2[22];
DBUG_PRINT("info", ("my_b_tell(cur_log)=%s rli->event_relay_log_pos=%s",
llstr(my_b_tell(cur_log),llbuf1),
- llstr(rli->event_relay_log_pos,llbuf2)));
+ llstr(rli->get_event_relay_log_pos(),llbuf2)));
DBUG_ASSERT(my_b_tell(cur_log) >= BIN_LOG_HEADER_SIZE);
- DBUG_ASSERT(my_b_tell(cur_log) == rli->event_relay_log_pos);
+ DBUG_ASSERT(my_b_tell(cur_log) == rli->get_event_relay_log_pos());
}
#endif
/*
@@ -4623,7 +4623,7 @@ static Log_event* next_event(Relay_log_i
read it while we have a lock, to avoid a mutex lock in
inc_event_relay_log_pos()
*/
- rli->future_event_relay_log_pos= my_b_tell(cur_log);
+ rli->set_future_event_relay_log_pos(my_b_tell(cur_log));
if (hot_log)
pthread_mutex_unlock(log_lock);
DBUG_RETURN(ev);
@@ -4766,8 +4766,8 @@ static Log_event* next_event(Relay_log_i
*/
if (rli->relay_log.purge_first_log
(rli,
- rli->group_relay_log_pos == rli->event_relay_log_pos
- && !strcmp(rli->group_relay_log_name,rli->event_relay_log_name)))
+ rli->get_group_relay_log_pos() == rli->get_event_relay_log_pos()
+ && !strcmp(rli->get_group_relay_log_name(),rli->get_event_relay_log_name())))
{
errmsg = "Error purging processed logs";
goto err;
@@ -4787,9 +4787,8 @@ static Log_event* next_event(Relay_log_i
errmsg = "error switching to the next log";
goto err;
}
- rli->event_relay_log_pos = BIN_LOG_HEADER_SIZE;
- strmake(rli->event_relay_log_name,rli->linfo.log_file_name,
- sizeof(rli->event_relay_log_name)-1);
+ rli->set_event_relay_log_pos(BIN_LOG_HEADER_SIZE);
+ rli->set_event_relay_log_name(rli->linfo.log_file_name);
rli->flush_info();
}
@@ -4860,7 +4859,7 @@ static Log_event* next_event(Relay_log_i
event(errno: %d cur_log->error: %d)",
my_errno,cur_log->error);
// set read position to the beginning of the event
- my_b_seek(cur_log,rli->event_relay_log_pos);
+ my_b_seek(cur_log,rli->get_event_relay_log_pos());
/* otherwise, we have had a partial read */
errmsg = "Aborting slave SQL thread because of partial event read";
break; // To end of function
=== modified file 'sql/slave.h'
--- a/sql/slave.h 2009-11-05 02:30:41 +0000
+++ b/sql/slave.h 2009-11-05 19:55:02 +0000
@@ -131,9 +131,8 @@ extern ulonglong relay_log_space_limit;
#define MYSQL_SLAVE_NOT_RUN 0
#define MYSQL_SLAVE_RUN_NOT_CONNECT 1
#define MYSQL_SLAVE_RUN_CONNECT 2
-
-#define RPL_LOG_NAME (rli->group_master_log_name[0] ? rli->group_master_log_name :\
- "FIRST")
+#define RPL_LOG_NAME (const_cast<Relay_log_info*>(rli)->get_group_master_log_name() != NULL ? \
+ const_cast<Relay_log_info*>(rli)->get_group_master_log_name() : "FIRST")
#define IO_RPL_LOG_NAME (mi->master_log_name[0] ? mi->master_log_name :\
"FIRST")
=== modified file 'sql/sql_repl.cc'
--- a/sql/sql_repl.cc 2009-11-05 02:30:41 +0000
+++ b/sql/sql_repl.cc 2009-11-05 19:55:02 +0000
@@ -198,7 +198,7 @@ static int send_file(THD *thd)
TODO
- Inform the slave threads that they should sync the position
in the binary log file with flush_info.
- Now they sync is done for next read.
+ Now the sync is done for next read.
*/
void adjust_linfo_offsets(my_off_t purge_offset)
@@ -1335,6 +1335,8 @@ bool change_master(THD* thd, Master_info
const char* errmsg= 0;
bool need_relay_log_purge= 1;
bool ret= FALSE;
+ const char *group_master_log_name= NULL;
+
DBUG_ENTER("change_master");
lock_slave_threads(mi);
@@ -1469,17 +1471,17 @@ bool change_master(THD* thd, Master_info
{
need_relay_log_purge= 0;
char relay_log_name[FN_REFLEN];
+
mi->rli->relay_log.make_log_name(relay_log_name, lex_mi->relay_log_name);
- strmake(mi->rli->group_relay_log_name, relay_log_name,
- sizeof(mi->rli->group_relay_log_name)-1);
- strmake(mi->rli->event_relay_log_name, relay_log_name,
- sizeof(mi->rli->event_relay_log_name)-1);
+ mi->rli->set_group_relay_log_name(relay_log_name);
+ mi->rli->set_event_relay_log_name(relay_log_name);
}
if (lex_mi->relay_log_pos)
{
need_relay_log_purge= 0;
- mi->rli->group_relay_log_pos= mi->rli->event_relay_log_pos= lex_mi->relay_log_pos;
+ mi->rli->set_group_relay_log_pos(lex_mi->relay_log_pos);
+ mi->rli->set_event_relay_log_pos(lex_mi->relay_log_pos);
}
/*
@@ -1508,8 +1510,8 @@ bool change_master(THD* thd, Master_info
max().
*/
mi->master_log_pos = max(BIN_LOG_HEADER_SIZE,
- mi->rli->group_master_log_pos);
- strmake(mi->master_log_name, mi->rli->group_master_log_name,
+ mi->rli->get_group_master_log_pos());
+ strmake(mi->master_log_name, mi->rli->get_group_master_log_name(),
sizeof(mi->master_log_name)-1);
}
/*
@@ -1541,8 +1543,8 @@ bool change_master(THD* thd, Master_info
relay_log_purge= 0;
/* Relay log is already initialized */
if (init_relay_log_pos(mi->rli,
- mi->rli->group_relay_log_name,
- mi->rli->group_relay_log_pos,
+ mi->rli->get_group_relay_log_name(),
+ mi->rli->get_group_relay_log_pos(),
0 /*no data lock*/,
&msg, 0))
{
@@ -1561,13 +1563,13 @@ bool change_master(THD* thd, Master_info
''/0: we have lost all copies of the original good coordinates.
That's why we always save good coords in rli.
*/
- mi->rli->group_master_log_pos= mi->master_log_pos;
+ mi->rli->set_group_master_log_pos(mi->master_log_pos);
DBUG_PRINT("info", ("master_log_pos: %lu", (ulong) mi->master_log_pos));
- strmake(mi->rli->group_master_log_name,mi->master_log_name,
- sizeof(mi->rli->group_master_log_name)-1);
+ mi->rli->set_group_master_log_name(mi->master_log_name);
- if (!mi->rli->group_master_log_name[0]) // uninitialized case
- mi->rli->group_master_log_pos=0;
+ group_master_log_name= const_cast<Relay_log_info*>(mi->rli)->get_group_master_log_name();
+ if (!group_master_log_name[0]) // uninitialized case
+ mi->rli->set_group_master_log_pos(0);
pthread_mutex_lock(&mi->rli->data_lock);
mi->rli->abort_pos_wait++; /* for MASTER_POS_WAIT() to abort */
Attachment: [text/bzr-bundle]
| Thread |
|---|
| • bzr commit into mysql-5.1-rep+3 branch (alfranio.correia:3120) WL#5125 | Alfranio Correia | 5 Nov |
