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

MXS-2020 Replace ss[_info]_dassert with mxb_assert[_message]

Browse Source
This commit is contained in:
Johan Wikman
2018-08-22 09:59:02 +03:00
parent b1e405442f
commit 3f53eddbde
161 changed files with 1640 additions and 1643 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
server/modules/protocol/MySQL/mariadb_client.cc
View File

@ -72,7 +72,7 @@ void LocalClient::self_destruct()
void LocalClient::close()
{
mxb::Worker* worker = mxb::Worker::get_current();
ss_dassert(worker);
mxb_assert(worker);
worker->remove_fd(m_sock);
::close(m_sock);
}

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

@ -162,7 +162,7 @@ static int gw_create_backend_connection(DCB *backend_dcb,
int fd = -1;
protocol = mysql_protocol_init(backend_dcb, -1);
ss_dassert(protocol != NULL);
mxb_assert(protocol != NULL);
if (protocol == NULL)
{
@ -194,7 +194,7 @@ static int gw_create_backend_connection(DCB *backend_dcb,
switch (rv)
{
case 0:
ss_dassert(fd > 0);
mxb_assert(fd > 0);
protocol->fd = fd;
protocol->protocol_auth_state = MXS_AUTH_STATE_CONNECTED;
MXS_DEBUG("Established "
@ -215,7 +215,7 @@ static int gw_create_backend_connection(DCB *backend_dcb,
/* The state MYSQL_PENDING_CONNECT is likely to be transitory, */
/* as it means the calls have been successful but the connection */
/* has not yet completed and the calls are non-blocking. */
ss_dassert(fd > 0);
mxb_assert(fd > 0);
protocol->protocol_auth_state = MXS_AUTH_STATE_PENDING_CONNECT;
protocol->fd = fd;
MXS_DEBUG("Connection "
@ -228,8 +228,8 @@ static int gw_create_backend_connection(DCB *backend_dcb,
default:
/* Failure - the state reverts to its initial value */
ss_dassert(fd == -1);
ss_dassert(protocol->protocol_auth_state == MXS_AUTH_STATE_INIT);
mxb_assert(fd == -1);
mxb_assert(protocol->protocol_auth_state == MXS_AUTH_STATE_INIT);
break;
} /*< switch */
@ -667,7 +667,7 @@ static inline bool expecting_ps_response(MySQLProtocol *proto)
static inline bool complete_ps_response(GWBUF *buffer)
{
ss_dassert(GWBUF_IS_CONTIGUOUS(buffer));
mxb_assert(GWBUF_IS_CONTIGUOUS(buffer));
MXS_PS_RESPONSE resp;
bool rval = false;
@ -781,12 +781,12 @@ gw_read_and_write(DCB *dcb)
nbytes_read = gwbuf_length(read_buffer);
if (nbytes_read == 0)
{
ss_dassert(read_buffer == NULL);
mxb_assert(read_buffer == NULL);
return return_code;
}
else
{
ss_dassert(read_buffer != NULL);
mxb_assert(read_buffer != NULL);
}
/** Ask what type of output the router/filter chain expects */
@ -906,7 +906,7 @@ gw_read_and_write(DCB *dcb)
GWBUF *query = proto->stored_query;
proto->stored_query = NULL;
proto->ignore_replies--;
ss_dassert(proto->ignore_replies >= 0);
mxb_assert(proto->ignore_replies >= 0);
GWBUF* reply = modutil_get_next_MySQL_packet(&read_buffer);
while (read_buffer)
@ -916,8 +916,8 @@ gw_read_and_write(DCB *dcb)
reply = modutil_get_next_MySQL_packet(&read_buffer);
}
ss_dassert(reply);
ss_dassert(!read_buffer);
mxb_assert(reply);
mxb_assert(!read_buffer);
uint8_t result = MYSQL_GET_COMMAND(GWBUF_DATA(reply));
int rval = 0;
@ -1107,13 +1107,13 @@ static int gw_MySQLWrite_backend(DCB *dcb, GWBUF *queue)
if (dcb->was_persistent)
{
ss_dassert(!dcb->fakeq);
ss_dassert(!dcb->readq);
ss_dassert(!dcb->delayq);
ss_dassert(!dcb->writeq);
ss_dassert(dcb->persistentstart == 0);
mxb_assert(!dcb->fakeq);
mxb_assert(!dcb->readq);
mxb_assert(!dcb->delayq);
mxb_assert(!dcb->writeq);
mxb_assert(dcb->persistentstart == 0);
dcb->was_persistent = false;
ss_dassert(backend_protocol->ignore_replies >= 0);
mxb_assert(backend_protocol->ignore_replies >= 0);
backend_protocol->ignore_replies = 0;
if (dcb->state != DCB_STATE_POLLING ||
@ -1240,7 +1240,7 @@ static int gw_MySQLWrite_backend(DCB *dcb, GWBUF *queue)
{
/** The response to this command should be ignored */
backend_protocol->ignore_replies++;
ss_dassert(backend_protocol->ignore_replies > 0);
mxb_assert(backend_protocol->ignore_replies > 0);
}
/** Write to backend */
@ -1359,7 +1359,7 @@ static int gw_backend_hangup(DCB *dcb)
*/
static int gw_backend_close(DCB *dcb)
{
ss_dassert(dcb->session);
mxb_assert(dcb->session);
/** Send COM_QUIT to the backend being closed */
GWBUF* quitbuf = mysql_create_com_quit(NULL, 0);
@ -1409,9 +1409,9 @@ static void backend_set_delayqueue(DCB *dcb, GWBUF *queue)
*/
static int backend_write_delayqueue(DCB *dcb, GWBUF *buffer)
{
ss_dassert(buffer);
ss_dassert(dcb->persistentstart == 0);
ss_dassert(!dcb->was_persistent);
mxb_assert(buffer);
mxb_assert(dcb->persistentstart == 0);
mxb_assert(!dcb->was_persistent);
if (MYSQL_IS_CHANGE_USER(((uint8_t *)GWBUF_DATA(buffer))))
{
@ -1499,7 +1499,7 @@ static int gw_change_user(DCB *backend,
if (auth_token_len > 0)
{
auth_token = (uint8_t *)MXS_MALLOC(auth_token_len);
ss_dassert(auth_token != NULL);
mxb_assert(auth_token != NULL);
if (auth_token == NULL)
{
@ -1865,7 +1865,7 @@ static void gw_send_proxy_protocol_header(DCB *backend_dcb)
MXS_ERROR("'%s' failed on file descriptor '%d'.", "getsockname()", client_fd);
return;
}
ss_dassert(sa_peer.ss_family == sa_local.ss_family);
mxb_assert(sa_peer.ss_family == sa_local.ss_family);
char peer_ip[INET6_ADDRSTRLEN];
char maxscale_ip[INET6_ADDRSTRLEN];

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

@ -285,7 +285,7 @@ int MySQLSendHandshake(DCB* dcb)
// allocate memory for packet header + payload
if ((buf = gwbuf_alloc(sizeof(mysql_packet_header) + mysql_payload_size)) == NULL)
{
ss_dassert(buf != NULL);
mxb_assert(buf != NULL);
return 0;
}
outbuf = GWBUF_DATA(buf);
@ -356,7 +356,7 @@ int MySQLSendHandshake(DCB* dcb)
mysql_server_capabilities_two[1] = (uint8_t)(GW_MYSQL_CAPABILITIES_SERVER >> 24);
// Check that we match the old values
ss_dassert(mysql_server_capabilities_two[0] == 15);
mxb_assert(mysql_server_capabilities_two[0] == 15);
/** NOTE: pre-2.1 versions sent the fourth byte of the capabilities as
the value 128 even though there's no such capability. */
@ -565,7 +565,7 @@ static void store_client_information(DCB *dcb, GWBUF *buffer)
MYSQL_session *ses = (MYSQL_session*)dcb->data;
gwbuf_copy_data(buffer, 0, len, data);
ss_dassert(MYSQL_GET_PAYLOAD_LEN(data) + MYSQL_HEADER_LEN == len ||
mxb_assert(MYSQL_GET_PAYLOAD_LEN(data) + MYSQL_HEADER_LEN == len ||
len == MYSQL_AUTH_PACKET_BASE_SIZE); // For SSL request packet
proto->client_capabilities = gw_mysql_get_byte4(data + MYSQL_CLIENT_CAP_OFFSET);
@ -626,7 +626,7 @@ static void store_client_information(DCB *dcb, GWBUF *buffer)
static void check_packet(DCB *dcb, GWBUF *buf, int bytes)
{
uint8_t hdr[MYSQL_HEADER_LEN];
ss_dassert(gwbuf_copy_data(buf, 0, MYSQL_HEADER_LEN, hdr) == MYSQL_HEADER_LEN);
mxb_assert(gwbuf_copy_data(buf, 0, MYSQL_HEADER_LEN, hdr) == MYSQL_HEADER_LEN);
int buflen = gwbuf_length(buf);
int pktlen = MYSQL_GET_PAYLOAD_LEN(hdr) + MYSQL_HEADER_LEN;
@ -634,13 +634,13 @@ static void check_packet(DCB *dcb, GWBUF *buf, int bytes)
if (bytes == MYSQL_AUTH_PACKET_BASE_SIZE)
{
/** This is an SSL request packet */
ss_dassert(dcb->listener->ssl);
ss_dassert(buflen == bytes && pktlen >= buflen);
mxb_assert(dcb->listener->ssl);
mxb_assert(buflen == bytes && pktlen >= buflen);
}
else
{
/** Normal packet */
ss_dassert(buflen == pktlen);
mxb_assert(buflen == pktlen);
}
}
@ -738,13 +738,13 @@ gw_read_do_authentication(DCB *dcb, GWBUF *read_buffer, int nbytes_read)
if (session != NULL)
{
ss_dassert(session->state != SESSION_STATE_ALLOC &&
mxb_assert(session->state != SESSION_STATE_ALLOC &&
session->state != SESSION_STATE_DUMMY);
// For the time being only the sql_mode is stored in MXS_SESSION::client_protocol_data.
session->client_protocol_data = QC_SQL_MODE_DEFAULT;
protocol->protocol_auth_state = MXS_AUTH_STATE_COMPLETE;
MXB_AT_DEBUG(bool check = ) mxs_rworker_register_session(session);
ss_dassert(check);
mxb_assert(check);
mxs_mysql_send_ok(dcb, next_sequence, 0, NULL);
if (dcb->readq)
@ -853,7 +853,7 @@ static bool process_client_commands(DCB* dcb, int bytes_available, GWBUF** buffe
if (gwbuf_copy_data(queue, offset, MYSQL_HEADER_LEN, packet_header) != MYSQL_HEADER_LEN)
{
ss_dassert(offset > 0);
mxb_assert(offset > 0);
queue = split_and_store(dcb, queue, offset);
break;
}
@ -869,10 +869,10 @@ static bool process_client_commands(DCB* dcb, int bytes_available, GWBUF** buffe
{
if ((queue = split_and_store(dcb, queue, offset)) == NULL)
{
ss_dassert(bytes_available - offset == MYSQL_HEADER_LEN);
mxb_assert(bytes_available - offset == MYSQL_HEADER_LEN);
return false;
}
ss_dassert(offset > 0);
mxb_assert(offset > 0);
break;
}
@ -893,11 +893,11 @@ static bool process_client_commands(DCB* dcb, int bytes_available, GWBUF** buffe
bytes_available -= packet_bytes;
dcb->protocol_bytes_processed += packet_bytes;
offset += packet_bytes;
ss_dassert(dcb->protocol_bytes_processed <= dcb->protocol_packet_length);
mxb_assert(dcb->protocol_bytes_processed <= dcb->protocol_packet_length);
}
ss_dassert(bytes_available >= 0);
ss_dassert(queue);
mxb_assert(bytes_available >= 0);
mxb_assert(queue);
*buffer = queue;
return true;
}
@ -950,7 +950,7 @@ char* handle_variables(MXS_SESSION* session, GWBUF** read_buffer)
break;
default:
ss_dassert(!true);
mxb_assert(!true);
}
}
}
@ -983,7 +983,7 @@ char* handle_variables(MXS_SESSION* session, GWBUF** read_buffer)
break;
default:
ss_dassert(!true);
mxb_assert(!true);
}
return message;
@ -1109,7 +1109,7 @@ gw_read_normal_data(DCB *dcb, GWBUF *read_buffer, int nbytes_read)
break;
default:
ss_dassert(!true);
mxb_assert(!true);
}
return rval;
}
@ -1194,7 +1194,7 @@ gw_read_finish_processing(DCB *dcb, GWBUF *read_buffer, uint64_t capabilities)
else if (proto->current_command == MXS_COM_QUIT)
{
/** Close router session which causes closing of backends */
ss_info_dassert(session_valid_for_pool(dcb->session), "Session should qualify for pooling");
mxb_assert_message(session_valid_for_pool(dcb->session), "Session should qualify for pooling");
dcb_close(dcb);
}
@ -1304,7 +1304,7 @@ int gw_write_client_event(DCB *dcb)
{
MySQLProtocol *protocol = NULL;
ss_dassert(dcb->state != DCB_STATE_DISCONNECTED);
mxb_assert(dcb->state != DCB_STATE_DISCONNECTED);
if (dcb == NULL)
{
@ -1448,7 +1448,7 @@ retblock:
static int gw_client_close(DCB *dcb)
{
ss_dassert(dcb->protocol);
mxb_assert(dcb->protocol);
if (mysql_protocol_done(dcb))
{
@ -1457,10 +1457,10 @@ static int gw_client_close(DCB *dcb)
if (target->state != SESSION_STATE_TO_BE_FREED &&
target->state != SESSION_STATE_DUMMY)
{
ss_dassert(target->state == SESSION_STATE_ROUTER_READY ||
mxb_assert(target->state == SESSION_STATE_ROUTER_READY ||
target->state == SESSION_STATE_STOPPING);
MXB_AT_DEBUG(bool removed = ) mxs_rworker_deregister_session(target->ses_id);
ss_dassert(removed);
mxb_assert(removed);
session_close(target);
}
}
@ -1626,7 +1626,7 @@ static int route_by_statement(MXS_SESSION* session, uint64_t capabilities, GWBUF
if (rcap_type_required(capabilities, RCAP_TYPE_CONTIGUOUS_INPUT))
{
ss_dassert(GWBUF_IS_CONTIGUOUS(packetbuf));
mxb_assert(GWBUF_IS_CONTIGUOUS(packetbuf));
SERVICE *service = session->client_dcb->service;
if (rcap_type_required(capabilities, RCAP_TYPE_TRANSACTION_TRACKING) && !service->session_track_trx_state)
@ -1695,7 +1695,7 @@ static int route_by_statement(MXS_SESSION* session, uint64_t capabilities, GWBUF
}
else if (proto->changing_user)
{
ss_dassert(proto->current_command == MXS_COM_CHANGE_USER);
mxb_assert(proto->current_command == MXS_COM_CHANGE_USER);
proto->changing_user = false;
bool ok = reauthenticate_client(session, packetbuf);
gwbuf_free(packetbuf);
@ -2002,7 +2002,7 @@ static bool parse_kill_query(char *query, uint64_t *thread_id_out, kill_type_t *
}
else
{
ss_dassert(*endptr_id == '\0' || *endptr_id == ';');
mxb_assert(*endptr_id == '\0' || *endptr_id == ';');
state = SEMICOLON; // In case we have space before ;
get_next = true;
thread_id = l;

6
server/modules/protocol/MySQL/mariadbclient/setparser.hh
View File

@ -97,7 +97,7 @@ public:
GWBUF* pBuffer = *ppBuffer;
ss_dassert(gwbuf_length(pBuffer) >= MYSQL_HEADER_LEN);
mxb_assert(gwbuf_length(pBuffer) >= MYSQL_HEADER_LEN);
size_t buf_len = GWBUF_LENGTH(pBuffer);
size_t payload_len;
@ -218,7 +218,7 @@ public:
return "NOT_RELEVANT";
default:
ss_dassert(!true);
mxb_assert(!true);
return "UNKNOWN";
}
}
@ -244,7 +244,7 @@ private:
status_t initialize(GWBUF* pBuffer)
{
ss_dassert(GWBUF_IS_CONTIGUOUS(pBuffer));
mxb_assert(GWBUF_IS_CONTIGUOUS(pBuffer));
status_t rv = ERROR;

8
server/modules/protocol/MySQL/mariadbclient/setsqlmodeparser.hh
View File

@ -76,7 +76,7 @@ public:
GWBUF* pBuffer = *ppBuffer;
ss_dassert(gwbuf_length(pBuffer) >= MYSQL_HEADER_LEN);
mxb_assert(gwbuf_length(pBuffer) >= MYSQL_HEADER_LEN);
size_t buf_len = GWBUF_LENGTH(pBuffer);
size_t payload_len;
@ -196,7 +196,7 @@ public:
return "SOMETHING";
default:
ss_dassert(!true);
mxb_assert(!true);
return "UNKNOWN";
}
}
@ -222,7 +222,7 @@ public:
return "NOT_SET_SQL_MODE";
default:
ss_dassert(!true);
mxb_assert(!true);
return "UNKNOWN";
}
}
@ -248,7 +248,7 @@ private:
result_t initialize(GWBUF* pBuffer)
{
ss_dassert(GWBUF_IS_CONTIGUOUS(pBuffer));
mxb_assert(GWBUF_IS_CONTIGUOUS(pBuffer));
result_t rv = ERROR;

2
server/modules/protocol/MySQL/mariadbclient/sqlmodeparser.hh
View File

@ -81,7 +81,7 @@ public:
return "SOMETHING";
default:
ss_dassert(!true);
mxb_assert(!true);
return "UNKNOWN";
}
}

6
server/modules/protocol/MySQL/mariadbclient/test/test_setparser.cc
View File

@ -388,7 +388,7 @@ int test(GWBUF** ppStmt, SetParser::status_t expected_status, const TEST_CASE::E
{
const SetParser::Result::Items& variables = result.variables();
const SetParser::Result::Items& values = result.values();
ss_dassert(variables.size() == values.size());
mxb_assert(variables.size() == values.size());
SetParser::Result::Items::const_iterator i = variables.begin();
SetParser::Result::Items::const_iterator j = values.begin();
@ -482,7 +482,7 @@ int test(const TEST_CASE& test_case)
cout << test_case.zStmt << ": ";
GWBUF* pStmt = gwbuf_create_com_query(test_case.zStmt);
ss_dassert(pStmt);
mxb_assert(pStmt);
rv = test(&pStmt, test_case.status, test_case.expectations);
@ -525,7 +525,7 @@ int test_non_contiguous()
cout << test_case.zStmt << "(" << strlen(test_case.zStmt) << ": ";
GWBUF* pTail = gwbuf_create_com_query(test_case.zStmt);
ss_dassert(pTail);
mxb_assert(pTail);
GWBUF* pStmt = NULL;
while (pTail)

4
server/modules/protocol/MySQL/mariadbclient/test/test_setsqlmodeparser.cc
View File

@ -242,7 +242,7 @@ int test(const TEST_CASE& test_case)
cout << test_case.zStmt << ": ";
GWBUF* pStmt = gwbuf_create_com_query(test_case.zStmt);
ss_dassert(pStmt);
mxb_assert(pStmt);
rv = test(&pStmt, test_case.sql_mode, test_case.status);
@ -285,7 +285,7 @@ int test_non_contiguous()
cout << test_case.zStmt << "(" << strlen(test_case.zStmt) << ": ";
GWBUF* pTail = gwbuf_create_com_query(test_case.zStmt);
ss_dassert(pTail);
mxb_assert(pTail);
GWBUF* pStmt = NULL;
while (pTail)

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

@ -47,7 +47,7 @@ MySQLProtocol* mysql_protocol_init(DCB* dcb, int fd)
MySQLProtocol* p;
p = (MySQLProtocol *) MXS_CALLOC(1, sizeof(MySQLProtocol));
ss_dassert(p != NULL);
mxb_assert(p != NULL);
if (p == NULL)
{
@ -134,7 +134,7 @@ GWBUF* mysql_create_com_quit(GWBUF* bufparam,
{
return 0;
}
ss_dassert(GWBUF_LENGTH(buf) == COM_QUIT_PACKET_SIZE);
mxb_assert(GWBUF_LENGTH(buf) == COM_QUIT_PACKET_SIZE);
data = GWBUF_DATA(buf);
@ -154,7 +154,7 @@ int mysql_send_com_quit(DCB* dcb,
GWBUF *buf;
int nbytes = 0;
ss_dassert(packet_number <= 255);
mxb_assert(packet_number <= 255);
if (dcb == NULL)
{
@ -216,7 +216,7 @@ GWBUF* mysql_create_custom_error(int packet_number,
/** allocate memory for packet header + payload */
errbuf = gwbuf_alloc(sizeof(mysql_packet_header) + mysql_payload_size);
ss_dassert(errbuf != NULL);
mxb_assert(errbuf != NULL);
if (errbuf == NULL)
{
@ -587,7 +587,7 @@ bool gw_get_shared_session_auth_info(DCB* dcb, MYSQL_session* session)
if (dcb->dcb_role == DCB_ROLE_CLIENT_HANDLER)
{
// The shared session data can be extracted at any time if the client DCB is used.
ss_dassert(dcb->data);
mxb_assert(dcb->data);
memcpy(session, dcb->data, sizeof(MYSQL_session));
}
else if (dcb->session->state != SESSION_STATE_ALLOC &&
@ -597,7 +597,7 @@ bool gw_get_shared_session_auth_info(DCB* dcb, MYSQL_session* session)
}
else
{
ss_dassert(false);
mxb_assert(false);
MXS_ERROR("Couldn't get session authentication info. Session in a wrong state %s.",
STRSESSIONSTATE(dcb->session->state));
rval = false;
@ -971,7 +971,7 @@ mxs_auth_state_t gw_send_backend_auth(DCB *dcb)
GWBUF* buffer = gw_generate_auth_response(&client, (MySQLProtocol*)dcb->protocol,
with_ssl, ssl_established,
dcb->service->capabilities);
ss_dassert(buffer);
mxb_assert(buffer);
if (with_ssl && !ssl_established)
{
@ -1088,8 +1088,8 @@ int gw_decode_mysql_server_handshake(MySQLProtocol *conn, uint8_t *payload)
if (payload[0] > 0)
{
scramble_len = payload[0] - 1;
ss_dassert(scramble_len > GW_SCRAMBLE_LENGTH_323);
ss_dassert(scramble_len <= GW_MYSQL_SCRAMBLE_SIZE);
mxb_assert(scramble_len > GW_SCRAMBLE_LENGTH_323);
mxb_assert(scramble_len <= GW_MYSQL_SCRAMBLE_SIZE);
if ((scramble_len < GW_SCRAMBLE_LENGTH_323) ||
scramble_len > GW_MYSQL_SCRAMBLE_SIZE)
@ -1416,7 +1416,7 @@ void mxs_mysql_execute_kill(MXS_SESSION* issuer, uint64_t target_id, kill_type_t
for (int i = 0; i < config_threadcount(); i++)
{
MXB_WORKER* worker = mxs_rworker_get(i);
ss_dassert(worker);
mxb_assert(worker);
mxb_worker_post_message(worker, MXB_WORKER_MSG_CALL, (intptr_t)worker_func,
(intptr_t)new ConnKillInfo(target_id, ss.str(), issuer));
}
@ -1434,7 +1434,7 @@ void mxs_mysql_execute_kill_user(MXS_SESSION* issuer, const char* user, kill_typ
for (int i = 0; i < config_threadcount(); i++)
{
MXB_WORKER* worker = mxs_rworker_get(i);
ss_dassert(worker);
mxb_assert(worker);
mxb_worker_post_message(worker, MXB_WORKER_MSG_CALL, (intptr_t)worker_func,
(intptr_t)new UserKillInfo(user, ss.str(), issuer));
}
@ -1470,14 +1470,14 @@ void mxs_mysql_parse_ok_packet(GWBUF *buff, size_t packet_offset, size_t packet_
if (server_status & SERVER_SESSION_STATE_CHANGED)
{
MXB_AT_DEBUG(uint64_t data_size = )mxs_leint_consume(&ptr); // total SERVER_SESSION_STATE_CHANGED length
ss_dassert(data_size == packet_len - (ptr - local_buf));
mxb_assert(data_size == packet_len - (ptr - local_buf));
while (ptr < (local_buf + packet_len))
{
enum_session_state_type type =
(enum enum_session_state_type)mxs_leint_consume(&ptr);
#if defined(SS_DEBUG)
ss_dassert(type <= SESSION_TRACK_TRANSACTION_TYPE);
mxb_assert(type <= SESSION_TRACK_TRANSACTION_TYPE);
#endif
switch (type)
{
@ -1606,7 +1606,7 @@ void mxs_mysql_get_session_track_info(GWBUF *buff, MySQLProtocol *proto)
mysql_tx_state_t parse_trx_state(const char *str)
{
int s = TX_EMPTY;
ss_dassert(str);
mxb_assert(str);
do
{
switch (*str)