hcq/MaxScale
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

MXS-1703 Change type of m_master to MariaDBServer

Browse Source
This commit is contained in:
Esa Korhonen
2018-04-12 14:31:39 +03:00
parent e3b11d866f
commit 9fe57bfb9b
4 changed files with 58 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
server/modules/monitor/mariadbmon/cluster_discovery.cc
View File

@ -87,7 +87,7 @@ MXS_MONITORED_SERVER* MariaDBMonitor::build_mysql51_replication_tree()
/* Set the Slave Role */
if (ismaster)
{
m_master = database;
m_master = get_server_info(database);
MXS_DEBUG("Master server found at [%s]:%d with %d slaves",
database->server->name,
@ -128,7 +128,7 @@ MXS_MONITORED_SERVER* MariaDBMonitor::build_mysql51_replication_tree()
}
if (SERVER_IS_SLAVE(database->server) &&
(database->server->master_id <= 0 ||
database->server->master_id != m_master->server->node_id))
database->server->master_id != m_master->server_base->server->node_id))
{
monitor_set_pending_status(database, SERVER_SLAVE);
@ -205,7 +205,7 @@ MXS_MONITORED_SERVER* MariaDBMonitor::get_replication_tree()
if (current->depth > -1 && current->depth < root_level)
{
root_level = current->depth;
m_master = ptr;
m_master = get_server_info(ptr);
}
backend = getServerByNodeId(node_id);
@ -236,12 +236,12 @@ MXS_MONITORED_SERVER* MariaDBMonitor::get_replication_tree()
current->node_id);
master_cand->server->depth = current->depth - 1;
if (m_master && master_cand->server->depth < m_master->server->depth)
if (m_master && master_cand->server->depth < m_master->server_base->server->depth)
{
/** A master with a lower depth was found, remove
the master status from the previous master. */
monitor_clear_pending_status(m_master, SERVER_MASTER);
m_master = master_cand;
monitor_clear_pending_status(m_master->server_base, SERVER_MASTER);
m_master = get_server_info(master_cand);
}
MariaDBServer* info = get_server_info(master_cand);
@ -275,13 +275,13 @@ MXS_MONITORED_SERVER* MariaDBMonitor::get_replication_tree()
if (m_master != NULL)
{
/* If the root master is in MAINT, return NULL */
if (SERVER_IN_MAINT(m_master->server))
if (SERVER_IN_MAINT(m_master->server_base->server))
{
return NULL;
}
else
{
return m_master;
return m_master->server_base;
}
}
else
@ -1017,7 +1017,7 @@ bool MariaDBMonitor::set_standalone_master(MXS_MONITORED_SERVER *db)
server_clear_set_status(db->server, SERVER_SLAVE, SERVER_MASTER | SERVER_STALE_STATUS);
monitor_set_pending_status(db, SERVER_MASTER | SERVER_STALE_STATUS);
monitor_clear_pending_status(db, SERVER_SLAVE);
m_master = db;
m_master = get_server_info(db);
rval = true;
}
else if (!m_allow_cluster_recovery)
@ -1110,7 +1110,7 @@ MariaDBServer* MariaDBMonitor::find_root_master()
monitor_set_pending_status(mon_server, SERVER_MASTER);
mon_server->server->depth = 0;
m_master = mon_server;
m_master = &m_servers[0];
found_root_master = mon_server;
}
}

36
server/modules/monitor/mariadbmon/cluster_manipulation.cc
View File

