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

MXS-1703 Remove MariaDBServer value array type

Browse Source 
Having two types of arrays was more trouble than worth. Clearer to just
use the array of pointers. Renamed ServerRefArray to ServerArray.
This commit is contained in:
Esa Korhonen
2018-04-12 15:52:24 +03:00
parent 9fe57bfb9b
commit f7cc2aed5a
4 changed files with 64 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1100,7 +1100,7 @@ MariaDBServer* MariaDBMonitor::find_root_master()
/* if only one server is configured, that's is Master */
if (num_servers == 1)
{
auto mon_server = m_servers[0].server_base;
auto mon_server = m_servers[0]->server_base;
if (SERVER_IS_RUNNING(mon_server->server))
{
mon_server->server->depth = 0;
@ -1110,7 +1110,7 @@ MariaDBServer* MariaDBMonitor::find_root_master()
monitor_set_pending_status(mon_server, SERVER_MASTER);
mon_server->server->depth = 0;
m_master = &m_servers[0];
m_master = m_servers[0];
found_root_master = mon_server;
}
}

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

@ -20,7 +20,7 @@
using std::string;
static void print_redirect_errors(MariaDBServer* first_server, const ServerRefArray& servers,
static void print_redirect_errors(MariaDBServer* first_server, const ServerArray& servers,
json_t** err_out);
bool MariaDBMonitor::manual_switchover(SERVER* new_master, SERVER* current_master, json_t** error_out)
@ -140,7 +140,7 @@ bool MariaDBMonitor::manual_rejoin(SERVER* rejoin_server, json_t** output)
{
if (can_replicate_from(slave_cand, m_master))
{
ServerRefArray joinable_server;
ServerArray joinable_server;
joinable_server.push_back(slave_cand);
if (do_rejoin(joinable_server) == 1)
{
@ -219,8 +219,8 @@ string MariaDBMonitor::generate_change_master_cmd(const string& master_host, int
* @param redirected_slaves A vector where to insert successfully redirected slaves.
* @return The number of slaves successfully redirected.
*/
int MariaDBMonitor::redirect_slaves(MariaDBServer* new_master, const ServerRefArray& slaves,
ServerRefArray* redirected_slaves)
int MariaDBMonitor::redirect_slaves(MariaDBServer* new_master, const ServerArray& slaves,
ServerArray* redirected_slaves)
{
ss_dassert(redirected_slaves != NULL);
MXS_NOTICE("Redirecting slaves to new master.");
@ -335,7 +335,7 @@ bool MariaDBMonitor::redirect_one_slave(MXS_MONITORED_SERVER* slave, const char*
* @param joinable_servers Which servers to rejoin
* @return The number of servers successfully rejoined
*/
uint32_t MariaDBMonitor::do_rejoin(const ServerRefArray& joinable_servers)
uint32_t MariaDBMonitor::do_rejoin(const ServerArray& joinable_servers)
{
SERVER* master_server = m_master->server_base->server;
const char* master_name = master_server->unique_name;
@ -389,18 +389,18 @@ bool MariaDBMonitor::cluster_can_be_joined()
* @return False, if there were possible rejoinable servers but communications error to master server
* prevented final checks.
*/
bool MariaDBMonitor::get_joinable_servers(ServerRefArray* output)
bool MariaDBMonitor::get_joinable_servers(ServerArray* output)
{
ss_dassert(output);
// 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++)
ServerArray suspects;
for (auto iter = m_servers.begin(); iter != m_servers.end(); iter++)
{
if (server_is_rejoin_suspect(&m_servers[i], m_master, NULL))
if (server_is_rejoin_suspect(*iter, m_master, NULL))
{
suspects.push_back(&m_servers[i]);
suspects.push_back(*iter);
}
}
@ -572,7 +572,7 @@ bool MariaDBMonitor::do_switchover(MariaDBServer** current_master, MariaDBServer
// Step 1: Save all slaves except promotion target to an array. If we have a
// user-defined master candidate, check it. Otherwise, autoselect.
MariaDBServer* promotion_target = NULL;
ServerRefArray redirectable_slaves;
ServerArray redirectable_slaves;
if (*new_master == NULL)
{
// Autoselect new master.
@ -600,14 +600,14 @@ bool MariaDBMonitor::do_switchover(MariaDBServer** current_master, MariaDBServer
* updated by update_slave_info() but not added to array. */
for (auto iter = m_servers.begin(); iter != m_servers.end(); iter++)
{
MariaDBServer& server = *iter;
if (&server != promotion_target)
MariaDBServer* server = *iter;
if (server != promotion_target)
{
MariaDBServer* slave_info = update_slave_info(server.server_base);
MariaDBServer* slave_info = update_slave_info(server->server_base);
// If master is replicating from external master, it is updated but not added to array.
if (slave_info && &server != demotion_target)
if (slave_info && server != demotion_target)
{
redirectable_slaves.push_back(&server);
redirectable_slaves.push_back(server);
}
}
}
@ -628,7 +628,7 @@ bool MariaDBMonitor::do_switchover(MariaDBServer** current_master, MariaDBServer
seconds_remaining -= difftime(step2_time, start_time);
// Step 3: Wait for the slaves (including promotion target) to catch up with master.
ServerRefArray catchup_slaves = redirectable_slaves;
ServerArray catchup_slaves = redirectable_slaves;
catchup_slaves.push_back(promotion_target);
if (switchover_wait_slaves_catchup(catchup_slaves, demotion_target->gtid_binlog_pos,
seconds_remaining, m_monitor_base->read_timeout, err_out))
@ -643,7 +643,7 @@ bool MariaDBMonitor::do_switchover(MariaDBServer** current_master, MariaDBServer
{
catchup_and_promote_success = true;
// Step 5: Redirect slaves and start replication on old master.
ServerRefArray redirected_slaves;
ServerArray redirected_slaves;
bool start_ok = switchover_start_slave(demotion_target->server_base,
promotion_target->server_base->server);
if (start_ok)
@ -729,7 +729,7 @@ bool MariaDBMonitor::do_failover(json_t** err_out)
int seconds_remaining = m_failover_timeout;
time_t start_time = time(NULL);
// Step 1: Select new master. Also populate a vector with all slaves not the selected master.
ServerRefArray redirectable_slaves;
ServerArray redirectable_slaves;
MariaDBServer* new_master = select_new_master(&redirectable_slaves, err_out);
if (new_master == NULL)
{
@ -751,7 +751,7 @@ bool MariaDBMonitor::do_failover(json_t** err_out)
if (promote_new_master(new_master->server_base, err_out))
{
// Step 4: Redirect slaves.
ServerRefArray redirected_slaves;
ServerArray redirected_slaves;
int redirects = redirect_slaves(new_master, redirectable_slaves, &redirected_slaves);
bool success = redirectable_slaves.empty() ? true : redirects > 0;
if (success)
@ -968,7 +968,7 @@ bool MariaDBMonitor::switchover_demote_master(MXS_MONITORED_SERVER* current_mast
* @param err_out json object for error printing. Can be NULL.
* @return True, if target gtid was reached within allotted time for all servers
*/
bool MariaDBMonitor::switchover_wait_slaves_catchup(const ServerRefArray& slaves, const GtidList& gtid,
bool MariaDBMonitor::switchover_wait_slaves_catchup(const ServerArray& slaves, const GtidList& gtid,
int total_timeout, int read_timeout, json_t** err_out)
{
bool success = true;
@ -1005,7 +1005,7 @@ bool MariaDBMonitor::switchover_wait_slaves_catchup(const ServerRefArray& slaves
* @param seconds_remaining How long can we wait
* @return True, if at least one slave got the new event within the time limit
*/
bool MariaDBMonitor::wait_cluster_stabilization(MariaDBServer* new_master, const ServerRefArray& slaves,
bool MariaDBMonitor::wait_cluster_stabilization(MariaDBServer* new_master, const ServerArray& slaves,
int seconds_remaining)
{
ss_dassert(!slaves.empty());
@ -1019,7 +1019,7 @@ bool MariaDBMonitor::wait_cluster_stabilization(MariaDBServer* new_master, const
int repl_fails = 0;
int successes = 0;
const GtidList& target = new_master->gtid_current_pos;
ServerRefArray wait_list = slaves; // Check all the servers in the list
ServerArray wait_list = slaves; // Check all the servers in the list
bool first_round = true;
bool time_is_up = false;
@ -1155,7 +1155,7 @@ bool MariaDBMonitor::promote_new_master(MXS_MONITORED_SERVER* new_master, json_t
* @param err_out json object for error printing. Can be NULL.
* @return The found master, or NULL if not found
*/
MariaDBServer* MariaDBMonitor::select_new_master(ServerRefArray* slaves_out, json_t** err_out)
MariaDBServer* MariaDBMonitor::select_new_master(ServerArray* slaves_out, json_t** err_out)
{
ss_dassert(slaves_out && slaves_out->size() == 0);
/* Select a new master candidate. Selects the one with the latest event in relay log.
@ -1163,7 +1163,7 @@ MariaDBServer* MariaDBMonitor::select_new_master(ServerRefArray* slaves_out, jso
MXS_MONITORED_SERVER* current_best = NULL;
MariaDBServer* current_best_info = NULL;
// Servers that cannot be selected because of exclusion, but seem otherwise ok.
ServerRefArray valid_but_excluded;
ServerArray valid_but_excluded;
// Index of the current best candidate in slaves_out
int master_vector_index = -1;
@ -1173,7 +1173,7 @@ MariaDBServer* MariaDBMonitor::select_new_master(ServerRefArray* slaves_out, jso
* Do not worry about the exclusion list yet, querying the excluded servers is ok.
* 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);
MariaDBServer* cand = update_slave_info((*iter)->server_base);
if (cand && cand != m_master)
{
slaves_out->push_back(cand);
@ -1610,7 +1610,7 @@ bool MariaDBMonitor::slave_receiving_events()
* @param redirectable_slaves Other servers to query for errors.
* @param err_out If not null, the error output object.
*/
static void print_redirect_errors(MariaDBServer* first_server, const ServerRefArray& servers,
static void print_redirect_errors(MariaDBServer* first_server, const ServerArray& servers,
json_t** err_out)
{
// Individual server errors have already been printed to the log.
@ -1619,7 +1619,7 @@ static void print_redirect_errors(MariaDBServer* first_server, const ServerRefAr
MXS_ERROR(MSG);
if (err_out)
{
ServerRefArray failed_slaves;
ServerArray failed_slaves;
if (first_server)
{
failed_slaves.push_back(first_server);
@ -1692,7 +1692,7 @@ bool MariaDBMonitor::switchover_check(SERVER* new_master, SERVER* current_master
bool gtid_ok = true;
for (auto iter = m_servers.begin(); iter != m_servers.end(); iter++)
{
if (SERVER_IS_SLAVE(iter->server_base->server) && !uses_gtid(iter->server_base, error_out))
if (SERVER_IS_SLAVE((*iter)->server_base->server) && !uses_gtid((*iter)->server_base, error_out))
{
gtid_ok = false;
}

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

@ -65,19 +65,23 @@ MariaDBMonitor::~MariaDBMonitor()
*/
void MariaDBMonitor::init_server_info()
{
m_servers.clear();
for (auto server = m_monitor_base->monitored_servers; server; server = server->next)
// If this monitor is being restarted, the server data needs to be freed.
for (auto iter = m_servers.begin(); iter != m_servers.end(); iter++)
{
m_servers.push_back(MariaDBServer(server));
delete *iter;
}
m_servers.clear();
for (auto mon_server = m_monitor_base->monitored_servers; mon_server; mon_server = mon_server->next)
{
m_servers.push_back(new MariaDBServer(mon_server));
}
// All servers have been inserted into the vector. The data in the vector should no longer move so it's
// safe to take addresses.
m_server_info.clear();
for (auto iter = m_servers.begin(); iter != m_servers.end(); iter++)
{
ss_dassert(m_server_info.count(iter->server_base) == 0);
ServerInfoMap::value_type new_val(iter->server_base, &*iter);
auto mon_server = (*iter)->server_base;
ss_dassert(m_server_info.count(mon_server) == 0);
ServerInfoMap::value_type new_val(mon_server, *iter);
m_server_info.insert(new_val);
}
}
@ -397,7 +401,7 @@ void MariaDBMonitor::main_loop()
// Query all servers for their status.
for (auto iter = m_servers.begin(); iter != m_servers.end(); iter++)
{
monitor_one_server(*iter);
monitor_one_server(**iter);
}
// Use the information to find the so far best master server.
@ -413,19 +417,19 @@ void MariaDBMonitor::main_loop()
// Assign relay masters, clear SERVER_SLAVE from binlog relays
for (auto iter = m_servers.begin(); iter != m_servers.end(); iter++)
{
assign_relay_master(*iter);
assign_relay_master(**iter);
/* Remove SLAVE status if this server is a Binlog Server relay */
if (iter->binlog_relay)
if ((*iter)->binlog_relay)
{
monitor_clear_pending_status(iter->server_base, SERVER_SLAVE);
monitor_clear_pending_status((*iter)->server_base, SERVER_SLAVE);
}
}
/* Update server status from monitor pending status on that server*/
for (auto iter = m_servers.begin(); iter != m_servers.end(); iter++)
{
update_server_states(*iter, root_master);
update_server_states(**iter, root_master);
}
/** Now that all servers have their status correctly set, we can check
@ -585,13 +589,13 @@ void MariaDBMonitor::measure_replication_lag(MariaDBServer* root_master_server)
set_master_heartbeat(root_master);
for (auto iter = m_servers.begin(); iter != m_servers.end(); iter++)
{
MXS_MONITORED_SERVER* ptr = iter->server_base;
MXS_MONITORED_SERVER* ptr = (*iter)->server_base;
if ((!SERVER_IN_MAINT(ptr->server)) && SERVER_IS_RUNNING(ptr->server))
{
if (ptr->server->node_id != root_master->server->node_id &&
(SERVER_IS_SLAVE(ptr->server) ||
SERVER_IS_RELAY_SERVER(ptr->server)) &&
!iter->binlog_relay) // No select lag for Binlog Server
!(*iter)->binlog_relay) // No select lag for Binlog Server
{
set_slave_heartbeat(ptr);
}
@ -665,7 +669,7 @@ void MariaDBMonitor::log_master_changes(MariaDBServer* root_master_server, int*
void MariaDBMonitor::handle_auto_rejoin()
{
ServerRefArray joinable_servers;
ServerArray joinable_servers;
if (get_joinable_servers(&joinable_servers))
{
uint32_t joins = do_rejoin(joinable_servers);
@ -1102,7 +1106,7 @@ bool handle_manual_rejoin(const MODULECMD_ARG* args, json_t** output)
return rv;
}
string monitored_servers_to_string(const ServerRefArray& servers)
string monitored_servers_to_string(const ServerArray& servers)
{
string rval;
size_t array_size = servers.size();
@ -1119,7 +1123,7 @@ string monitored_servers_to_string(const ServerRefArray& servers)
return rval;
}
string get_connection_errors(const ServerRefArray& servers)
string get_connection_errors(const ServerArray& servers)
{
// Get errors from all connections, form a string.
string rval;

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

@ -29,10 +29,8 @@ class MariaDBMonitor;
// Map of base struct to MariaDBServer. Does not own the server objects. May not be needed at the end.
typedef std::tr1::unordered_map<MXS_MONITORED_SERVER*, MariaDBServer*> ServerInfoMap;
// Server container, owns the server objects.
typedef std::vector<MariaDBServer> ServerArray; // TODO: Rename/get rid of ServerVector typedef!
// Server pointer array, used for temporary server collections
typedef std::vector<MariaDBServer*> ServerRefArray;
// Server pointer array
typedef std::vector<MariaDBServer*> ServerArray;
// MariaDB Monitor instance data
class MariaDBMonitor
@ -142,7 +140,7 @@ private:
bool m_auto_failover; /**< If automatic master failover is enabled */
bool m_auto_rejoin; /**< Attempt to start slave replication on standalone servers or servers
* replicating from the wrong master automatically. */
ServerRefArray m_excluded_servers; /**< Servers banned for master promotion during auto-failover. */
ServerArray m_excluded_servers; /**< Servers banned for master promotion during auto-failover. */
// Other settings
std::string m_script; /**< Script to call when state changes occur on servers */
@ -197,7 +195,7 @@ private:
bool switchover_check_preferred_master(MXS_MONITORED_SERVER* preferred, json_t** err_out);
bool switchover_demote_master(MXS_MONITORED_SERVER* current_master, MariaDBServer* info,
json_t** err_out);
bool switchover_wait_slaves_catchup(const ServerRefArray& slaves, const GtidList& gtid, int total_timeout,
bool switchover_wait_slaves_catchup(const ServerArray& slaves, const GtidList& gtid, int total_timeout,
int read_timeout, json_t** err_out);
bool switchover_start_slave(MXS_MONITORED_SERVER* old_master, SERVER* new_master);
@ -213,26 +211,26 @@ private:
// Rejoin methods
bool cluster_can_be_joined();
void handle_auto_rejoin();
bool get_joinable_servers(ServerRefArray* output);
bool get_joinable_servers(ServerArray* output);
bool server_is_rejoin_suspect(MariaDBServer* rejoin_cand, MariaDBServer* master, json_t** output);
bool can_replicate_from(MariaDBServer* slave_cand, MariaDBServer* master);
uint32_t do_rejoin(const ServerRefArray& joinable_servers);
uint32_t do_rejoin(const ServerArray& joinable_servers);
bool join_cluster(MXS_MONITORED_SERVER* server, const char* change_cmd);
// Methods common to failover/switchover/rejoin
bool uses_gtid(MXS_MONITORED_SERVER* mon_server, json_t** error_out);
MariaDBServer* select_new_master(ServerRefArray* slaves_out, json_t** err_out);
MariaDBServer* select_new_master(ServerArray* slaves_out, json_t** err_out);
MariaDBServer* update_slave_info(MXS_MONITORED_SERVER* server);
bool server_is_excluded(const MXS_MONITORED_SERVER* server);
bool is_candidate_better(const MariaDBServer* current_best_info, const MariaDBServer* candidate_info,
uint32_t gtid_domain);
bool promote_new_master(MXS_MONITORED_SERVER* new_master, json_t** err_out);
int redirect_slaves(MariaDBServer* new_master, const ServerRefArray& slaves,
ServerRefArray* redirected_slaves);
int redirect_slaves(MariaDBServer* new_master, const ServerArray& slaves,
ServerArray* redirected_slaves);
bool redirect_one_slave(MXS_MONITORED_SERVER* slave, const char* change_cmd);
std::string generate_change_master_cmd(const std::string& master_host, int master_port);
bool start_external_replication(MXS_MONITORED_SERVER* new_master, json_t** err_out);
bool wait_cluster_stabilization(MariaDBServer* new_master, const ServerRefArray& slaves,
bool wait_cluster_stabilization(MariaDBServer* new_master, const ServerArray& slaves,
int seconds_remaining);
void disable_setting(const char* setting);
void load_journal();
@ -244,7 +242,7 @@ private:
* @param servers The servers
* @return Server names
*/
std::string monitored_servers_to_string(const ServerRefArray& servers);
std::string monitored_servers_to_string(const ServerArray& servers);
/**
* Get MariaDB connection error strings from all the given servers, form one string.
@ -252,4 +250,4 @@ std::string monitored_servers_to_string(const ServerRefArray& servers);
* @param servers Servers with errors
* @return Concatenated string.
*/
std::string get_connection_errors(const ServerRefArray& servers);
std::string get_connection_errors(const ServerArray& servers);