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

MXS-2025 Change RWBackend usage to a vector of raw ptrs.

Browse Source 
This is essentially just a search and replace to change SRWBackend to
RWBackend* and SRWBackendList to PRWBackends, a vector of a raw
pointers. In the next few commits vector<unique_ptr<RWBackend>>
will be used for life time management.

There are a lot of diffs from the global search and replace. Only a few manual
edits had to be done.

list-src -x build | xargs sed -ri 's/SRWBackends/prwbackends/g'
list-src -x build | xargs sed -ri 's/const mxs::SRWBackend\&/const mxs::RWBackend\*/g'
list-src -x build | xargs sed -ri 's/const SRWBackend\&/const RWBackend\*/g'
list-src -x build | xargs sed -ri 's/mxs::SRWBackend\&/mxs::RWBackend\*/g'
list-src -x build | xargs sed -ri 's/mxs::SRWBackend/mxs::RWBackend\*/g'
list-src -x build | xargs sed -ri 's/SRWBackend\(\)/nullptr/g'
list-src -x build | xargs sed -ri 's/mxs::SRWBackend\&/mxs::RWBackend\*/g'
list-src -x build | xargs sed -ri 's/mxs::SRWBackend/mxs::RWBackend\*/g'
list-src -x build | xargs sed -ri 's/SRWBackend\&/RWBackend\*/g'
list-src -x build | xargs sed -ri 's/SRWBackend\b/RWBackend\*/g'
list-src -x build | xargs sed -ri 's/prwbackends/PRWBackends/g'
This commit is contained in:
Niclas Antti
2018-11-28 18:52:42 +02:00
parent d96a7dedc5
commit 20b62a3f3d
10 changed files with 128 additions and 125 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
include/maxscale/protocol/rwbackend.hh
View File