@ -131,15 +131,14 @@ bool MariaDBMonitor::manual_rejoin(SERVER* rejoin_server, json_t** output)
MXS_MONITORED_SERVER* mon_slave_cand = mon_get_monitored_server(m_monitor_base, rejoin_server);
if (mon_slave_cand)
{
const char* master_name = m_master->server->unique_name;
MariaDBServer* master = get_server_info(m_master);
const char* master_name = m_master->server_base->server->unique_name;
MariaDBServer* slave_cand = get_server_info(mon_slave_cand);
if (server_is_rejoin_suspect(slave_cand, master, output))
if (server_is_rejoin_suspect(slave_cand, m_master, output))
{
if (master->update_gtids())
if (m_master->update_gtids())
{
if (can_replicate_from(slave_cand, master))
if (can_replicate_from(slave_cand, m_master))
{
ServerRefArray joinable_server;
joinable_server.push_back(slave_cand);
@ -338,7 +337,7 @@ bool MariaDBMonitor::redirect_one_slave(MXS_MONITORED_SERVER* slave, const char*
*/
uint32_t MariaDBMonitor::do_rejoin(const ServerRefArray& joinable_servers)
{
SERVER* master_server = m_master->server;
SERVER* master_server = m_master->server_base->server;
const char* master_name = master_server->unique_name;
uint32_t servers_joined = 0;
if (!joinable_servers.empty())
@ -346,7 +345,7 @@ uint32_t MariaDBMonitor::do_rejoin(const ServerRefArray& joinable_servers)
string change_cmd = generate_change_master_cmd(master_server->name, master_server->port);
for (auto iter = joinable_servers.begin(); iter != joinable_servers.end(); iter++)
{
auto joinable = *iter;
MariaDBServer* joinable = *iter;
const char* name = joinable->server_base->server->unique_name;
bool op_success;
@ -378,7 +377,7 @@ uint32_t MariaDBMonitor::do_rejoin(const ServerRefArray& joinable_servers)
*/
bool MariaDBMonitor::cluster_can_be_joined()
{
return (m_master != NULL && SERVER_IS_MASTER(m_master->server) && m_master_gtid_domain >= 0);
return (m_master != NULL && SERVER_IS_MASTER(m_master->server_base->server) && m_master_gtid_domain >= 0);
}
/**
@ -393,14 +392,13 @@ bool MariaDBMonitor::cluster_can_be_joined()
bool MariaDBMonitor::get_joinable_servers(ServerRefArray* output)
{
ss_dassert(output);
MariaDBServer* master = get_server_info(m_master);
// Whether a join operation should be attempted or not depends on several criteria. Start with the ones
// easiest to test. Go though all slaves and construct a preliminary list.
ServerRefArray suspects;
for (size_t i = 0; i < m_servers.size(); i++)
{
if (server_is_rejoin_suspect(&m_servers[i], master, NULL))
if (server_is_rejoin_suspect(&m_servers[i], m_master, NULL))
{
suspects.push_back(&m_servers[i]);
}
@ -410,11 +408,11 @@ bool MariaDBMonitor::get_joinable_servers(ServerRefArray* output)
bool comm_ok = true;
if (!suspects.empty())
{
if (master->update_gtids())
if (m_master->update_gtids())
{
for (size_t i = 0; i < suspects.size(); i++)
{
if (can_replicate_from(suspects[i], master))
if (can_replicate_from(suspects[i], m_master))
{
output->push_back(suspects[i]);
}
@ -508,8 +506,8 @@ bool MariaDBMonitor::server_is_rejoin_suspect(MariaDBServer* rejoin_cand, MariaD
}
// or is disconnected but master host or port is wrong.
else if (!slave_status->slave_io_running && slave_status->slave_sql_running &&
(slave_status->master_host != m_master->server->name ||
slave_status->master_port != m_master->server->port))
(slave_status->master_host != m_master->server_base->server->name ||
slave_status->master_port != m_master->server_base->server->port))
{
is_suspect = true;
}
@ -542,9 +540,9 @@ bool MariaDBMonitor::do_switchover(MariaDBServer** current_master, MariaDBServer
if (*current_master == NULL)
{
// Autoselect current master.
if (m_master && SERVER_IS_MASTER(m_master->server))
if (m_master && SERVER_IS_MASTER(m_master->server_base->server))
{
demotion_target = get_server_info(m_master);
demotion_target = m_master;
*current_master = demotion_target;
}
else
@ -1176,7 +1174,7 @@ MariaDBServer* MariaDBMonitor::select_new_master(ServerRefArray* slaves_out, jso
* If master is replicating from external master, it is updated by update_slave_info()
* but not added to array. */
MariaDBServer* cand = update_slave_info(iter->server_base);
if (cand && cand->server_base != m_master)
if (cand && cand != m_master)
{
slaves_out->push_back(cand);
// Check that server is not in the exclusion list while still being a valid choice.
@ -1461,7 +1459,7 @@ bool MariaDBMonitor::mon_process_failover(bool* cluster_modified_out)
{
ss_dassert(*cluster_modified_out == false);
if (config_get_global_options()->passive ||
(m_master && SERVER_IS_MASTER(m_master->server)))
(m_master && SERVER_IS_MASTER(m_master->server_base->server)))
{
return true;
}
@ -1583,7 +1581,7 @@ bool MariaDBMonitor::slave_receiving_events()
{
ss_dassert(m_master);
bool received_event = false;
int64_t master_id = m_master->server->node_id;
int64_t master_id = m_master->server_base->server->node_id;
for (MXS_MONITORED_SERVER* server = m_monitor_base->monitored_servers; server; server = server->next)
{
MariaDBServer* info = get_server_info(server);

47
server/modules/monitor/mariadbmon/mariadbmon.cc
View File

@ -378,7 +378,7 @@ void MariaDBMonitor::main_loop()
return;
}
load_server_journal(m_monitor_base, &m_master);
load_journal();
if (m_detect_replication_lag)
{
@ -403,7 +403,7 @@ void MariaDBMonitor::main_loop()
// Use the information to find the so far best master server.
root_master = find_root_master();
if (m_master != NULL && SERVER_IS_MASTER(m_master->server))
if (m_master != NULL && SERVER_IS_MASTER(m_master->server_base->server))
{
// Update cluster-wide values dependant on the current master.
update_gtid_domain();
@ -438,7 +438,7 @@ void MariaDBMonitor::main_loop()
if (set_standalone_master(m_monitor_base->monitored_servers))
{
// Update the root_master to point to the standalone master
root_master = get_server_info(m_master);
root_master = m_master;
}
}
else
@ -466,7 +466,7 @@ void MariaDBMonitor::main_loop()
}
}
ss_dassert(root_master == NULL || root_master->server_base == m_master);
ss_dassert(root_master == NULL || root_master == m_master);
ss_dassert(root_master == NULL ||
((root_master->server_base->server->status & (SERVER_SLAVE | SERVER_MASTER)) !=
(SERVER_SLAVE | SERVER_MASTER)));
@ -505,7 +505,7 @@ void MariaDBMonitor::main_loop()
mon_hangup_failed_servers(m_monitor_base);
servers_status_current_to_pending(m_monitor_base);
store_server_journal(m_monitor_base, m_master);
store_server_journal(m_monitor_base, m_master->server_base);
release_monitor_servers(m_monitor_base);
// Check how much the monitor should sleep to get one full monitor interval.
@ -535,8 +535,7 @@ void MariaDBMonitor::main_loop()
void MariaDBMonitor::update_gtid_domain()
{
MariaDBServer* master_info = get_server_info(m_master);
int64_t domain = master_info->gtid_domain_id;
int64_t domain = m_master->gtid_domain_id;
if (m_master_gtid_domain >= 0 && domain != m_master_gtid_domain)
{
MXS_NOTICE("Gtid domain id of master has changed: %" PRId64 " -> %" PRId64 ".",
@ -547,14 +546,13 @@ void MariaDBMonitor::update_gtid_domain()
void MariaDBMonitor::update_external_master()
{
MariaDBServer* master_info = get_server_info(m_master);
if (SERVER_IS_SLAVE_OF_EXTERNAL_MASTER(m_master->server))
if (SERVER_IS_SLAVE_OF_EXTERNAL_MASTER(m_master->server_base->server))
{
if (master_info->slave_status.master_host != m_external_master_host ||
master_info->slave_status.master_port != m_external_master_port)
if (m_master->slave_status.master_host != m_external_master_host ||
m_master->slave_status.master_port != m_external_master_port)
{
const string new_ext_host = master_info->slave_status.master_host;
const int new_ext_port = master_info->slave_status.master_port;
const string new_ext_host = m_master->slave_status.master_host;
const int new_ext_port = m_master->slave_status.master_port;
if (m_external_master_port == PORT_UNKNOWN)
{
MXS_NOTICE("Cluster master server is replicating from an external master: %s:%d",
@ -617,7 +615,7 @@ void MariaDBMonitor::handle_auto_failover(bool* failover_performed)
}
// If master seems to be down, check if slaves are receiving events.
else if (m_verify_master_failure && m_master &&
SERVER_IS_DOWN(m_master->server) && slave_receiving_events())
SERVER_IS_DOWN(m_master->server_base->server) && slave_receiving_events())
{
MXS_INFO("Master failure not yet confirmed by slaves, delaying failover.");
}
@ -687,7 +685,7 @@ void MariaDBMonitor::handle_auto_rejoin()
else
{
MXS_ERROR("Query error to master '%s' prevented a possible rejoin operation.",
m_master->server->unique_name);
m_master->server_base->server->unique_name);
}
}
@ -790,7 +788,7 @@ void MariaDBMonitor::set_master_heartbeat(MXS_MONITORED_SERVER *database)
sprintf(heartbeat_insert_query,
"UPDATE maxscale_schema.replication_heartbeat "
"SET master_timestamp = %lu WHERE master_server_id = %li AND maxscale_id = %lu",
heartbeat, m_master->server->node_id, m_id);
heartbeat, m_master->server_base->server->node_id, m_id);
/* Try to insert MaxScale timestamp into master */
if (mxs_mysql_query(database->con, heartbeat_insert_query))
@ -810,7 +808,7 @@ void MariaDBMonitor::set_master_heartbeat(MXS_MONITORED_SERVER *database)
sprintf(heartbeat_insert_query,
"REPLACE INTO maxscale_schema.replication_heartbeat "
"(master_server_id, maxscale_id, master_timestamp ) VALUES ( %li, %lu, %lu)",
m_master->server->node_id, m_id, heartbeat);
m_master->server_base->server->node_id, m_id, heartbeat);
if (mxs_mysql_query(database->con, heartbeat_insert_query))
{
@ -866,7 +864,7 @@ void MariaDBMonitor::set_slave_heartbeat(MXS_MONITORED_SERVER *database)
sprintf(select_heartbeat_query, "SELECT master_timestamp "
"FROM maxscale_schema.replication_heartbeat "
"WHERE maxscale_id = %lu AND master_server_id = %li",
m_id, m_master->server->node_id);
m_id, m_master->server_base->server->node_id);
/* if there is a master then send the query to the slave with master_id */
if (m_master != NULL && (mxs_mysql_query(database->con, select_heartbeat_query) == 0
@ -927,7 +925,7 @@ void MariaDBMonitor::set_slave_heartbeat(MXS_MONITORED_SERVER *database)
database->server->rlag = MAX_RLAG_NOT_AVAILABLE;
database->server->node_ts = 0;
if (m_master->server->node_id < 0)
if (m_master->server_base->server->node_id < 0)
{
MXS_ERROR("error: replication heartbeat: "
"master_server_id NOT available for %s:%i",
@ -960,6 +958,17 @@ void MariaDBMonitor::disable_setting(const char* setting)
monitorAddParameters(m_monitor_base, &p);
}
/**
* Loads saved server states. Should only be called once at the beginning of the main loop after server
* creation.
*/
void MariaDBMonitor::load_journal()
{
MXS_MONITORED_SERVER* master_output = NULL;
load_server_journal(m_monitor_base, &master_output);
m_master = master_output ? get_server_info(master_output) : NULL;
}
/**
* Start the monitor instance and return the instance data. This function creates a thread to
* execute the monitoring. Use stopMonitor() to stop the thread.

3
server/modules/monitor/mariadbmon/mariadbmon.hh
View File

@ -118,7 +118,7 @@ private:
int64_t m_master_gtid_domain; /**< Gtid domain currently used by the master */
std::string m_external_master_host; /**< External master host, for fail/switchover */
int m_external_master_port; /**< External master port */
MXS_MONITORED_SERVER *m_master; /**< Master server for MySQL Master/Slave replication */
MariaDBServer *m_master; /**< Master server for MySQL Master/Slave replication */
// Replication topology detection settings
bool m_mysql51_replication; /**< Use MySQL 5.1 replication */
@ -235,6 +235,7 @@ private:
bool wait_cluster_stabilization(MariaDBServer* new_master, const ServerRefArray& slaves,
int seconds_remaining);
void disable_setting(const char* setting);
void load_journal();
};
/**