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 */ typedef std::map<uint32_t, uint32_t> BackendHandleMap; /** Internal ID to external ID */
class RWBackend; 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 class RWBackend : public mxs::Backend
{ {
@ -44,7 +48,7 @@ class RWBackend : public mxs::Backend
public: public:
static SRWBackendList from_servers(SERVER_REF* servers); static PRWBackends from_servers(SERVER_REF* servers);
RWBackend(SERVER_REF* ref); RWBackend(SERVER_REF* ref);
virtual ~RWBackend(); virtual ~RWBackend();

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

@ -253,15 +253,15 @@ ResponseStat& RWBackend::response_stat()
return m_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) for (SERVER_REF* ref = servers; ref; ref = ref->next)
{ {
if (ref->active) 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; using namespace maxscale;
CatSession::CatSession(MXS_SESSION* session, Cat* router, SRWBackendList& backends) CatSession::CatSession(MXS_SESSION* session, Cat* router, PRWBackends& backends)
: RouterSession(session) : RouterSession(session)
, m_session(session) , m_session(session)
, m_backends(backends) , 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; CatSession& operator=(const CatSession&) = delete;
public: 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 * The RouterSession instance will be deleted when a client session
@ -71,10 +71,10 @@ public:
private: private:
MXS_SESSION* m_session; MXS_SESSION* m_session;
mxs::SRWBackendList m_backends; mxs::PRWBackends m_backends;
uint64_t m_completed; uint64_t m_completed;
uint8_t m_packet_num; uint8_t m_packet_num;
mxs::SRWBackendList::iterator m_current; mxs::PRWBackends::iterator m_current;
GWBUF* m_query; 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. /** Function that returns a "score" for a server to enable comparison.
* Smaller numbers are better. * Smaller numbers are better.
*/ */
using SRWBackendVector = std::vector<mxs::SRWBackend*>; using SRWBackendVector = std::vector<mxs::RWBackend**>;
using BackendSelectFunction = std::function using BackendSelectFunction = std::function
<SRWBackendVector::iterator (SRWBackendVector& sBackends)>; <SRWBackendVector::iterator (SRWBackendVector& sBackends)>;
BackendSelectFunction get_backend_select_function(select_criteria_t); BackendSelectFunction get_backend_select_function(select_criteria_t);
@ -270,8 +270,8 @@ public:
int max_slave_count() const; int max_slave_count() const;
bool have_enough_servers() const; bool have_enough_servers() const;
bool select_connect_backend_servers(MXS_SESSION* session, bool select_connect_backend_servers(MXS_SESSION* session,
mxs::SRWBackendList& backends, mxs::PRWBackends& backends,
mxs::SRWBackend& current_master, mxs::RWBackend** current_master,
mxs::SessionCommandList* sescmd_list, mxs::SessionCommandList* sescmd_list,
int* expected_responses, int* expected_responses,
connection_type type); 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); void closed_session_reply(GWBUF* querybuf);
bool send_readonly_error(DCB* dcb); 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 * 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 * @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 * Find the best backend by grouping the servers by priority, and then applying
* selection criteria to the best group. * selection criteria to the best group.
* *
* @param backends: vector of SRWBackend * @param backends: vector of RWBackend*
* @param select: selection function * @param select: selection function
* @param master_accept_reads: NOTE: even if this is false, in some cases a master can * @param master_accept_reads: NOTE: even if this is false, in some cases a master can
* still be selected for reads. * 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 * 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. * 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_assert(target);
MXB_AT_DEBUG(int nserv = 0); 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++) 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()) 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); 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; bool rval = true;
@ -195,7 +195,7 @@ bool RWSplitSession::route_single_stmt(GWBUF* querybuf)
uint32_t qtype = info.type_mask(); uint32_t qtype = info.type_mask();
route_target_t route_target = info.target(); route_target_t route_target = info.target();
SRWBackend target; RWBackend* target;
if (TARGET_IS_ALL(route_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++) for (auto it = m_backends.begin(); it != m_backends.end(); it++)
{ {
SRWBackend& backend = *it; RWBackend* backend = *it;
if (backend->in_use()) 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++) for (auto it = m_backends.begin(); it != m_backends.end(); it++)
{ {
SRWBackend& backend = *it; RWBackend* backend = *it;
if (backend->in_use()) 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 * 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; 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++) for (auto it = m_backends.begin(); it != m_backends.end(); it++)
{ {
@ -574,7 +574,7 @@ SRWBackend RWSplitSession::get_hinted_backend(char* name)
return rval; 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), // create a list of useable backends (includes masters, function name is a bit off),
// then feed that list to compare. // 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.backend_select_fct,
m_config.master_accept_reads); 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 */ /** get root master from available servers */
SRWBackend master = get_root_master(m_backends); RWBackend* master = get_root_master(m_backends);
if (master) if (master)
{ {
@ -639,7 +639,7 @@ SRWBackend RWSplitSession::get_master_backend()
return rval; return rval;
} }
SRWBackend RWSplitSession::get_last_used_backend() RWBackend* RWSplitSession::get_last_used_backend()
{ {
return m_prev_target ? m_prev_target : get_master_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 * @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, char* name,
int max_rlag) int max_rlag)
{ {
@ -665,7 +665,7 @@ SRWBackend RWSplitSession::get_target_backend(backend_type_t btype,
return m_target_node; return m_target_node;
} }
SRWBackend rval; RWBackend* rval;
if (name) /*< Choose backend by name from a hint */ 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 * @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; char* named_server = NULL;
int rlag_max = MXS_RLAG_UNDEFINED; 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. * Search backend server by name or replication lag.
* If it fails, then try to find valid slave or master. * 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) if (!target)
{ {
@ -799,10 +799,10 @@ SRWBackend RWSplitSession::handle_hinted_target(GWBUF* querybuf, route_target_t
* *
* @return The target backend if one was found * @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(); int rlag_max = get_max_replication_lag();
SRWBackend target; RWBackend* target;
if (cmd == MXS_COM_STMT_FETCH) 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 * @brief Log master write failure
*/ */
void RWSplitSession::log_master_routing_failure(bool found, void RWSplitSession::log_master_routing_failure(bool found,
SRWBackend& old_master, RWBackend* old_master,
SRWBackend& curr_master) RWBackend* curr_master)
{ {
/** Both backends should either be empty, not connected or the DCB should /** Both backends should either be empty, not connected or the DCB should
* be a backend (the last check is slightly redundant). */ * be a backend (the last check is slightly redundant). */
@ -915,7 +915,7 @@ void RWSplitSession::log_master_routing_failure(bool found,
errmsg); errmsg);
} }
bool RWSplitSession::should_replace_master(SRWBackend& target) bool RWSplitSession::should_replace_master(RWBackend* target)
{ {
return m_config.master_reconnection return m_config.master_reconnection
&& // We have a target server and it's not the current master && // 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(); !is_locked_to_master();
} }
void RWSplitSession::replace_master(SRWBackend& target) void RWSplitSession::replace_master(RWBackend* target)
{ {
m_current_master = target; m_current_master = target;
m_qc.master_replaced(); m_qc.master_replaced();
} }
bool RWSplitSession::should_migrate_trx(SRWBackend& target) bool RWSplitSession::should_migrate_trx(RWBackend* target)
{ {
return m_config.transaction_replay return m_config.transaction_replay
&& // We have a target server and it's not the current master && // 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 * @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; bool succp = true;
if (should_replace_master(target)) if (should_replace_master(target))
@ -1001,7 +1001,7 @@ bool RWSplitSession::handle_master_is_target(SRWBackend* dest)
&& m_target_node == m_current_master) && m_target_node == m_current_master)
{ {
/** Reset the forced node as we're in relaxed multi-statement mode */ /** Reset the forced node as we're in relaxed multi-statement mode */
m_target_node.reset(); m_target_node = nullptr;
} }
*dest = target; *dest = target;
@ -1073,7 +1073,7 @@ GWBUF* RWSplitSession::add_prefix_wait_gtid(SERVER* server, GWBUF* origin)
* *
* @return True on success * @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()); 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_read_only(m_client->session)
&& session_trx_is_ending(m_client->session)) && session_trx_is_ending(m_client->session))
{ {
m_target_node.reset(); m_target_node = nullptr;
} }
} }
else 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 * @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()) return (backend->is_slave() || backend->is_relay())
&& (!master || backend != master); && (!master || backend != master);
@ -257,12 +257,12 @@ SRWBackendVector::iterator find_best_backend(SRWBackendVector& backends,
* @param criteria Slave selection criteria * @param criteria Slave selection criteria
* @param rses Router client session * @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:", MXS_INFO("Servers and %s connection counts:",
criteria == LEAST_GLOBAL_CONNECTIONS ? "all MaxScale" : "router"); 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(); 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) for (auto candidate : backends)
{ {
if (candidate->is_master()) if (candidate->is_master())
@ -335,15 +335,15 @@ SRWBackend get_root_master(const SRWBackendList& backends)
return master; 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_found = 0;
int slaves_connected = 0; int slaves_connected = 0;
/** Calculate how many connections we already have */ /** 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)) 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 * @return True if session can continue
*/ */
bool RWSplit::select_connect_backend_servers(MXS_SESSION* session, bool RWSplit::select_connect_backend_servers(MXS_SESSION* session,
SRWBackendList& backends, PRWBackends& backends,
SRWBackend& current_master, mxs::RWBackend** current_master,
SessionCommandList* sescmd_list, SessionCommandList* sescmd_list,
int* expected_responses, int* expected_responses,
connection_type type) connection_type type)
{ {
SRWBackend master = get_root_master(backends); RWBackend* master = get_root_master(backends);
const Config& cnf {config()}; const Config& cnf {config()};
if (!master && cnf.master_failure_mode == RW_FAIL_INSTANTLY) 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) if (type == ALL)
{ {
/** Find a master server */ /** 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->can_connect() && master && backend == master)
{ {
if (backend->connect(session)) if (backend->connect(session))
{ {
MXS_INFO("Selected Master: %s", backend->name()); MXS_INFO("Selected Master: %s", backend->name());
current_master = backend; *current_master = backend;
} }
break; 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 master_cmd Master's reply
* @param slave_cmd Slave'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 master_response,
uint8_t slave_response, uint8_t slave_response,
SSessionCommand sescmd) 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()) 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, RWSplitSession::RWSplitSession(RWSplit* instance,
MXS_SESSION* session, MXS_SESSION* session,
const SRWBackendList& backends, PRWBackends backends,
const SRWBackend& master) RWBackend* master)
: mxs::RouterSession(session) : mxs::RouterSession(session)
, m_backends(backends) , m_backends(backends)
, m_current_master(master) , m_current_master(master)
@ -60,18 +60,18 @@ RWSplitSession* RWSplitSession::create(RWSplit* router, MXS_SESSION* session)
if (router->have_enough_servers()) 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. * 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. * If sessions without master are allowed, only a slave must be found.
*/ */
SRWBackend master; RWBackend* master;
if (router->select_connect_backend_servers(session, if (router->select_connect_backend_servers(session,
backends, backends,
master, &master,
NULL, NULL,
NULL, NULL,
connection_type::ALL)) connection_type::ALL))
@ -91,11 +91,11 @@ RWSplitSession* RWSplitSession::create(RWSplit* router, MXS_SESSION* session)
return rses; 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()) if (backend->in_use())
{ {
@ -306,13 +306,13 @@ GWBUF* RWSplitSession::discard_master_wait_gtid_result(GWBUF* buffer)
* *
* @return The correct reference * @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); mxb_assert(dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER);
for (auto it = m_backends.begin(); it != m_backends.end(); it++) for (auto it = m_backends.begin(); it != m_backends.end(); it++)
{ {
SRWBackend& backend = *it; RWBackend* backend = *it;
if (backend->in_use() && backend->dcb() == dcb) 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); MXS_ALERT("No reference to DCB %p found, aborting.", dcb);
raise(SIGABRT); raise(SIGABRT);
// To make the compiler happy, we return a reference to a static value. // Make the compiler happy
static SRWBackend this_should_not_happen; abort();
return this_should_not_happen;
} }
/** /**
@ -367,7 +366,7 @@ static bool connection_was_killed(GWBUF* buffer)
return rval; 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)) 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) 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) 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) void RWSplitSession::clientReply(GWBUF* writebuf, DCB* backend_dcb)
{ {
DCB* client_dcb = backend_dcb->session->client_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) 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) if (backend)
{ {
@ -868,7 +867,7 @@ void RWSplitSession::handleError(GWBUF* errmsgbuf,
MXS_SESSION* session = problem_dcb->session; MXS_SESSION* session = problem_dcb->session;
mxb_assert(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()); mxb_assert(backend->in_use());
switch (action) switch (action)
@ -950,7 +949,7 @@ void RWSplitSession::handleError(GWBUF* errmsgbuf,
&& session_trx_is_read_only(problem_dcb->session)) && session_trx_is_read_only(problem_dcb->session))
{ {
// We're no longer locked to this server as it failed // 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 // Try to replay the transaction on another node
can_continue = start_trx_replay(); 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) 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; MXS_SESSION* ses = backend_dcb->session;
bool route_stored = false; 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, succp = m_router->select_connect_backend_servers(ses,
m_backends, m_backends,
m_current_master, &m_current_master,
&m_sescmd_list, &m_sescmd_list,
&m_expected_responses, &m_expected_responses,
connection_type::SLAVE); 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) void RWSplitSession::handle_error_reply_client(DCB* backend_dcb, GWBUF* errmsg)
{ {
mxs_session_state_t sesstate = m_client->session->state; 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(); 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; typedef std::map<uint64_t, uint8_t> ResponseMap;
/** List of slave responses that arrived before the master */ /** 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 */ /** 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 * The client session of a RWSplit instance
@ -131,10 +131,10 @@ public:
} }
// TODO: Make member variables private // TODO: Make member variables private
mxs::SRWBackendList m_backends; /**< List of backend servers */ mxs::PRWBackends m_backends; /**< List of backend servers */
mxs::SRWBackend m_current_master; /**< Current master server */ mxs::RWBackend* m_current_master; /**< Current master server */
mxs::SRWBackend m_target_node; /**< The currently locked target node */ mxs::RWBackend* m_target_node; /**< The currently locked target node */
mxs::SRWBackend m_prev_target; /**< The previous target where a query was sent */ mxs::RWBackend* m_prev_target; /**< The previous target where a query was sent */
Config m_config; /**< Configuration for this session */ Config m_config; /**< Configuration for this session */
int m_nbackends; /**< Number of backend servers (obsolete) */ int m_nbackends; /**< Number of backend servers (obsolete) */
DCB* m_client; /**< The client DCB */ DCB* m_client; /**< The client DCB */
@ -172,10 +172,10 @@ public:
private: private:
RWSplitSession(RWSplit* instance, RWSplitSession(RWSplit* instance,
MXS_SESSION* session, MXS_SESSION* session,
const mxs::SRWBackendList& backends, mxs::PRWBackends backends,
const mxs::SRWBackend& master); 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); void compress_history(mxs::SSessionCommand& sescmd);
bool route_session_write(GWBUF* querybuf, uint8_t command, uint32_t type); 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_single_stmt(GWBUF* querybuf);
bool route_stored_query(); bool route_stored_query();
mxs::SRWBackend get_hinted_backend(char* name); mxs::RWBackend* get_hinted_backend(char* name);
mxs::SRWBackend get_slave_backend(int max_rlag); mxs::RWBackend* get_slave_backend(int max_rlag);
mxs::SRWBackend get_master_backend(); mxs::RWBackend* get_master_backend();
mxs::SRWBackend get_last_used_backend(); mxs::RWBackend* get_last_used_backend();
mxs::SRWBackend get_target_backend(backend_type_t btype, char* name, int max_rlag); mxs::RWBackend* get_target_backend(backend_type_t btype, char* name, int max_rlag);
bool handle_target_is_all(route_target_t route_target, bool handle_target_is_all(route_target_t route_target,
GWBUF* querybuf, GWBUF* querybuf,
int packet_type, int packet_type,
uint32_t qtype); uint32_t qtype);
mxs::SRWBackend handle_hinted_target(GWBUF* querybuf, route_target_t route_target); mxs::RWBackend* handle_hinted_target(GWBUF* querybuf, route_target_t route_target);
mxs::SRWBackend handle_slave_is_target(uint8_t cmd, uint32_t stmt_id); mxs::RWBackend* handle_slave_is_target(uint8_t cmd, uint32_t stmt_id);
bool handle_master_is_target(mxs::SRWBackend* dest); bool handle_master_is_target(mxs::RWBackend** dest);
bool handle_got_target(GWBUF* querybuf, mxs::SRWBackend& target, bool store); bool handle_got_target(GWBUF* querybuf, mxs::RWBackend* target, bool store);
void handle_connection_keepalive(mxs::SRWBackend& target); void handle_connection_keepalive(mxs::RWBackend* target);
bool prepare_target(mxs::SRWBackend& target, route_target_t route_target); bool prepare_target(mxs::RWBackend* target, route_target_t route_target);
void retry_query(GWBUF* querybuf, int delay = 1); void retry_query(GWBUF* querybuf, int delay = 1);
bool should_replace_master(mxs::SRWBackend& target); bool should_replace_master(mxs::RWBackend* target);
void replace_master(mxs::SRWBackend& target); void replace_master(mxs::RWBackend* target);
bool should_migrate_trx(mxs::SRWBackend& target); bool should_migrate_trx(mxs::RWBackend* target);
void log_master_routing_failure(bool found, void log_master_routing_failure(bool found,
mxs::SRWBackend& old_master, mxs::RWBackend* old_master,
mxs::SRWBackend& curr_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); GWBUF* add_prefix_wait_gtid(SERVER* server, GWBUF* origin);
void correct_packet_sequence(GWBUF* buffer); void correct_packet_sequence(GWBUF* buffer);
GWBUF* discard_master_wait_gtid_result(GWBUF* buffer); GWBUF* discard_master_wait_gtid_result(GWBUF* buffer);
int get_max_replication_lag(); 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); void handle_error_reply_client(DCB* backend_dcb, GWBUF* errmsg);
bool handle_error_new_connection(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(); void trx_replay_next_stmt();