@ -34,8 +34,12 @@ enum reply_state_t
typedef std::map<uint32_t, uint32_t> BackendHandleMap; /** Internal ID to external ID */
class RWBackend;
typedef std::shared_ptr<RWBackend> SRWBackend;
typedef std::list<SRWBackend> SRWBackendList;
// All interfacing is now handled via RWBackend*.
using PRWBackends = std::vector<RWBackend*>;
// Internal storage for a class containing RWBackend:s. Not used yet.
using SRWBackends = std::vector<std::unique_ptr<RWBackend>>;
class RWBackend : public mxs::Backend
{
@ -44,7 +48,7 @@ class RWBackend : public mxs::Backend
public:
static SRWBackendList from_servers(SERVER_REF* servers);
static PRWBackends from_servers(SERVER_REF* servers);
RWBackend(SERVER_REF* ref);
virtual ~RWBackend();

6
server/modules/protocol/MySQL/rwbackend.cc
View File

@ -253,15 +253,15 @@ ResponseStat& RWBackend::response_stat()
return m_response_stat;
}
SRWBackendList RWBackend::from_servers(SERVER_REF* servers)
PRWBackends RWBackend::from_servers(SERVER_REF* servers)
{
SRWBackendList backends;
PRWBackends backends;
for (SERVER_REF* ref = servers; ref; ref = ref->next)
{
if (ref->active)
{
backends.push_back(mxs::SRWBackend(new mxs::RWBackend(ref)));
backends.push_back(new mxs::RWBackend(ref));
}
}

2
server/modules/routing/cat/catsession.cc
View File

@ -18,7 +18,7 @@
using namespace maxscale;
CatSession::CatSession(MXS_SESSION* session, Cat* router, SRWBackendList& backends)
CatSession::CatSession(MXS_SESSION* session, Cat* router, PRWBackends& backends)
: RouterSession(session)
, m_session(session)
, m_backends(backends)

6
server/modules/routing/cat/catsession.hh
View File

@ -27,7 +27,7 @@ class CatSession : public mxs::RouterSession
CatSession& operator=(const CatSession&) = delete;
public:
CatSession(MXS_SESSION* session, Cat* router, mxs::SRWBackendList& backends);
CatSession(MXS_SESSION* session, Cat* router, mxs::PRWBackends& backends);
/**
* The RouterSession instance will be deleted when a client session
@ -71,10 +71,10 @@ public:
private:
MXS_SESSION* m_session;
mxs::SRWBackendList m_backends;
mxs::PRWBackends m_backends;
uint64_t m_completed;
uint8_t m_packet_num;
mxs::SRWBackendList::iterator m_current;
mxs::PRWBackends::iterator m_current;
GWBUF* m_query;
/**

14
server/modules/routing/readwritesplit/readwritesplit.hh
View File

@ -132,7 +132,7 @@ static const char gtid_wait_stmt[] =
/** Function that returns a "score" for a server to enable comparison.
* Smaller numbers are better.
*/
using SRWBackendVector = std::vector<mxs::SRWBackend*>;
using SRWBackendVector = std::vector<mxs::RWBackend**>;
using BackendSelectFunction = std::function
<SRWBackendVector::iterator (SRWBackendVector& sBackends)>;
BackendSelectFunction get_backend_select_function(select_criteria_t);
@ -270,8 +270,8 @@ public:
int max_slave_count() const;
bool have_enough_servers() const;
bool select_connect_backend_servers(MXS_SESSION* session,
mxs::SRWBackendList& backends,
mxs::SRWBackend& current_master,
mxs::PRWBackends& backends,
mxs::RWBackend** current_master,
mxs::SessionCommandList* sescmd_list,
int* expected_responses,
connection_type type);
@ -393,7 +393,7 @@ static inline const char* failure_mode_to_str(enum failure_mode type)
void closed_session_reply(GWBUF* querybuf);
bool send_readonly_error(DCB* dcb);
mxs::SRWBackend get_root_master(const mxs::SRWBackendList& backends);
mxs::RWBackend* get_root_master(const mxs::PRWBackends& backends);
/**
* Get total slave count and connected slave count
@ -403,13 +403,13 @@ mxs::SRWBackend get_root_master(const mxs::SRWBackendList& backends);
*
* @return Total number of slaves and number of slaves we are connected to
*/
std::pair<int, int> get_slave_counts(mxs::SRWBackendList& backends, mxs::SRWBackend& master);
std::pair<int, int> get_slave_counts(mxs::PRWBackends& backends, mxs::RWBackend* master);
/**
* Find the best backend by grouping the servers by priority, and then applying
* selection criteria to the best group.
*
* @param backends: vector of SRWBackend
* @param backends: vector of RWBackend*
* @param select: selection function
* @param master_accept_reads: NOTE: even if this is false, in some cases a master can
* still be selected for reads.
@ -423,4 +423,4 @@ SRWBackendVector::iterator find_best_backend(SRWBackendVector& backends,
/*
* The following are implemented in rwsplit_tmp_table_multi.c
*/
void close_all_connections(mxs::SRWBackendList& backends);
void close_all_connections(mxs::PRWBackends& backends);

62
server/modules/routing/readwritesplit/rwsplit_route_stmt.cc
View File

@ -36,7 +36,7 @@ using namespace maxscale;
* write split router, and not intended to be called from anywhere else.
*/
void RWSplitSession::handle_connection_keepalive(SRWBackend& target)
void RWSplitSession::handle_connection_keepalive(RWBackend* target)
{
mxb_assert(target);
MXB_AT_DEBUG(int nserv = 0);
@ -45,7 +45,7 @@ void RWSplitSession::handle_connection_keepalive(SRWBackend& target)
for (auto it = m_backends.begin(); it != m_backends.end(); it++)
{
SRWBackend backend = *it;
RWBackend* backend = *it;
if (backend->in_use() && backend != target && !backend->is_waiting_result())
{
@ -65,7 +65,7 @@ void RWSplitSession::handle_connection_keepalive(SRWBackend& target)
mxb_assert(nserv < m_nbackends);
}
bool RWSplitSession::prepare_target(SRWBackend& target, route_target_t route_target)
bool RWSplitSession::prepare_target(RWBackend* target, route_target_t route_target)
{
bool rval = true;
@ -195,7 +195,7 @@ bool RWSplitSession::route_single_stmt(GWBUF* querybuf)
uint32_t qtype = info.type_mask();
route_target_t route_target = info.target();
SRWBackend target;
RWBackend* target;
if (TARGET_IS_ALL(route_target))
{
@ -380,7 +380,7 @@ void RWSplitSession::continue_large_session_write(GWBUF* querybuf, uint32_t type
{
for (auto it = m_backends.begin(); it != m_backends.end(); it++)
{
SRWBackend& backend = *it;
RWBackend* backend = *it;
if (backend->in_use())
{
@ -448,7 +448,7 @@ bool RWSplitSession::route_session_write(GWBUF* querybuf, uint8_t command, uint3
for (auto it = m_backends.begin(); it != m_backends.end(); it++)
{
SRWBackend& backend = *it;
RWBackend* backend = *it;
if (backend->in_use())
{
@ -549,14 +549,14 @@ bool RWSplitSession::route_session_write(GWBUF* querybuf, uint8_t command, uint3
/**
* Check if replication lag is below acceptable levels
*/
static inline bool rpl_lag_is_ok(SRWBackend& backend, int max_rlag)
static inline bool rpl_lag_is_ok(RWBackend* backend, int max_rlag)
{
return max_rlag == MXS_RLAG_UNDEFINED || backend->server()->rlag <= max_rlag;
}
SRWBackend RWSplitSession::get_hinted_backend(char* name)
RWBackend* RWSplitSession::get_hinted_backend(char* name)
{
SRWBackend rval;
RWBackend* rval;
for (auto it = m_backends.begin(); it != m_backends.end(); it++)
{
@ -574,7 +574,7 @@ SRWBackend RWSplitSession::get_hinted_backend(char* name)
return rval;
}
SRWBackend RWSplitSession::get_slave_backend(int max_rlag)
RWBackend* RWSplitSession::get_slave_backend(int max_rlag)
{
// create a list of useable backends (includes masters, function name is a bit off),
// then feed that list to compare.
@ -605,14 +605,14 @@ SRWBackend RWSplitSession::get_slave_backend(int max_rlag)
m_config.backend_select_fct,
m_config.master_accept_reads);
return (rval == candidates.end()) ? SRWBackend() : **rval;
return (rval == candidates.end()) ? nullptr : **rval;
}
SRWBackend RWSplitSession::get_master_backend()
RWBackend* RWSplitSession::get_master_backend()
{
SRWBackend rval;
RWBackend* rval;
/** get root master from available servers */
SRWBackend master = get_root_master(m_backends);
RWBackend* master = get_root_master(m_backends);
if (master)
{
@ -639,7 +639,7 @@ SRWBackend RWSplitSession::get_master_backend()
return rval;
}
SRWBackend RWSplitSession::get_last_used_backend()
RWBackend* RWSplitSession::get_last_used_backend()
{
return m_prev_target ? m_prev_target : get_master_backend();
}
@ -655,7 +655,7 @@ SRWBackend RWSplitSession::get_last_used_backend()
*
* @return True if a backend was found
*/
SRWBackend RWSplitSession::get_target_backend(backend_type_t btype,
RWBackend* RWSplitSession::get_target_backend(backend_type_t btype,
char* name,
int max_rlag)
{
@ -665,7 +665,7 @@ SRWBackend RWSplitSession::get_target_backend(backend_type_t btype,
return m_target_node;
}
SRWBackend rval;
RWBackend* rval;
if (name) /*< Choose backend by name from a hint */
{
@ -721,7 +721,7 @@ int RWSplitSession::get_max_replication_lag()
*
* @return bool - true if succeeded, false otherwise
*/
SRWBackend RWSplitSession::handle_hinted_target(GWBUF* querybuf, route_target_t route_target)
RWBackend* RWSplitSession::handle_hinted_target(GWBUF* querybuf, route_target_t route_target)
{
char* named_server = NULL;
int rlag_max = MXS_RLAG_UNDEFINED;
@ -768,7 +768,7 @@ SRWBackend RWSplitSession::handle_hinted_target(GWBUF* querybuf, route_target_t
* Search backend server by name or replication lag.
* If it fails, then try to find valid slave or master.
*/
SRWBackend target = get_target_backend(btype, named_server, rlag_max);
RWBackend* target = get_target_backend(btype, named_server, rlag_max);
if (!target)
{
@ -799,10 +799,10 @@ SRWBackend RWSplitSession::handle_hinted_target(GWBUF* querybuf, route_target_t
*
* @return The target backend if one was found
*/
SRWBackend RWSplitSession::handle_slave_is_target(uint8_t cmd, uint32_t stmt_id)
RWBackend* RWSplitSession::handle_slave_is_target(uint8_t cmd, uint32_t stmt_id)
{
int rlag_max = get_max_replication_lag();
SRWBackend target;
RWBackend* target;
if (cmd == MXS_COM_STMT_FETCH)
{
@ -852,8 +852,8 @@ SRWBackend RWSplitSession::handle_slave_is_target(uint8_t cmd, uint32_t stmt_id)
* @brief Log master write failure
*/
void RWSplitSession::log_master_routing_failure(bool found,
SRWBackend& old_master,
SRWBackend& curr_master)
RWBackend* old_master,
RWBackend* curr_master)
{
/** Both backends should either be empty, not connected or the DCB should
* be a backend (the last check is slightly redundant). */
@ -915,7 +915,7 @@ void RWSplitSession::log_master_routing_failure(bool found,
errmsg);
}
bool RWSplitSession::should_replace_master(SRWBackend& target)
bool RWSplitSession::should_replace_master(RWBackend* target)
{
return m_config.master_reconnection
&& // We have a target server and it's not the current master
@ -926,14 +926,14 @@ bool RWSplitSession::should_replace_master(SRWBackend& target)
!is_locked_to_master();
}
void RWSplitSession::replace_master(SRWBackend& target)
void RWSplitSession::replace_master(RWBackend* target)
{
m_current_master = target;
m_qc.master_replaced();
}
bool RWSplitSession::should_migrate_trx(SRWBackend& target)
bool RWSplitSession::should_migrate_trx(RWBackend* target)
{
return m_config.transaction_replay
&& // We have a target server and it's not the current master
@ -957,9 +957,9 @@ bool RWSplitSession::should_migrate_trx(SRWBackend& target)
*
* @return bool - true if succeeded, false otherwise
*/
bool RWSplitSession::handle_master_is_target(SRWBackend* dest)
bool RWSplitSession::handle_master_is_target(RWBackend** dest)
{
SRWBackend target = get_target_backend(BE_MASTER, NULL, MXS_RLAG_UNDEFINED);
RWBackend* target = get_target_backend(BE_MASTER, NULL, MXS_RLAG_UNDEFINED);
bool succp = true;
if (should_replace_master(target))
@ -1001,7 +1001,7 @@ bool RWSplitSession::handle_master_is_target(SRWBackend* dest)
&& m_target_node == m_current_master)
{
/** Reset the forced node as we're in relaxed multi-statement mode */
m_target_node.reset();
m_target_node = nullptr;
}
*dest = target;
@ -1073,7 +1073,7 @@ GWBUF* RWSplitSession::add_prefix_wait_gtid(SERVER* server, GWBUF* origin)
*
* @return True on success
*/
bool RWSplitSession::handle_got_target(GWBUF* querybuf, SRWBackend& target, bool store)
bool RWSplitSession::handle_got_target(GWBUF* querybuf, RWBackend* target, bool store)
{
mxb_assert(target->in_use());
/**
@ -1183,7 +1183,7 @@ bool RWSplitSession::handle_got_target(GWBUF* querybuf, SRWBackend& target, bool
&& session_trx_is_read_only(m_client->session)
&& session_trx_is_ending(m_client->session))
{
m_target_node.reset();
m_target_node = nullptr;
}
}
else

28
server/modules/routing/readwritesplit/rwsplit_select_backends.cc
View File

@ -51,7 +51,7 @@ double toss()
*
* @return True if this server is a valid slave candidate
*/
static bool valid_for_slave(const SRWBackend& backend, const SRWBackend& master)
static bool valid_for_slave(const RWBackend* backend, const RWBackend* master)
{
return (backend->is_slave() || backend->is_relay())
&& (!master || backend != master);
@ -257,12 +257,12 @@ SRWBackendVector::iterator find_best_backend(SRWBackendVector& backends,
* @param criteria Slave selection criteria
* @param rses Router client session
*/
static void log_server_connections(select_criteria_t criteria, const SRWBackendList& backends)
static void log_server_connections(select_criteria_t criteria, const PRWBackends& backends)
{
MXS_INFO("Servers and %s connection counts:",
criteria == LEAST_GLOBAL_CONNECTIONS ? "all MaxScale" : "router");
for (SRWBackendList::const_iterator it = backends.begin(); it != backends.end(); it++)
for (PRWBackends::const_iterator it = backends.begin(); it != backends.end(); it++)
{
SERVER_REF* b = (*it)->backend();
@ -320,9 +320,9 @@ static void log_server_connections(select_criteria_t criteria, const SRWBackendL
}
}
SRWBackend get_root_master(const SRWBackendList& backends)
RWBackend* get_root_master(const PRWBackends& backends)
{
SRWBackend master;
RWBackend* master;
for (auto candidate : backends)
{
if (candidate->is_master())
@ -335,15 +335,15 @@ SRWBackend get_root_master(const SRWBackendList& backends)
return master;
}
std::pair<int, int> get_slave_counts(SRWBackendList& backends, SRWBackend& master)
std::pair<int, int> get_slave_counts(PRWBackends& backends, RWBackend* master)
{
int slaves_found = 0;
int slaves_connected = 0;
/** Calculate how many connections we already have */
for (SRWBackendList::const_iterator it = backends.begin(); it != backends.end(); it++)
for (PRWBackends::const_iterator it = backends.begin(); it != backends.end(); it++)
{
const SRWBackend& backend = *it;
const RWBackend* backend = *it;
if (backend->can_connect() && valid_for_slave(backend, master))
{
@ -373,13 +373,13 @@ std::pair<int, int> get_slave_counts(SRWBackendList& backends, SRWBackend& maste
* @return True if session can continue
*/
bool RWSplit::select_connect_backend_servers(MXS_SESSION* session,
SRWBackendList& backends,
SRWBackend& current_master,
PRWBackends& backends,
mxs::RWBackend** current_master,
SessionCommandList* sescmd_list,
int* expected_responses,
connection_type type)
{
SRWBackend master = get_root_master(backends);
RWBackend* master = get_root_master(backends);
const Config& cnf {config()};
if (!master && cnf.master_failure_mode == RW_FAIL_INSTANTLY)
@ -398,16 +398,16 @@ bool RWSplit::select_connect_backend_servers(MXS_SESSION* session,
if (type == ALL)
{
/** Find a master server */
for (SRWBackendList::const_iterator it = backends.begin(); it != backends.end(); it++)
for (PRWBackends::const_iterator it = backends.begin(); it != backends.end(); it++)
{
const SRWBackend& backend = *it;
RWBackend* backend = *it;
if (backend->can_connect() && master && backend == master)
{
if (backend->connect(session))
{
MXS_INFO("Selected Master: %s", backend->name());
current_master = backend;
*current_master = backend;
}
break;
}

4
server/modules/routing/readwritesplit/rwsplit_session_cmd.cc
View File

@ -55,7 +55,7 @@ static std::string extract_error(GWBUF* buffer)
* @param master_cmd Master's reply
* @param slave_cmd Slave's reply
*/
static void discard_if_response_differs(SRWBackend backend,
static void discard_if_response_differs(RWBackend* backend,
uint8_t master_response,
uint8_t slave_response,
SSessionCommand sescmd)
@ -76,7 +76,7 @@ static void discard_if_response_differs(SRWBackend backend,
}
}
void RWSplitSession::process_sescmd_response(SRWBackend& backend, GWBUF** ppPacket)
void RWSplitSession::process_sescmd_response(RWBackend* backend, GWBUF** ppPacket)
{
if (backend->has_session_commands())
{

45
server/modules/routing/readwritesplit/rwsplitsession.cc
View File

@ -22,8 +22,8 @@ using namespace maxscale;
RWSplitSession::RWSplitSession(RWSplit* instance,
MXS_SESSION* session,
const SRWBackendList& backends,
const SRWBackend& master)
PRWBackends backends,
RWBackend* master)
: mxs::RouterSession(session)
, m_backends(backends)
, m_current_master(master)
@ -60,18 +60,18 @@ RWSplitSession* RWSplitSession::create(RWSplit* router, MXS_SESSION* session)
if (router->have_enough_servers())
{
SRWBackendList backends = RWBackend::from_servers(router->service()->dbref);
PRWBackends backends = RWBackend::from_servers(router->service()->dbref);
/**
* At least the master must be found if the router is in the strict mode.
* If sessions without master are allowed, only a slave must be found.
*/
SRWBackend master;
RWBackend* master;
if (router->select_connect_backend_servers(session,
backends,
master,
&master,
NULL,
NULL,
connection_type::ALL))
@ -91,11 +91,11 @@ RWSplitSession* RWSplitSession::create(RWSplit* router, MXS_SESSION* session)
return rses;
}
void close_all_connections(SRWBackendList& backends)
void close_all_connections(PRWBackends& backends)
{
for (SRWBackendList::iterator it = backends.begin(); it != backends.end(); it++)
for (PRWBackends::iterator it = backends.begin(); it != backends.end(); it++)
{
SRWBackend& backend = *it;
RWBackend* backend = *it;
if (backend->in_use())
{
@ -306,13 +306,13 @@ GWBUF* RWSplitSession::discard_master_wait_gtid_result(GWBUF* buffer)
*
* @return The correct reference
*/
SRWBackend& RWSplitSession::get_backend_from_dcb(DCB* dcb)
RWBackend* RWSplitSession::get_backend_from_dcb(DCB* dcb)
{
mxb_assert(dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER);
for (auto it = m_backends.begin(); it != m_backends.end(); it++)
{
SRWBackend& backend = *it;
RWBackend* backend = *it;
if (backend->in_use() && backend->dcb() == dcb)
{
@ -325,9 +325,8 @@ SRWBackend& RWSplitSession::get_backend_from_dcb(DCB* dcb)
MXS_ALERT("No reference to DCB %p found, aborting.", dcb);
raise(SIGABRT);
// To make the compiler happy, we return a reference to a static value.
static SRWBackend this_should_not_happen;
return this_should_not_happen;
// Make the compiler happy
abort();
}
/**
@ -367,7 +366,7 @@ static bool connection_was_killed(GWBUF* buffer)
return rval;
}
static void log_unexpected_response(SRWBackend& backend, GWBUF* buffer, GWBUF* current_query)
static void log_unexpected_response(RWBackend* backend, GWBUF* buffer, GWBUF* current_query)
{
if (mxs_mysql_is_err_packet(buffer))
{
@ -400,7 +399,7 @@ static void log_unexpected_response(SRWBackend& backend, GWBUF* buffer, GWBUF* c
}
}
GWBUF* RWSplitSession::handle_causal_read_reply(GWBUF* writebuf, SRWBackend& backend)
GWBUF* RWSplitSession::handle_causal_read_reply(GWBUF* writebuf, RWBackend* backend)
{
if (m_config.causal_reads)
{
@ -485,7 +484,7 @@ void RWSplitSession::trx_replay_next_stmt()
}
}
void RWSplitSession::manage_transactions(SRWBackend& backend, GWBUF* writebuf)
void RWSplitSession::manage_transactions(RWBackend* backend, GWBUF* writebuf)
{
if (m_otrx_state == OTRX_ROLLBACK)
{
@ -564,7 +563,7 @@ static bool server_is_shutting_down(GWBUF* writebuf)
void RWSplitSession::clientReply(GWBUF* writebuf, DCB* backend_dcb)
{
DCB* client_dcb = backend_dcb->session->client_dcb;
SRWBackend& backend = get_backend_from_dcb(backend_dcb);
RWBackend* backend = get_backend_from_dcb(backend_dcb);
if (backend->get_reply_state() == REPLY_STATE_DONE)
{
@ -747,7 +746,7 @@ void RWSplitSession::clientReply(GWBUF* writebuf, DCB* backend_dcb)
}
}
void check_and_log_backend_state(const SRWBackend& backend, DCB* problem_dcb)
void check_and_log_backend_state(const RWBackend* backend, DCB* problem_dcb)
{
if (backend)
{
@ -868,7 +867,7 @@ void RWSplitSession::handleError(GWBUF* errmsgbuf,
MXS_SESSION* session = problem_dcb->session;
mxb_assert(session);
SRWBackend& backend = get_backend_from_dcb(problem_dcb);
RWBackend* backend = get_backend_from_dcb(problem_dcb);
mxb_assert(backend->in_use());
switch (action)
@ -950,7 +949,7 @@ void RWSplitSession::handleError(GWBUF* errmsgbuf,
&& session_trx_is_read_only(problem_dcb->session))
{
// We're no longer locked to this server as it failed
m_target_node.reset();
m_target_node = nullptr;
// Try to replay the transaction on another node
can_continue = start_trx_replay();
@ -1019,7 +1018,7 @@ void RWSplitSession::handleError(GWBUF* errmsgbuf,
*/
bool RWSplitSession::handle_error_new_connection(DCB* backend_dcb, GWBUF* errmsg)
{
SRWBackend& backend = get_backend_from_dcb(backend_dcb);
RWBackend* backend = get_backend_from_dcb(backend_dcb);
MXS_SESSION* ses = backend_dcb->session;
bool route_stored = false;
@ -1096,7 +1095,7 @@ bool RWSplitSession::handle_error_new_connection(DCB* backend_dcb, GWBUF* errmsg
{
succp = m_router->select_connect_backend_servers(ses,
m_backends,
m_current_master,
&m_current_master,
&m_sescmd_list,
&m_expected_responses,
connection_type::SLAVE);
@ -1116,7 +1115,7 @@ bool RWSplitSession::handle_error_new_connection(DCB* backend_dcb, GWBUF* errmsg
void RWSplitSession::handle_error_reply_client(DCB* backend_dcb, GWBUF* errmsg)
{
mxs_session_state_t sesstate = m_client->session->state;
SRWBackend& backend = get_backend_from_dcb(backend_dcb);
RWBackend* backend = get_backend_from_dcb(backend_dcb);
backend->close();

56
server/modules/routing/readwritesplit/rwsplitsession.hh
View File

@ -35,10 +35,10 @@ typedef std::unordered_set<std::string> TableSet;
typedef std::map<uint64_t, uint8_t> ResponseMap;
/** List of slave responses that arrived before the master */
typedef std::list<std::pair<mxs::SRWBackend, uint8_t>> SlaveResponseList;
typedef std::list<std::pair<mxs::RWBackend*, uint8_t>> SlaveResponseList;
/** Map of COM_STMT_EXECUTE targets by internal ID */
typedef std::unordered_map<uint32_t, mxs::SRWBackend> ExecMap;
typedef std::unordered_map<uint32_t, mxs::RWBackend*> ExecMap;
/**
* The client session of a RWSplit instance
@ -131,10 +131,10 @@ public:
}
// TODO: Make member variables private
mxs::SRWBackendList m_backends; /**< List of backend servers */
mxs::SRWBackend m_current_master; /**< Current master server */
mxs::SRWBackend m_target_node; /**< The currently locked target node */
mxs::SRWBackend m_prev_target; /**< The previous target where a query was sent */
mxs::PRWBackends m_backends; /**< List of backend servers */
mxs::RWBackend* m_current_master; /**< Current master server */
mxs::RWBackend* m_target_node; /**< The currently locked target node */
mxs::RWBackend* m_prev_target; /**< The previous target where a query was sent */
Config m_config; /**< Configuration for this session */
int m_nbackends; /**< Number of backend servers (obsolete) */
DCB* m_client; /**< The client DCB */
@ -172,10 +172,10 @@ public:
private:
RWSplitSession(RWSplit* instance,
MXS_SESSION* session,
const mxs::SRWBackendList& backends,
const mxs::SRWBackend& master);
mxs::PRWBackends backends,
mxs::RWBackend* master);
void process_sescmd_response(mxs::SRWBackend& backend, GWBUF** ppPacket);
void process_sescmd_response(mxs::RWBackend* backend, GWBUF** ppPacket);
void compress_history(mxs::SSessionCommand& sescmd);
bool route_session_write(GWBUF* querybuf, uint8_t command, uint32_t type);
@ -183,42 +183,42 @@ private:
bool route_single_stmt(GWBUF* querybuf);
bool route_stored_query();
mxs::SRWBackend get_hinted_backend(char* name);
mxs::SRWBackend get_slave_backend(int max_rlag);
mxs::SRWBackend get_master_backend();
mxs::SRWBackend get_last_used_backend();
mxs::SRWBackend get_target_backend(backend_type_t btype, char* name, int max_rlag);
mxs::RWBackend* get_hinted_backend(char* name);
mxs::RWBackend* get_slave_backend(int max_rlag);
mxs::RWBackend* get_master_backend();
mxs::RWBackend* get_last_used_backend();
mxs::RWBackend* get_target_backend(backend_type_t btype, char* name, int max_rlag);
bool handle_target_is_all(route_target_t route_target,
GWBUF* querybuf,
int packet_type,
uint32_t qtype);
mxs::SRWBackend handle_hinted_target(GWBUF* querybuf, route_target_t route_target);
mxs::SRWBackend handle_slave_is_target(uint8_t cmd, uint32_t stmt_id);
bool handle_master_is_target(mxs::SRWBackend* dest);
bool handle_got_target(GWBUF* querybuf, mxs::SRWBackend& target, bool store);
void handle_connection_keepalive(mxs::SRWBackend& target);
bool prepare_target(mxs::SRWBackend& target, route_target_t route_target);
mxs::RWBackend* handle_hinted_target(GWBUF* querybuf, route_target_t route_target);
mxs::RWBackend* handle_slave_is_target(uint8_t cmd, uint32_t stmt_id);
bool handle_master_is_target(mxs::RWBackend** dest);
bool handle_got_target(GWBUF* querybuf, mxs::RWBackend* target, bool store);
void handle_connection_keepalive(mxs::RWBackend* target);
bool prepare_target(mxs::RWBackend* target, route_target_t route_target);
void retry_query(GWBUF* querybuf, int delay = 1);
bool should_replace_master(mxs::SRWBackend& target);
void replace_master(mxs::SRWBackend& target);
bool should_migrate_trx(mxs::SRWBackend& target);
bool should_replace_master(mxs::RWBackend* target);
void replace_master(mxs::RWBackend* target);
bool should_migrate_trx(mxs::RWBackend* target);
void log_master_routing_failure(bool found,
mxs::SRWBackend& old_master,
mxs::SRWBackend& curr_master);
mxs::RWBackend* old_master,
mxs::RWBackend* curr_master);
GWBUF* handle_causal_read_reply(GWBUF* writebuf, mxs::SRWBackend& backend);
GWBUF* handle_causal_read_reply(GWBUF* writebuf, mxs::RWBackend* backend);
GWBUF* add_prefix_wait_gtid(SERVER* server, GWBUF* origin);
void correct_packet_sequence(GWBUF* buffer);
GWBUF* discard_master_wait_gtid_result(GWBUF* buffer);
int get_max_replication_lag();
mxs::SRWBackend& get_backend_from_dcb(DCB* dcb);
mxs::RWBackend* get_backend_from_dcb(DCB* dcb);
void handle_error_reply_client(DCB* backend_dcb, GWBUF* errmsg);
bool handle_error_new_connection(DCB* backend_dcb, GWBUF* errmsg);
void manage_transactions(mxs::SRWBackend& backend, GWBUF* writebuf);
void manage_transactions(mxs::RWBackend* backend, GWBUF* writebuf);
void trx_replay_next_stmt();