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

MXS-2196: Rename dcb_role_t to DCB::Role

Browse Source
This commit is contained in:
Markus Mäkelä 2018-12-04 12:02:10 +02:00
parent 0b9241913c
commit 77477d9648
No known key found for this signature in database
GPG Key ID: 72D48FCE664F7B19
21 changed files with 93 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
examples/roundrobinrouter.cpp
View File

@ -363,7 +363,7 @@ void RRRouter::handle_error(RRRouterSession* rses,
/* If the erroneous dcb is a client handler, close it. Setting succp to
* false will cause the entire attached session to be closed.
*/
if (problem_dcb->dcb_role == DCB_ROLE_CLIENT_HANDLER)
if (problem_dcb->role == DCB::Role::CLIENT)
{
dcb_close(problem_dcb);
*succp = false;
@ -391,7 +391,7 @@ void RRRouter::handle_error(RRRouterSession* rses,
case ERRACT_NEW_CONNECTION:
{
/* React to a failed backend */
if (problem_dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER)
if (problem_dcb->role == DCB::Role::BACKEND)
{
if (problem_dcb == rses->m_write_dcb)
{

22
include/maxscale/dcb.hh
View File

@ -91,13 +91,6 @@ typedef enum
: \
"DCB_STATE_UNKNOWN"))))))
typedef enum
{
DCB_ROLE_CLIENT_HANDLER, /*< Serves dedicated client */
DCB_ROLE_BACKEND_HANDLER, /*< Serves back end connection */
DCB_ROLE_INTERNAL /*< Internal DCB not connected to the outside */
} dcb_role_t;
/**
* Callback reasons for the DCB callback mechanism.
*/
@ -151,7 +144,14 @@ typedef enum
*/
struct DCB : public MXB_POLL_DATA
{
DCB(dcb_role_t role, MXS_SESSION*);
enum class Role
{
CLIENT, /*< Serves dedicated client */
BACKEND, /*< Serves back end connection */
INTERNAL /*< Internal DCB not connected to the outside */
};
DCB(Role role, MXS_SESSION*);
~DCB();
/**
@ -160,7 +160,7 @@ struct DCB : public MXB_POLL_DATA
const char* type();
bool dcb_errhandle_called = false; /**< this can be called only once */
dcb_role_t dcb_role;
Role role;
int fd = DCBFD_CLOSED; /**< The descriptor */
dcb_state_t state = DCB_STATE_ALLOC; /**< Current descriptor state */
SSL_STATE ssl_state = SSL_HANDSHAKE_UNKNOWN; /**< Current state of SSL if in use */
@ -239,8 +239,8 @@ typedef enum
*/
void dcb_global_init();
int dcb_write(DCB*, GWBUF*);
DCB* dcb_alloc(dcb_role_t, MXS_SESSION*);
int dcb_write(DCB*, GWBUF*);
DCB* dcb_alloc(DCB::Role, MXS_SESSION*);
DCB* dcb_connect(struct server*, MXS_SESSION*, const char*);
int dcb_read(DCB*, GWBUF**, int);
int dcb_drain_writeq(DCB*);

86
server/core/dcb.cc
View File

@ -140,23 +140,23 @@ uint64_t dcb_get_session_id(DCB* dcb)
return (dcb && dcb->session) ? dcb->session->ses_id : 0;
}
static MXB_WORKER* get_dcb_owner(dcb_role_t role)
static MXB_WORKER* get_dcb_owner()
{
/** The DCB is owned by the thread that allocates it */
mxb_assert(RoutingWorker::get_current_id() != -1);
return RoutingWorker::get_current();
}
DCB::DCB(dcb_role_t role, MXS_SESSION* session)
: MXB_POLL_DATA{dcb_poll_handler, get_dcb_owner(role)}
, dcb_role(role)
DCB::DCB(Role role, MXS_SESSION* session)
: MXB_POLL_DATA{dcb_poll_handler, get_dcb_owner()}
, role(role)
, session(session)
, high_water(config_writeq_high_water())
, low_water(config_writeq_low_water())
, service(session->service)
, last_read(mxs_clock())
{
// TODO: Remove DCB_ROLE_INTERNAL to always have a valid listener
// TODO: Remove DCB::Role::INTERNAL to always have a valid listener
if (session->listener)
{
func = session->listener->protocol_func();
@ -220,7 +220,7 @@ DCB::~DCB()
*
* @return An available DCB or NULL if none could be allocated.
*/
DCB* dcb_alloc(dcb_role_t role, MXS_SESSION* session)
DCB* dcb_alloc(DCB::Role role, MXS_SESSION* session)
{
return new(std::nothrow) DCB(role, session);
}
@ -232,8 +232,7 @@ DCB* dcb_alloc(dcb_role_t role, MXS_SESSION* session)
*/
static void dcb_final_free(DCB* dcb)
{
mxb_assert_message(dcb->state == DCB_STATE_DISCONNECTED
|| dcb->state == DCB_STATE_ALLOC,
mxb_assert_message(dcb->state == DCB_STATE_DISCONNECTED || dcb->state == DCB_STATE_ALLOC,
"dcb not in DCB_STATE_DISCONNECTED not in DCB_STATE_ALLOC state.");
if (dcb->session)
@ -243,7 +242,7 @@ static void dcb_final_free(DCB* dcb)
*/
MXS_SESSION* local_session = dcb->session;
dcb->session = NULL;
if (dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER)
if (dcb->role == DCB::Role::BACKEND)
{
session_unlink_backend_dcb(local_session, dcb);
}
@ -256,7 +255,7 @@ static void dcb_final_free(DCB* dcb)
* been closed.
*/
mxb_assert(dcb->dcb_role == DCB_ROLE_CLIENT_HANDLER || dcb->dcb_role == DCB_ROLE_INTERNAL);
mxb_assert(dcb->role == DCB::Role::CLIENT || dcb->role == DCB::Role::INTERNAL);
session_put_ref(local_session);
return;
}
@ -350,7 +349,7 @@ DCB* dcb_connect(SERVER* server, MXS_SESSION* session, const char* protocol)
}
}
if ((dcb = dcb_alloc(DCB_ROLE_BACKEND_HANDLER, session)) == NULL)
if ((dcb = dcb_alloc(DCB::Role::BACKEND, session)) == NULL)
{
return NULL;
}
@ -599,7 +598,7 @@ static int dcb_bytes_readable(DCB* dcb)
static int dcb_read_no_bytes_available(DCB* dcb, int nreadtotal)
{
/** Handle closed client socket */
if (nreadtotal == 0 && DCB_ROLE_CLIENT_HANDLER == dcb->dcb_role)
if (nreadtotal == 0 && DCB::Role::CLIENT == dcb->role)
{
char c;
int l_errno = 0;
@ -998,17 +997,17 @@ static void log_illegal_dcb(DCB* dcb)
{
const char* connected_to;
switch (dcb->dcb_role)
switch (dcb->role)
{
case DCB_ROLE_BACKEND_HANDLER:
case DCB::Role::BACKEND:
connected_to = dcb->server->name;
break;
case DCB_ROLE_CLIENT_HANDLER:
case DCB::Role::CLIENT:
connected_to = dcb->remote;
break;
case DCB_ROLE_INTERNAL:
case DCB::Role::INTERNAL:
connected_to = "Internal DCB";
break;
@ -1138,11 +1137,11 @@ void dcb_final_close(DCB* dcb)
#endif
mxb_assert(dcb->n_close != 0);
if (dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER // Backend DCB
&& dcb->state == DCB_STATE_POLLING // Being polled
&& dcb->persistentstart == 0 /** Not already in (> 0) or being evicted from (-1)
* the persistent pool. */
&& dcb->server) // And has a server
if (dcb->role == DCB::Role::BACKEND // Backend DCB
&& dcb->state == DCB_STATE_POLLING // Being polled
&& dcb->persistentstart == 0 /** Not already in (> 0) or being evicted from (-1)
* the persistent pool. */
&& dcb->server) // And has a server
{
/* May be a candidate for persistence, so save user name */
const char* user;
@ -1167,7 +1166,7 @@ void dcb_final_close(DCB* dcb)
if (dcb->server)
{
// This is now a DCB_ROLE_BACKEND_HANDLER.
// This is now a DCB::Role::BACKEND_HANDLER.
// TODO: Make decisions according to the role and assert
// TODO: that what the role implies is preset.
mxb::atomic::add(&dcb->server->stats.n_current, -1, mxb::atomic::RELAXED);
@ -1197,7 +1196,7 @@ void dcb_final_close(DCB* dcb)
else
{
// Only internal DCBs are closed with a fd of -1
mxb_assert(dcb->dcb_role == DCB_ROLE_INTERNAL);
mxb_assert(dcb->role == DCB::Role::INTERNAL);
}
dcb->state = DCB_STATE_DISCONNECTED;
@ -1483,7 +1482,7 @@ static bool dlist_clients_cb(DCB* dcb, void* data)
{
DCB* pdcb = (DCB*)data;
if (dcb->dcb_role == DCB_ROLE_CLIENT_HANDLER)
if (dcb->role == DCB::Role::CLIENT)
{
dcb_printf(pdcb,
" %-15s | %16p | %-20s | %10p\n",
@ -2031,7 +2030,7 @@ bool count_by_usage_cb(DCB* dcb, void* data)
switch (d->type)
{
case DCB_USAGE_CLIENT:
if (DCB_ROLE_CLIENT_HANDLER == dcb->dcb_role)
if (DCB::Role::CLIENT == dcb->role)
{
d->count++;
}
@ -2045,15 +2044,15 @@ bool count_by_usage_cb(DCB* dcb, void* data)
break;
case DCB_USAGE_BACKEND:
if (dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER)
if (dcb->role == DCB::Role::BACKEND)
{
d->count++;
}
break;
case DCB_USAGE_INTERNAL:
if (dcb->dcb_role == DCB_ROLE_CLIENT_HANDLER
|| dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER)
if (dcb->role == DCB::Role::CLIENT
|| dcb->role == DCB::Role::BACKEND)
{
d->count++;
}
@ -2305,15 +2304,15 @@ char* dcb_role_name(DCB* dcb)
if (name)
{
name[0] = 0;
if (DCB_ROLE_CLIENT_HANDLER == dcb->dcb_role)
if (DCB::Role::CLIENT == dcb->role)
{
strcat(name, "Client Request Handler");
}
else if (DCB_ROLE_BACKEND_HANDLER == dcb->dcb_role)
else if (DCB::Role::BACKEND == dcb->role)
{
strcat(name, "Backend Request Handler");
}
else if (DCB_ROLE_INTERNAL == dcb->dcb_role)
else if (DCB::Role::INTERNAL == dcb->role)
{
strcat(name, "Internal");
}
@ -2432,7 +2431,7 @@ void dcb_process_idle_sessions(int thr)
for (DCB* dcb = this_unit.all_dcbs[thr]; dcb; dcb = dcb->thread.next)
{
if (dcb->dcb_role == DCB_ROLE_CLIENT_HANDLER)
if (dcb->role == DCB::Role::CLIENT)
{
SERVICE* service = dcb->session->service;
@ -2621,7 +2620,7 @@ static uint32_t dcb_process_poll_events(DCB* dcb, uint32_t events)
* until it return 1 for success or -1 for error */
if (dcb->ssl_state == SSL_HANDSHAKE_REQUIRED)
{
return_code = (DCB_ROLE_CLIENT_HANDLER == dcb->dcb_role) ?
return_code = (DCB::Role::CLIENT == dcb->role) ?
dcb_accept_SSL(dcb) :
dcb_connect_SSL(dcb);
}
@ -3046,7 +3045,7 @@ int poll_add_dcb(DCB* dcb)
dcb_state_t new_state;
RoutingWorker* owner = nullptr;
if (dcb->dcb_role == DCB_ROLE_CLIENT_HANDLER)
if (dcb->role == DCB::Role::CLIENT)
{
if (strcasecmp(dcb->service->routerModule, "cli") == 0
|| strcasecmp(dcb->service->routerModule, "maxinfo") == 0)
@ -3074,7 +3073,7 @@ int poll_add_dcb(DCB* dcb)
}
else
{
mxb_assert(dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER);
mxb_assert(dcb->role == DCB::Role::BACKEND);
mxb_assert(RoutingWorker::get_current_id() != -1);
mxb_assert(RoutingWorker::get_current() == dcb->owner);
@ -3135,7 +3134,7 @@ int poll_remove_dcb(DCB* dcb)
* Only positive fds can be removed from epoll set.
*/
dcbfd = dcb->fd;
mxb_assert(dcbfd > 0 || dcb->dcb_role == DCB_ROLE_INTERNAL);
mxb_assert(dcbfd > 0 || dcb->role == DCB::Role::INTERNAL);
if (dcbfd > 0)
{
@ -3188,7 +3187,7 @@ bool backend_dcb_remove_func(DCB* dcb, void* data)
{
MXS_SESSION* session = (MXS_SESSION*)data;
if (dcb->session == session && dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER)
if (dcb->session == session && dcb->role == DCB::Role::BACKEND)
{
poll_remove_dcb(dcb);
}
@ -3200,7 +3199,7 @@ bool backend_dcb_add_func(DCB* dcb, void* data)
{
MXS_SESSION* session = (MXS_SESSION*)data;
if (dcb->session == session && dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER)
if (dcb->session == session && dcb->role == DCB::Role::BACKEND)
{
poll_add_dcb(dcb);
}
@ -3255,14 +3254,17 @@ json_t* dcb_to_json(DCB* dcb)
const char* DCB::type()
{
switch (dcb_role)
switch (role)
{
case DCB_ROLE_CLIENT_HANDLER:
case DCB::Role::CLIENT:
return "Client DCB";
case DCB_ROLE_BACKEND_HANDLER:
case DCB::Role::BACKEND:
return "Backend DCB";
case DCB_ROLE_INTERNAL:
case DCB::Role::INTERNAL:
return "Internal DCB";
default:
mxb_assert(!true);
return "Unknown DCB";

3
server/core/listener.cc
View File

@ -852,7 +852,6 @@ static int accept_one_connection(int fd, struct sockaddr* client_conn)
return client_fd;
}
}
DCB* Listener::accept_one_dcb()
@ -866,7 +865,7 @@ DCB* Listener::accept_one_dcb()
configure_network_socket(c_sock, client_conn.ss_family);
mxs::Session* session = new(std::nothrow) mxs::Session(m_self);
client_dcb = dcb_alloc(DCB_ROLE_CLIENT_HANDLER, session);
client_dcb = dcb_alloc(DCB::Role::CLIENT, session);
if (!session || !client_dcb)
{

26
server/core/session.cc
View File

@ -59,8 +59,8 @@ struct
/* Global session id counter. Must be updated atomically. Value 0 is reserved for
* dummy/unused sessions.
*/
uint64_t next_session_id;
uint32_t retain_last_statements;
uint64_t next_session_id;
uint32_t retain_last_statements;
session_dump_statements_t dump_statements;
} this_unit =
{
@ -68,7 +68,6 @@ struct
0,
SESSION_DUMP_STATEMENTS_NEVER
};
}
static void session_initialize(void* session);
@ -171,7 +170,7 @@ bool session_start(MXS_SESSION* session)
void session_link_backend_dcb(MXS_SESSION* session, DCB* dcb)
{
mxb_assert(dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER);
mxb_assert(dcb->role == DCB::Role::BACKEND);
mxb::atomic::add(&session->refcount, 1);
dcb->session = session;
@ -329,7 +328,7 @@ void printSession(MXS_SESSION* session)
bool printAllSessions_cb(DCB* dcb, void* data)
{
if (dcb->dcb_role == DCB_ROLE_CLIENT_HANDLER)
if (dcb->role == DCB::Role::CLIENT)
{
printSession(dcb->session);
}
@ -351,7 +350,7 @@ void printAllSessions()
/** Callback for dprintAllSessions */
bool dprintAllSessions_cb(DCB* dcb, void* data)
{
if (dcb->dcb_role == DCB_ROLE_CLIENT_HANDLER)
if (dcb->role == DCB::Role::CLIENT)
{
DCB* out_dcb = (DCB*)data;
dprintSession(out_dcb, dcb->session);
@ -420,7 +419,7 @@ void dprintSession(DCB* dcb, MXS_SESSION* print_session)
bool dListSessions_cb(DCB* dcb, void* data)
{
if (dcb->dcb_role == DCB_ROLE_CLIENT_HANDLER)
if (dcb->role == DCB::Role::CLIENT)
{
DCB* out_dcb = (DCB*)data;
MXS_SESSION* session = dcb->session;
@ -605,7 +604,7 @@ const char* session_get_user(const MXS_SESSION* session)
bool dcb_iter_cb(DCB* dcb, void* data)
{
if (dcb->dcb_role == DCB_ROLE_CLIENT_HANDLER)
if (dcb->role == DCB::Role::CLIENT)
{
ResultSet* set = static_cast<ResultSet*>(data);
MXS_SESSION* ses = dcb->session;
@ -825,7 +824,7 @@ struct SessionListData
bool seslist_cb(DCB* dcb, void* data)
{
if (dcb->dcb_role == DCB_ROLE_CLIENT_HANDLER)
if (dcb->role == DCB::Role::CLIENT)
{
SessionListData* d = (SessionListData*)data;
Session* session = static_cast<Session*>(dcb->session);
@ -1122,7 +1121,7 @@ Session::~Session()
void Session::set_client_dcb(DCB* dcb)
{
mxb_assert(client_dcb == nullptr);
mxb_assert(dcb->dcb_role == DCB_ROLE_CLIENT_HANDLER);
mxb_assert(dcb->role == DCB::Role::CLIENT);
client_dcb = dcb;
}
@ -1187,7 +1186,7 @@ void Session::dump_statements() const
if ((id != 0) && (id != ses_id))
{
MXS_WARNING("Current session is %" PRIu64 ", yet statements are dumped for %" PRIu64 ". "
"The session id in the subsequent dumped statements is the wrong one.",
"The session id in the subsequent dumped statements is the wrong one.",
id,
ses_id);
}
@ -1502,7 +1501,6 @@ void timespec_to_iso(char* zIso, const timespec& ts)
i = sprintf(zIso + i, ".%03ld", ts.tv_nsec / 1000000);
mxb_assert(i == 4);
}
}
json_t* Session::QueryInfo::as_json() const
@ -1570,8 +1568,8 @@ void Session::QueryInfo::book_server_response(SERVER* pServer, bool final_respon
mxb_assert(!m_complete);
// A particular server may be reported only exactly once.
mxb_assert(find_if(m_server_infos.begin(), m_server_infos.end(), [pServer](const ServerInfo& info) {
return info.pServer == pServer;
}) == m_server_infos.end());
return info.pServer == pServer;
}) == m_server_infos.end());
timespec now;
clock_gettime(CLOCK_REALTIME_COARSE, &now);

4
server/core/test/test_dcb.cc
View File

@ -49,11 +49,11 @@ static int test1()
{
DCB* dcb;
/* Single buffer tests */
fprintf(stderr, "testdcb : creating buffer with type DCB_ROLE_INTERNAL");
fprintf(stderr, "testdcb : creating buffer with type DCB::Role::INTERNAL");
auto service = service_alloc("service", "readconnroute", nullptr);
auto listener = Listener::create(service, "listener", "mariadbclient", "0.0.0.0", 3306, "", "", nullptr);
auto session = new mxs::Session(listener);
dcb = dcb_alloc(DCB_ROLE_INTERNAL, session);
dcb = dcb_alloc(DCB::Role::INTERNAL, session);
printDCB(dcb);
fprintf(stderr, "\t..done\nAllocated dcb.");
// TODO: Without running workers, the following will hang. As it does not

2
server/core/test/test_poll.cc
View File

@ -60,7 +60,7 @@ static int test1()
auto service = service_alloc("service", "readconnroute", nullptr);
auto listener = Listener::create(service, "listener", "mariadbclient", "0.0.0.0", 3306, "", "", nullptr);
auto session = new mxs::Session(listener);
dcb = dcb_alloc(DCB_ROLE_CLIENT_HANDLER, session);
dcb = dcb_alloc(DCB::Role::CLIENT, session);
if (dcb == NULL)
{

2
server/modules/filter/test/mock_backend.cc
View File

@ -174,7 +174,7 @@ class ResultSetDCB : public DCB
{
public:
ResultSetDCB(MXS_SESSION* session)
: DCB(DCB_ROLE_CLIENT_HANDLER, session)
: DCB(DCB::Role::CLIENT, session)
{
DCB* pDcb = this;

2
server/modules/filter/test/mock_dcb.cc
View File

@ -34,7 +34,7 @@ Dcb::Dcb(MXS_SESSION* pSession,
const char* zUser,
const char* zHost,
Handler* pHandler)
: DCB(DCB_ROLE_CLIENT_HANDLER, pSession)
: DCB(DCB::Role::CLIENT, pSession)
, m_user(zUser)
, m_host(zHost)
, m_pHandler(pHandler)

6
server/modules/protocol/MySQL/mariadbbackend/mysql_backend.cc
View File

@ -401,7 +401,7 @@ static inline void prepare_for_write(DCB* dcb, GWBUF* buffer)
{
MySQLProtocol* proto = (MySQLProtocol*)dcb->protocol;
// The DCB's session is set to null when it is put into the persistent connection pool.
// The DCB's session is set to null when it is put into the persistent connection pool.
if (dcb->session)
{
uint64_t capabilities = service_get_capabilities(dcb->session->service);
@ -645,7 +645,7 @@ static inline bool session_ok_to_route(DCB* dcb)
rval = true;
}
}
else if (dcb->session->client_dcb->dcb_role == DCB_ROLE_INTERNAL)
else if (dcb->session->client_dcb->role == DCB::Role::INTERNAL)
{
rval = true;
}
@ -1351,7 +1351,7 @@ static int gw_backend_hangup(DCB* dcb)
if (error != 0 && session->state != SESSION_STATE_STOPPING)
{
MXS_ERROR("Hangup in session that is not ready for routing, "
"Error reported is '%s'.",
"Error reported is '%s'.",
mxs_strerror(errno));
}
}

2
server/modules/protocol/MySQL/mariadbclient/mysql_client.cc
View File

@ -456,7 +456,7 @@ int gw_read_client_event(DCB* dcb)
uint32_t nbytes_read = 0;
uint32_t max_bytes = 0;
if (dcb->dcb_role != DCB_ROLE_CLIENT_HANDLER)
if (dcb->role != DCB::Role::CLIENT)
{
MXS_ERROR("DCB must be a client handler for MySQL client protocol.");
return 1;

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

@ -590,7 +590,7 @@ bool gw_get_shared_session_auth_info(DCB* dcb, MYSQL_session* session)
{
bool rval = true;
if (dcb->dcb_role == DCB_ROLE_CLIENT_HANDLER)
if (dcb->role == DCB::Role::CLIENT)
{
// The shared session data can be extracted at any time if the client DCB is used.
mxb_assert(dcb->data);
@ -1385,7 +1385,7 @@ static bool kill_func(DCB* dcb, void* data)
{
ConnKillInfo* info = static_cast<ConnKillInfo*>(data);
if (dcb->session->ses_id == info->target_id && dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER)
if (dcb->session->ses_id == info->target_id && dcb->role == DCB::Role::BACKEND)
{
MySQLProtocol* proto = (MySQLProtocol*)dcb->protocol;
@ -1411,7 +1411,7 @@ static bool kill_user_func(DCB* dcb, void* data)
{
UserKillInfo* info = (UserKillInfo*)data;
if (dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER
if (dcb->role == DCB::Role::BACKEND
&& strcasecmp(dcb->session->client_dcb->user, info->user.c_str()) == 0)
{
info->targets[dcb->server] = info->query_base;

2
server/modules/routing/avrorouter/avro_file.cc
View File

@ -375,7 +375,7 @@ bool notify_cb(DCB* dcb, void* data)
{
SERVICE* service = static_cast<SERVICE*>(data);
if (dcb->service == service && dcb->dcb_role == DCB_ROLE_CLIENT_HANDLER)
if (dcb->service == service && dcb->role == DCB::Role::CLIENT)
{
poll_fake_write_event(dcb);
}

2
server/modules/routing/binlogrouter/blr.cc
View File

@ -2374,7 +2374,7 @@ static void errorReply(MXS_ROUTER* instance,
mxs_error_action_t action,
bool* succp)
{
mxb_assert(backend_dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER);
mxb_assert(backend_dcb->role == DCB::Role::BACKEND);
ROUTER_INSTANCE* router = (ROUTER_INSTANCE*)instance;
int error;
socklen_t len;

2
server/modules/routing/binlogrouter/blr_master.cc
View File

@ -189,7 +189,7 @@ static void blr_start_master(void* data)
pthread_mutex_unlock(&router->lock);
// TODO: Fix this
DCB* client = dcb_alloc(DCB_ROLE_INTERNAL, NULL);
DCB* client = dcb_alloc(DCB::Role::INTERNAL, NULL);
/* Create fake 'client' DCB */
if (client == NULL)

2
server/modules/routing/hintrouter/hintroutersession.cc
View File

@ -158,7 +158,7 @@ void HintRouterSession::handleError(GWBUF* pMessage,
{
HR_ENTRY();
mxb_assert(pProblem->dcb_role == DCB_ROLE_BACKEND_HANDLER);
mxb_assert(pProblem->role == DCB::Role::BACKEND);
MXS_SESSION* pSession = pProblem->session;
mxs_session_state_t sesstate = pSession->state;

2
server/modules/routing/maxinfo/maxinfo.cc
View File

@ -269,7 +269,7 @@ static void handleError(MXS_ROUTER* instance,
bool* succp)
{
mxb_assert(backend_dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER);
mxb_assert(backend_dcb->role == DCB::Role::BACKEND);
DCB* client_dcb;
MXS_SESSION* session = backend_dcb->session;

2
server/modules/routing/readconnroute/readconnroute.cc
View File

@ -710,7 +710,7 @@ static void handleError(MXS_ROUTER* instance,
bool* succp)
{
mxb_assert(problem_dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER);
mxb_assert(problem_dcb->role == DCB::Role::BACKEND);
mxb_assert(problem_dcb->session->state == SESSION_STATE_ROUTER_READY);
DCB* client_dcb = problem_dcb->session->client_dcb;
client_dcb->func.write(client_dcb, gwbuf_clone(errbuf));

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

@ -858,9 +858,9 @@ void RWSplitSession::log_master_routing_failure(bool found,
/** Both backends should either be empty, not connected or the DCB should
* be a backend (the last check is slightly redundant). */
mxb_assert(!old_master || !old_master->in_use()
|| old_master->dcb()->dcb_role == DCB_ROLE_BACKEND_HANDLER);
|| old_master->dcb()->role == DCB::Role::BACKEND);
mxb_assert(!curr_master || !curr_master->in_use()
|| curr_master->dcb()->dcb_role == DCB_ROLE_BACKEND_HANDLER);
|| curr_master->dcb()->role == DCB::Role::BACKEND);
char errmsg[MAX_SERVER_ADDRESS_LEN * 2 + 100]; // Extra space for error message
if (m_config.delayed_retry && m_retry_duration >= m_config.delayed_retry_timeout)

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

@ -311,7 +311,7 @@ GWBUF* RWSplitSession::discard_master_wait_gtid_result(GWBUF* buffer)
*/
RWBackend* RWSplitSession::get_backend_from_dcb(DCB* dcb)
{
mxb_assert(dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER);
mxb_assert(dcb->role == DCB::Role::BACKEND);
for (auto it = m_raw_backends.begin(); it != m_raw_backends.end(); it++)
{
@ -866,7 +866,7 @@ void RWSplitSession::handleError(GWBUF* errmsgbuf,
mxs_error_action_t action,
bool* succp)
{
mxb_assert(problem_dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER);
mxb_assert(problem_dcb->role == DCB::Role::BACKEND);
MXS_SESSION* session = problem_dcb->session;
mxb_assert(session);

2
server/modules/routing/schemarouter/schemaroutersession.cc
View File

@ -616,7 +616,7 @@ void SchemaRouterSession::handleError(GWBUF* pMessage,
mxs_error_action_t action,
bool* pSuccess)
{
mxb_assert(pProblem->dcb_role == DCB_ROLE_BACKEND_HANDLER);
mxb_assert(pProblem->role == DCB::Role::BACKEND);
SSRBackend bref = get_bref_from_dcb(pProblem);
if (bref.get() == NULL) // Should never happen