hcq/MaxScale
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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
avro/maxavro.c
View File

@ -254,7 +254,7 @@ bool maxavro_read_float(MAXAVRO_FILE* file, float *dest)
}
else
{
ss_dassert(!true);
mxb_assert(!true);
MXS_ERROR("Block cannot hold a value of type float");
}
@ -293,7 +293,7 @@ bool maxavro_read_double(MAXAVRO_FILE* file, double *dest)
}
else
{
ss_dassert(!true);
mxb_assert(!true);
MXS_ERROR("Block cannot hold a value of type double");
}

2
avro/maxavro_file.c
View File

@ -194,7 +194,7 @@ bool maxavro_read_datablock_start(MAXAVRO_FILE* file)
file->records_in_block = records;
file->records_read_from_block = 0;
file->data_start_pos = pos;
ss_dassert(file->data_start_pos > file->block_start_pos);
mxb_assert(file->data_start_pos > file->block_start_pos);
file->metadata_read = true;
rval = maxavro_verify_block(file);
}

10
avro/maxavro_record.c
View File

@ -62,13 +62,13 @@ static json_t* read_and_pack_value(MAXAVRO_FILE *file, MAXAVRO_SCHEMA_FIELD *fie
maxavro_read_integer(file, &val);
json_t *arr = field->extra;
ss_dassert(arr);
ss_dassert(json_is_array(arr));
mxb_assert(arr);
mxb_assert(json_is_array(arr));
if (json_array_size(arr) >= val)
{
json_t * symbol = json_array_get(arr, val);
ss_dassert(json_is_string(symbol));
mxb_assert(json_is_string(symbol));
value = json_pack("s", json_string_value(symbol));
}
}
@ -260,7 +260,7 @@ bool maxavro_record_seek(MAXAVRO_FILE *file, uint64_t offset)
maxavro_next_block(file);
}
ss_dassert(offset <= file->records_in_block);
mxb_assert(offset <= file->records_in_block);
while (offset-- > 0)
{
@ -310,7 +310,7 @@ GWBUF* maxavro_record_read_binary(MAXAVRO_FILE *file)
}
long data_size = (file->data_start_pos - file->block_start_pos) + file->buffer_size;
ss_dassert(data_size > 0);
mxb_assert(data_size > 0);
rval = gwbuf_alloc(data_size + SYNC_MARKER_SIZE);
if (rval)

2
avro/maxavro_schema.c
View File

@ -100,7 +100,7 @@ static enum maxavro_value_type unpack_to_type(json_t *object,
{
json_t *tmp = NULL;
json_unpack(object, "{s:o}", "symbols", &tmp);
ss_dassert(json_is_array(tmp));
mxb_assert(json_is_array(tmp));
json_incref(tmp);
field->extra = tmp;
}

4
examples/roundrobinrouter.cpp
View File

@ -423,7 +423,7 @@ void RRRouter::handle_error(RRRouterSession* rses, GWBUF* message, DCB* problem_
}
break;
default:
ss_dassert(!true);
mxb_assert(!true);
*succp = false;
break;
}
@ -444,7 +444,7 @@ RRRouterSession::RRRouterSession(DCB_VEC& backends, DCB* write, DCB* client)
RRRouterSession::~RRRouterSession()
{
/* Shouldn't happen. */
ss_dassert(m_closed);
mxb_assert(m_closed);
}
void RRRouterSession::close()

6
include/maxscale/backend.hh
View File

@ -100,7 +100,7 @@ public:
*/
inline bool has_session_commands() const
{
ss_dassert(in_use());
mxb_assert(in_use());
return !m_session_commands.empty();
}
@ -125,7 +125,7 @@ public:
*/
inline SERVER_REF* backend() const
{
ss_dassert(m_backend);
mxb_assert(m_backend);
return m_backend;
}
@ -136,7 +136,7 @@ public:
*/
inline SERVER* server() const
{
ss_dassert(m_backend);
mxb_assert(m_backend);
return m_backend->server;
}

10
include/maxscale/buffer.hh
View File

@ -72,7 +72,7 @@ public:
void advance()
{
ss_dassert(m_i != m_end);
mxb_assert(m_i != m_end);
++m_i;
@ -151,7 +151,7 @@ public:
reference operator*()
{
ss_dassert(m_i);
mxb_assert(m_i);
return *m_i;
}
};
@ -198,7 +198,7 @@ public:
reference operator*() const
{
ss_dassert(m_i);
mxb_assert(m_i);
return *m_i;
}
};
@ -226,7 +226,7 @@ public:
if (!m_pBuffer)
{
ss_dassert(!true);
mxb_assert(!true);
throw std::bad_alloc();
}
}
@ -666,7 +666,7 @@ public:
{
if (!make_contiguous(std::nothrow))
{
ss_dassert(!true);
mxb_assert(!true);
throw std::bad_alloc();
}
}

2
include/maxscale/customparser.hh
View File

@ -116,7 +116,7 @@ protected:
*/
bool is_next_alpha(char uc, int offset = 1) const
{
ss_dassert(uc >= 'A' && uc <= 'Z');
mxb_assert(uc >= 'A' && uc <= 'Z');
char lc = uc + ('a' - 'A');

3
include/maxscale/debug.h
View File

@ -18,7 +18,4 @@
MXS_BEGIN_DECLS
#define ss_dassert mxb_assert
#define ss_info_dassert mxb_assert_message
MXS_END_DECLS

2
include/maxscale/jansson.hh
View File

@ -97,7 +97,7 @@ static inline std::string json_to_string(json_t* json)
break;
default:
ss_dassert(false);
mxb_assert(false);
break;
}

6
include/maxscale/modinfo.h
View File

@ -254,7 +254,7 @@ static inline const char* mxs_module_param_type_to_string(enum mxs_module_param_
case MXS_MODULE_PARAM_REGEX:
return "regular expression";
default:
ss_dassert(!true);
mxb_assert(!true);
return "unknown";
}
}
@ -276,7 +276,7 @@ static inline const char* mxs_module_api_to_string(MXS_MODULE_API type)
case MXS_MODULE_API_QUERY_CLASSIFIER:
return "query_classifier";
default:
ss_dassert(!true);
mxb_assert(!true);
return "unknown";
}
}
@ -296,7 +296,7 @@ static inline const char* mxs_module_status_to_string(MXS_MODULE_STATUS type)
case MXS_MODULE_EXPERIMENTAL:
return "Experimental";
default:
ss_dassert(!true);
mxb_assert(!true);
return "Unknown";
}
}

2
include/maxscale/queryclassifier.hh
View File

@ -207,7 +207,7 @@ public:
{
if (state == LOAD_DATA_ACTIVE)
{
ss_dassert(m_load_data_state == LOAD_DATA_INACTIVE);
mxb_assert(m_load_data_state == LOAD_DATA_INACTIVE);
reset_load_data_sent();
}

62
query_classifier/qc_mysqlembedded/qc_mysqlembedded.cc
View File

@ -235,7 +235,7 @@ bool ensure_query_is_parsed(GWBUF* query)
MXB_AT_DEBUG(int rv);
MXB_AT_DEBUG(rv = )pthread_mutex_lock(&this_unit.sql_mode_mutex);
ss_dassert(rv == 0);
mxb_assert(rv == 0);
if (this_thread.sql_mode == QC_SQL_MODE_ORACLE)
{
@ -249,7 +249,7 @@ bool ensure_query_is_parsed(GWBUF* query)
parsed = parse_query(query);
MXB_AT_DEBUG(rv = )pthread_mutex_unlock(&this_unit.sql_mode_mutex);
ss_dassert(rv == 0);
mxb_assert(rv == 0);
if (!parsed)
{
@ -274,7 +274,7 @@ int32_t qc_mysql_parse(GWBUF* querybuf, uint32_t collect, int32_t* result)
{
parsing_info_t* pi = (parsing_info_t*) gwbuf_get_buffer_object_data(querybuf,
GWBUF_PARSING_INFO);
ss_dassert(pi);
mxb_assert(pi);
*result = pi->result;
}
@ -294,7 +294,7 @@ int32_t qc_mysql_get_type_mask(GWBUF* querybuf, uint32_t* type_mask)
MYSQL* mysql;
bool succp;
ss_info_dassert(querybuf != NULL, ("querybuf is NULL"));
mxb_assert_message(querybuf != NULL, ("querybuf is NULL"));
if (querybuf == NULL)
{
@ -359,7 +359,7 @@ static bool parse_query(GWBUF* querybuf)
parsing_info_t* pi;
/** Do not parse without releasing previous parse info first */
ss_dassert(!query_is_parsed(querybuf));
mxb_assert(!query_is_parsed(querybuf));
if (querybuf == NULL || query_is_parsed(querybuf))
{
@ -461,8 +461,8 @@ static THD* get_or_create_thd_for_parsing(MYSQL* mysql, char* query_str)
bool failp = FALSE;
size_t query_len;
ss_info_dassert(mysql != NULL, ("mysql is NULL"));
ss_info_dassert(query_str != NULL, ("query_str is NULL"));
mxb_assert_message(mysql != NULL, ("mysql is NULL"));
mxb_assert_message(query_str != NULL, ("query_str is NULL"));
query_len = strlen(query_str);
client_flags = set_client_flags(mysql);
@ -727,7 +727,7 @@ static uint32_t resolve_query_type(parsing_info_t *pi, THD* thd)
bool force_data_modify_op_replication;
force_data_modify_op_replication = FALSE;
#endif /* NOT_IN_USE */
ss_info_dassert(thd != NULL, ("thd is NULL\n"));
mxb_assert_message(thd != NULL, ("thd is NULL\n"));
lex = thd->lex;
@ -1317,7 +1317,7 @@ static int is_autocommit_stmt(LEX* lex)
if ((rc = find_type(&bool_typelib, res->ptr(), res->length(), false)))
{
ss_dassert(rc >= 0 && rc <= 2);
mxb_assert(rc >= 0 && rc <= 2);
/**
* rc is the position of matchin string in
* typelib's value array.
@ -1375,9 +1375,9 @@ parsing_info_t* get_pinfo(GWBUF* querybuf)
LEX* get_lex(parsing_info_t* pi)
{
MYSQL* mysql = (MYSQL *) pi->pi_handle;
ss_dassert(mysql);
mxb_assert(mysql);
THD* thd = (THD *) mysql->thd;
ss_dassert(thd);
mxb_assert(thd);
return thd->lex;
}
@ -1397,9 +1397,9 @@ LEX* get_lex(GWBUF* querybuf)
if (pi)
{
MYSQL* mysql = (MYSQL *) pi->pi_handle;
ss_dassert(mysql);
mxb_assert(mysql);
THD* thd = (THD *) mysql->thd;
ss_dassert(thd);
mxb_assert(thd);
lex = thd->lex;
}
@ -1417,7 +1417,7 @@ static TABLE_LIST* skygw_get_affected_tables(void* lexptr)
if (lex == NULL || lex->current_select == NULL)
{
ss_dassert(lex != NULL && lex->current_select != NULL);
mxb_assert(lex != NULL && lex->current_select != NULL);
return NULL;
}
@ -1678,7 +1678,7 @@ static parsing_info_t* parsing_info_init(void (*donefun)(void *))
const char* user = "skygw";
const char* db = "skygw";
ss_dassert(donefun != NULL);
mxb_assert(donefun != NULL);
/** Get server handle */
mysql = mysql_init(NULL);
@ -1688,7 +1688,7 @@ static parsing_info_t* parsing_info_init(void (*donefun)(void *))
MXS_ERROR("Call to mysql_real_connect failed due %d, %s.",
mysql_errno(mysql),
mysql_error(mysql));
ss_dassert(mysql != NULL);
mxb_assert(mysql != NULL);
goto retblock;
}
@ -1712,7 +1712,7 @@ static parsing_info_t* parsing_info_init(void (*donefun)(void *))
pi->pi_handle = mysql;
pi->pi_done_fp = donefun;
pi->result = QC_QUERY_INVALID;
ss_dassert(this_thread.function_name_mappings);
mxb_assert(this_thread.function_name_mappings);
pi->function_name_mappings = this_thread.function_name_mappings;
retblock:
@ -2227,7 +2227,7 @@ static void add_field_info(parsing_info_t* info,
const char* column,
List<Item>* excludep)
{
ss_dassert(column);
mxb_assert(column);
unalias_names(select, database, table, &database, &table);
@ -2242,7 +2242,7 @@ static void add_field_info(parsing_info_t* info,
{
if (!item.table && !field_info->table)
{
ss_dassert(!item.database && !field_info->database);
mxb_assert(!item.database && !field_info->database);
break;
}
else if (item.table && field_info->table && (strcmp(item.table, field_info->table) == 0))
@ -2294,7 +2294,7 @@ static void add_field_info(parsing_info_t* info,
{
item.database = item.database ? strdup(item.database) : NULL;
item.table = item.table ? strdup(item.table) : NULL;
ss_dassert(item.column);
mxb_assert(item.column);
item.column = strdup(item.column);
// We are happy if we at least could dup the column.
@ -2344,7 +2344,7 @@ static void add_function_field_usage(const char* database,
{
QC_FIELD_INFO* fields = (QC_FIELD_INFO*)realloc(fi->fields,
(fi->n_fields + 1) * sizeof(QC_FIELD_INFO));
ss_dassert(fields);
mxb_assert(fields);
if (fields)
{
@ -2431,7 +2431,7 @@ static void add_function_field_usage(st_select_lex* select,
break;
default:
//ss_dassert(!true);
//mxb_assert(!true);
;
}
}
@ -2499,7 +2499,7 @@ static QC_FUNCTION_INFO* add_function_info(parsing_info_t* info,
Item** items,
int n_items)
{
ss_dassert(name);
mxb_assert(name);
QC_FUNCTION_INFO* function_info = NULL;
@ -3093,12 +3093,12 @@ int32_t qc_mysql_get_field_info(GWBUF* buf, const QC_FIELD_INFO** infos, uint32_
}
parsing_info_t* pi = get_pinfo(buf);
ss_dassert(pi);
mxb_assert(pi);
if (!pi->field_infos)
{
LEX* lex = get_lex(buf);
ss_dassert(lex);
mxb_assert(lex);
if (!lex)
{
@ -3283,7 +3283,7 @@ int32_t qc_mysql_get_function_info(GWBUF* buf,
if (rv == QC_RESULT_OK)
{
parsing_info_t* pi = get_pinfo(buf);
ss_dassert(pi);
mxb_assert(pi);
*function_infos = pi->function_infos;
*n_function_infos = pi->function_infos_len;
@ -3348,15 +3348,15 @@ void configure_options(const char* datadir, const char* langdir)
int rv;
rv = snprintf(datadir_arg, OPTIONS_DATADIR_SIZE, "--datadir=%s", datadir);
ss_dassert(rv < OPTIONS_DATADIR_SIZE); // Ensured by create_datadir().
mxb_assert(rv < OPTIONS_DATADIR_SIZE); // Ensured by create_datadir().
server_options[IDX_DATADIR] = datadir_arg;
rv = sprintf(language_arg, "--language=%s", langdir);
ss_dassert(rv < OPTIONS_LANGUAGE_SIZE); // Ensured by qc_process_init().
mxb_assert(rv < OPTIONS_LANGUAGE_SIZE); // Ensured by qc_process_init().
server_options[IDX_LANGUAGE] = language_arg;
// To prevent warning of unused variable when built in release mode,
// when ss_dassert() turns into empty statement.
// when mxb_assert() turns into empty statement.
(void)rv;
}
@ -3401,7 +3401,7 @@ int32_t qc_mysql_process_init(void)
if (rc != 0)
{
this_thread.sql_mode = this_unit.sql_mode;
ss_dassert(this_unit.function_name_mappings);
mxb_assert(this_unit.function_name_mappings);
this_thread.function_name_mappings = this_unit.function_name_mappings;
MXS_ERROR("mysql_library_init() failed. Error code: %d", rc);
@ -3427,7 +3427,7 @@ void qc_mysql_process_end(void)
int32_t qc_mysql_thread_init(void)
{
this_thread.sql_mode = this_unit.sql_mode;
ss_dassert(this_unit.function_name_mappings);
mxb_assert(this_unit.function_name_mappings);
this_thread.function_name_mappings = this_unit.function_name_mappings;
bool inited = (mysql_thread_init() == 0);

6
query_classifier/qc_sqlite/builtin_functions.c
View File

@ -470,7 +470,7 @@ static int search_compare(const void* key, const void* value)
void init_builtin_functions()
{
ss_dassert(!unit.inited);
mxb_assert(!unit.inited);
qsort(BUILTIN_FUNCTIONS, N_BUILTIN_FUNCTIONS, sizeof(char*), sort_compare);
qsort(BUILTIN_10_2_3_FUNCTIONS, N_BUILTIN_10_2_3_FUNCTIONS, sizeof(char*), sort_compare);
@ -481,7 +481,7 @@ void init_builtin_functions()
void finish_builtin_functions()
{
ss_dassert(unit.inited);
mxb_assert(unit.inited);
unit.inited = false;
}
@ -489,7 +489,7 @@ bool is_builtin_readonly_function(const char* key,
uint32_t major, uint32_t minor, uint32_t patch,
bool check_oracle)
{
ss_dassert(unit.inited);
mxb_assert(unit.inited);
char* value = bsearch(key, BUILTIN_FUNCTIONS, N_BUILTIN_FUNCTIONS, sizeof(char*), search_compare);

342
query_classifier/qc_sqlite/qc_sqlite.cc
View File

File diff suppressed because it is too large Load Diff

12
query_classifier/test/compare.cc
View File

@ -277,7 +277,7 @@ static timespec timespec_subtract(const timespec& later, const timespec& earlier
{
timespec result = { 0, 0 };
ss_dassert((later.tv_sec > earlier.tv_sec) ||
mxb_assert((later.tv_sec > earlier.tv_sec) ||
((later.tv_sec == earlier.tv_sec) && (later.tv_nsec > earlier.tv_nsec)));
if (later.tv_nsec >= earlier.tv_nsec)
@ -830,7 +830,7 @@ ostream& operator << (ostream& out, const QC_FIELD_INFO& x)
{
out << x.database;
out << ".";
ss_dassert(x.table);
mxb_assert(x.table);
}
if (x.table)
@ -839,7 +839,7 @@ ostream& operator << (ostream& out, const QC_FIELD_INFO& x)
out << ".";
}
ss_dassert(x.column);
mxb_assert(x.column);
out << x.column;
return out;
@ -1069,7 +1069,7 @@ public:
out << name.table << ".";
}
ss_dassert(name.column);
mxb_assert(name.column);
out << name.column;
@ -1348,7 +1348,7 @@ bool compare(QUERY_CLASSIFIER* pClassifier1, QUERY_CLASSIFIER* pClassifier2, con
break;
default:
ss_dassert(!true);
mxb_assert(!true);
case SetSqlModeParser::SOMETHING:
break;
};
@ -1589,7 +1589,7 @@ int main(int argc, char* argv[])
}
else
{
ss_dassert(n == 2);
mxb_assert(n == 2);
ifstream in(argv[argc - 1]);

2
server/core/adminusers.cc
View File

@ -128,7 +128,7 @@ static const char* admin_remove_user(USERS *users, const char* fname, const char
static json_t* admin_user_json_data(const char* host, const char* user, enum user_type user_type,
enum user_account_type account)
{
ss_dassert(user_type != USER_TYPE_ALL);
mxb_assert(user_type != USER_TYPE_ALL);
const char* type = user_type == USER_TYPE_INET ? CN_INET : CN_UNIX;
json_t* entry = json_object();

26
server/core/backend.cc
View File

@ -33,7 +33,7 @@ Backend::Backend(SERVER_REF *ref):
Backend::~Backend()
{
ss_dassert(m_closed || !in_use());
mxb_assert(m_closed || !in_use());
if (in_use())
{
@ -43,7 +43,7 @@ Backend::~Backend()
void Backend::close(close_type type)
{
ss_dassert(m_dcb->n_close == 0);
mxb_assert(m_dcb->n_close == 0);
if (!m_closed)
{
@ -72,7 +72,7 @@ void Backend::close(close_type type)
}
else
{
ss_dassert(false);
mxb_assert(false);
}
}
@ -95,7 +95,7 @@ bool Backend::execute_session_command()
/** These commands do not generate responses */
rval = write(buffer, NO_RESPONSE);
complete_session_command();
ss_dassert(!is_waiting_result());
mxb_assert(!is_waiting_result());
break;
case MXS_COM_CHANGE_USER:
@ -107,7 +107,7 @@ bool Backend::execute_session_command()
// We want the complete response in one packet
gwbuf_set_type(buffer, GWBUF_TYPE_COLLECT_RESULT);
rval = write(buffer, EXPECT_RESPONSE);
ss_dassert(is_waiting_result());
mxb_assert(is_waiting_result());
break;
}
@ -143,7 +143,7 @@ size_t Backend::session_command_count() const
const SSessionCommand& Backend::next_session_command() const
{
ss_dassert(has_session_commands());
mxb_assert(has_session_commands());
return m_session_commands.front();
}
@ -152,7 +152,7 @@ void Backend::clear_state(backend_state state)
if ((state & WAITING_RESULT) && (m_state & WAITING_RESULT))
{
MXB_AT_DEBUG(int prev2 = )atomic_add(&m_backend->server->stats.n_current_ops, -1);
ss_dassert(prev2 > 0);
mxb_assert(prev2 > 0);
}
m_state &= ~state;
@ -163,7 +163,7 @@ void Backend::set_state(backend_state state)
if ((state & WAITING_RESULT) && (m_state & WAITING_RESULT) == 0)
{
MXB_AT_DEBUG(int prev2 = )atomic_add(&m_backend->server->stats.n_current_ops, 1);
ss_dassert(prev2 >= 0);
mxb_assert(prev2 >= 0);
}
m_state |= state;
@ -171,7 +171,7 @@ void Backend::set_state(backend_state state)
bool Backend::connect(MXS_SESSION* session, SessionCommandList* sescmd)
{
ss_dassert(!in_use());
mxb_assert(!in_use());
bool rval = false;
if ((m_dcb = dcb_connect(m_backend->server, session, m_backend->server->protocol)))
@ -201,7 +201,7 @@ bool Backend::connect(MXS_SESSION* session, SessionCommandList* sescmd)
bool Backend::write(GWBUF* buffer, response_type type)
{
ss_dassert(in_use());
mxb_assert(in_use());
bool rval = m_dcb->func.write(m_dcb, buffer) != 0;
if (rval && type == EXPECT_RESPONSE)
@ -214,7 +214,7 @@ bool Backend::write(GWBUF* buffer, response_type type)
bool Backend::auth(GWBUF* buffer)
{
ss_dassert(in_use());
mxb_assert(in_use());
bool rval = false;
if (m_dcb->func.auth(m_dcb, NULL, m_dcb->session, buffer) == 1)
@ -228,7 +228,7 @@ bool Backend::auth(GWBUF* buffer)
void Backend::ack_write()
{
ss_dassert(is_waiting_result());
mxb_assert(is_waiting_result());
clear_state(WAITING_RESULT);
}
@ -239,7 +239,7 @@ void Backend::store_command(GWBUF* buffer)
bool Backend::write_stored_command()
{
ss_dassert(in_use());
mxb_assert(in_use());
bool rval = false;
if (m_pending_cmd.length())

20
server/core/buffer.cc
View File

@ -375,7 +375,7 @@ static GWBUF *gwbuf_clone_portion(GWBUF *buf,
{
GWBUF* clonebuf;
ss_dassert(start_offset + length <= GWBUF_LENGTH(buf));
mxb_assert(start_offset + length <= GWBUF_LENGTH(buf));
if ((clonebuf = (GWBUF *)MXS_MALLOC(sizeof(GWBUF))) == NULL)
{
@ -431,7 +431,7 @@ GWBUF* gwbuf_split(GWBUF **buf, size_t length)
if (length > 0)
{
ss_dassert(GWBUF_LENGTH(buffer) > length);
mxb_assert(GWBUF_LENGTH(buffer) > length);
GWBUF* partial = gwbuf_clone_portion(buffer, 0, length);
/** If the head points to the original head of the buffer chain
@ -482,7 +482,7 @@ static inline bool gwbuf_get_byte(const GWBUF** buf, size_t* offset, uint8_t* b)
*buf = (*buf)->next;
}
ss_dassert(!*buf || (GWBUF_LENGTH(*buf) > *offset));
mxb_assert(!*buf || (GWBUF_LENGTH(*buf) > *offset));
if (*buf)
{
@ -505,17 +505,17 @@ int gwbuf_compare(const GWBUF* lhs, const GWBUF* rhs)
}
else if (lhs == NULL)
{
ss_dassert(rhs);
mxb_assert(rhs);
rv = -1;
}
else if (rhs == NULL)
{
ss_dassert(lhs);
mxb_assert(lhs);
rv = 1;
}
else
{
ss_dassert(lhs && rhs);
mxb_assert(lhs && rhs);
size_t llen = gwbuf_length(lhs);
size_t rlen = gwbuf_length(rhs);
@ -530,7 +530,7 @@ int gwbuf_compare(const GWBUF* lhs, const GWBUF* rhs)
}
else
{
ss_dassert(llen == rlen);
mxb_assert(llen == rlen);
rv = 0;
size_t i = 0;
@ -545,7 +545,7 @@ int gwbuf_compare(const GWBUF* lhs, const GWBUF* rhs)
MXB_AT_DEBUG(bool rv1 = ) gwbuf_get_byte(&lhs, &loffset, &lc);
MXB_AT_DEBUG(bool rv2 = ) gwbuf_get_byte(&rhs, &roffset, &rc);
ss_dassert(rv1 && rv2);
mxb_assert(rv1 && rv2);
rv = (int)lc - (int)rc;
@ -605,7 +605,7 @@ gwbuf_consume(GWBUF *head, unsigned int length)
}
}
ss_dassert(head == NULL || (head->end >= head->start));
mxb_assert(head == NULL || (head->end >= head->start));
return head;
}
@ -751,7 +751,7 @@ GWBUF* gwbuf_make_contiguous(GWBUF *orig)
{
if (orig == NULL)
{
ss_info_dassert(!true, "gwbuf_make_contiguous: NULL buffer");
mxb_assert_message(!true, "gwbuf_make_contiguous: NULL buffer");
return NULL;
}
if (orig->next == NULL)

68
server/core/config.cc
View File

@ -843,8 +843,8 @@ int config_cb(const char* fpath, const struct stat *sb, int typeflag, struct FTW
if (strcmp(suffix, "cnf") == 0) // that is ".cnf".
{
ss_dassert(current_dcontext);
ss_dassert(current_ccontext);
mxb_assert(current_dcontext);
mxb_assert(current_ccontext);
if (!config_load_single_file(fpath, current_dcontext, current_ccontext))
{
@ -960,7 +960,7 @@ static bool contains_cnf_files(const char *path)
break;
default:
ss_dassert(rc == GLOB_NOMATCH);
mxb_assert(rc == GLOB_NOMATCH);
break;
}
@ -1136,7 +1136,7 @@ bool config_load_global(const char *filename)
bool
config_load(const char *filename)
{
ss_dassert(!config_file);
mxb_assert(!config_file);
config_file = filename;
bool rval = config_load_and_process(filename, process_config_context);
@ -1207,7 +1207,7 @@ std::pair<const MXS_MODULE_PARAM*, const MXS_MODULE*> get_module_details(const C
return {config_filter_params, get_module(name, MODULE_FILTER)};
}
ss_dassert(!true);
mxb_assert(!true);
return {nullptr, nullptr};
}
@ -1465,7 +1465,7 @@ bool resolve_dependencies(std::vector<CONFIG_CONTEXT*>& objects)
}
else
{
ss_dassert(!group.empty());
mxb_assert(!group.empty());
/** Due to the algorithm that was used, the strongly connected
* components are always identified before the nodes that depend
* on them. This means that the result is sorted at the same
@ -1475,7 +1475,7 @@ bool resolve_dependencies(std::vector<CONFIG_CONTEXT*>& objects)
}
// The end result should contain the same set of nodes we started with
ss_dassert(std::set<CONFIG_CONTEXT*>(result.begin(), result.end()) ==
mxb_assert(std::set<CONFIG_CONTEXT*>(result.begin(), result.end()) ==
std::set<CONFIG_CONTEXT*>(objects.begin(), objects.end()));
objects = std::move(result);
@ -1512,7 +1512,7 @@ process_config_context(CONFIG_CONTEXT *context)
for (CONFIG_CONTEXT* obj : objects)
{
std::string type = config_get_string(obj->parameters, CN_TYPE);
ss_dassert(!type.empty());
mxb_assert(!type.empty());
if (type == CN_SERVER)
{
@ -1534,7 +1534,7 @@ process_config_context(CONFIG_CONTEXT *context)
for (CONFIG_CONTEXT* obj : objects)
{
std::string type = config_get_string(obj->parameters, CN_TYPE);
ss_dassert(!type.empty());
mxb_assert(!type.empty());
if (type == CN_SERVICE)
{
@ -1649,7 +1649,7 @@ uint64_t config_get_size(const MXS_CONFIG_PARAMETER *params, const char *key)
const char *value = config_get_value_string(params, key);
uint64_t intval;
MXB_AT_DEBUG(bool rval = )get_suffixed_size(value, &intval);
ss_dassert(rval);
mxb_assert(rval);
return intval;
}
@ -1731,7 +1731,7 @@ int config_get_server_list(const MXS_CONFIG_PARAMETER *params, const char *key,
}
}
*output = result;
ss_dassert(found == res_ind);
mxb_assert(found == res_ind);
}
MXS_FREE(servers);
}
@ -1780,7 +1780,7 @@ bool config_get_compiled_regexes(const MXS_CONFIG_PARAMETER *params,
uint32_t ovec_size_temp = 0;
for (int i = 0; i < keys_size; i++)
{
ss_dassert(out_codes[i]);
mxb_assert(out_codes[i]);
*out_codes[i] = config_get_compiled_regex(params, keys[i], options,
&ovec_size_temp);
if (*out_codes[i])
@ -1858,7 +1858,7 @@ void config_context_free(CONFIG_CONTEXT *context)
bool config_add_param(CONFIG_CONTEXT* obj, const char* key, const char* value)
{
ss_dassert(config_get_param(obj->parameters, key) == NULL);
mxb_assert(config_get_param(obj->parameters, key) == NULL);
bool rval = false;
char *my_key = MXS_STRDUP(key);
char *my_value = MXS_STRDUP(value);
@ -1885,7 +1885,7 @@ bool config_add_param(CONFIG_CONTEXT* obj, const char* key, const char* value)
bool config_append_param(CONFIG_CONTEXT* obj, const char* key, const char* value)
{
MXS_CONFIG_PARAMETER *param = config_get_param(obj->parameters, key);
ss_dassert(param);
mxb_assert(param);
int paramlen = strlen(param->value) + strlen(value) + 2;
char tmp[paramlen];
bool rval = false;
@ -2512,7 +2512,7 @@ bool config_create_ssl(const char* name, MXS_CONFIG_PARAMETER* params,
// The enum values convert to bool
int value = config_get_enum(params, CN_SSL, ssl_values);
ss_dassert(value != -1);
mxb_assert(value != -1);
if (value)
{
@ -2566,9 +2566,9 @@ bool config_create_ssl(const char* name, MXS_CONFIG_PARAMETER* params,
listener_set_certificates(ssl, ssl_cert, ssl_key, ssl_ca_cert);
ss_dassert(access(ssl_ca_cert, F_OK) == 0);
ss_dassert(!ssl_cert || access(ssl_cert, F_OK) == 0);
ss_dassert(!ssl_key || access(ssl_key, F_OK) == 0);
mxb_assert(access(ssl_ca_cert, F_OK) == 0);
mxb_assert(!ssl_cert || access(ssl_cert, F_OK) == 0);
mxb_assert(!ssl_key || access(ssl_key, F_OK) == 0);
if (!SSL_LISTENER_init(ssl))
{
@ -2812,13 +2812,13 @@ const char* param_type_to_str(const MXS_MODULE_PARAM* params, const char* name)
return "a path to a file";
default:
ss_info_dassert(!true, "Unknown parameter type");
mxb_assert_message(!true, "Unknown parameter type");
return "<unknown parameter type>";
}
}
}
ss_info_dassert(!true, "Unknown parameter name");
mxb_assert_message(!true, "Unknown parameter name");
return "<unknown parameter name>";
}
@ -2853,7 +2853,7 @@ check_config_objects(CONFIG_CONTEXT *context)
const MXS_MODULE *mod = nullptr;
std::tie(param_set, mod) = get_module_details(obj);
ss_dassert(param_set);
mxb_assert(param_set);
std::vector<std::string> to_be_removed;
for (MXS_CONFIG_PARAMETER *params = obj->parameters; params; params = params->next)
@ -3362,7 +3362,7 @@ void config_add_defaults(CONFIG_CONTEXT *ctx, const MXS_MODULE_PARAM *params)
*/
static json_t* param_value_to_json(const MXS_CONFIG_PARAMETER* param, const MXS_MODULE_PARAM* param_info)
{
ss_dassert(strcmp(param->name, param_info->name) == 0);
mxb_assert(strcmp(param->name, param_info->name) == 0);
json_t* rval = NULL;
switch (param_info->type)
@ -3429,12 +3429,12 @@ void config_add_module_params_json(const MXS_CONFIG_PARAMETER* parameters,
int create_new_service(CONFIG_CONTEXT *obj)
{
const char *router = config_get_string(obj->parameters, CN_ROUTER);
ss_dassert(*router);
mxb_assert(*router);
char *user = config_get_value(obj->parameters, CN_USER);
char *auth = config_get_value(obj->parameters, CN_PASSWORD);
const MXS_MODULE* module = get_module(router, MODULE_ROUTER);
ss_dassert(module);
mxb_assert(module);
if ((!user || !auth) &&
!rcap_type_required(module->module_capabilities, RCAP_TYPE_NO_AUTH))
@ -3527,7 +3527,7 @@ int create_new_server(CONFIG_CONTEXT *obj)
config_add_defaults(obj, config_server_params);
const char* module = config_get_string(obj->parameters, CN_PROTOCOL);
ss_dassert(module);
mxb_assert(module);
if (const MXS_MODULE* mod = get_module(module, MODULE_PROTOCOL))
{
@ -3599,7 +3599,7 @@ int create_new_monitor(CONFIG_CONTEXT *obj, std::set<std::string>& monitored_ser
}
const char* module = config_get_string(obj->parameters, CN_MODULE);
ss_dassert(module);
mxb_assert(module);
if (const MXS_MODULE* mod = get_module(module, MODULE_MONITOR))
{
@ -3648,7 +3648,7 @@ int create_new_monitor(CONFIG_CONTEXT *obj, std::set<std::string>& monitored_ser
int create_new_listener(CONFIG_CONTEXT *obj)
{
const char* protocol = config_get_string(obj->parameters, CN_PROTOCOL);
ss_dassert(*protocol);
mxb_assert(*protocol);
if (const MXS_MODULE * mod = get_module(protocol, MODULE_PROTOCOL))
{
@ -3682,7 +3682,7 @@ int create_new_listener(CONFIG_CONTEXT *obj)
{
const char *address = config_get_string(obj->parameters, CN_ADDRESS);
Service *service = static_cast<Service*>(config_get_service(obj->parameters, CN_SERVICE));
ss_dassert(service);
mxb_assert(service);
if (auto l = service_find_listener(service, socket, address, socket ? 0 : atoi(port)))
{
@ -3730,7 +3730,7 @@ int create_new_filter(CONFIG_CONTEXT *obj)
{
int error_count = 0;
const char* module = config_get_value(obj->parameters, CN_MODULE);
ss_dassert(*module);
mxb_assert(*module);
if (const MXS_MODULE* mod = get_module(module, MODULE_FILTER))
{
@ -4129,7 +4129,7 @@ bool config_param_is_valid(const MXS_MODULE_PARAM *params, const char *key,
default:
MXS_ERROR("Unexpected module parameter type: %d", params[i].type);
ss_dassert(false);
mxb_assert(false);
break;
}
}
@ -4140,7 +4140,7 @@ bool config_param_is_valid(const MXS_MODULE_PARAM *params, const char *key,
int config_parse_server_list(const char *servers, char ***output_array)
{
ss_dassert(servers);
mxb_assert(servers);
/* First, check the string for the maximum amount of servers it
* might contain by counting the commas. */
@ -4321,7 +4321,7 @@ bool config_global_serialize()
strcpy(final_filename, filename);
char *dot = strrchr(final_filename, '.');
ss_dassert(dot);
mxb_assert(dot);
*dot = '\0';
if (rename(filename, final_filename) == 0)
@ -4559,8 +4559,8 @@ bool get_suffixed_size(const char* value, uint64_t* dest)
bool config_parse_disk_space_threshold(MxsDiskSpaceThreshold* pDisk_space_threshold,
const char* zDisk_space_threshold)
{
ss_dassert(pDisk_space_threshold);
ss_dassert(zDisk_space_threshold);
mxb_assert(pDisk_space_threshold);
mxb_assert(zDisk_space_threshold);
bool success = true;

44
server/core/config_runtime.cc
View File

@ -93,7 +93,7 @@ static const MXS_MODULE_PARAM* get_type_parameters(const char* type)
}
MXS_NOTICE("Module type with no default parameters used: %s", type);
ss_info_dassert(!true, "Module type with no default parameters used");
mxb_assert_message(!true, "Module type with no default parameters used");
return NULL;
}
@ -591,7 +591,7 @@ bool runtime_alter_monitor(MXS_MONITOR *monitor, const char *key, const char *va
else
{
// This should be a module specific parameter
ss_dassert(config_param_is_valid(mod->parameters, key, value, NULL));
mxb_assert(config_param_is_valid(mod->parameters, key, value, NULL));
}
monitor_serialize(monitor);
@ -1039,7 +1039,7 @@ bool runtime_create_filter(const char *name, const char *module, MXS_CONFIG_PARA
bool runtime_destroy_filter(const SFilterDef& filter)
{
ss_dassert(filter);
mxb_assert(filter);
bool rval = false;
mxs::SpinLockGuard guard(crt_lock);
@ -1109,7 +1109,7 @@ bool runtime_destroy_service(Service* service)
{
bool rval = false;
mxs::SpinLockGuard guard(crt_lock);
ss_dassert(service && service->active);
mxb_assert(service && service->active);
if (service_can_be_destroyed(service))
{
@ -1233,7 +1233,7 @@ static inline bool is_null_relation(json_t* json, const char* relation)
std::string str(relation);
size_t pos = str.rfind("/data");
ss_dassert(pos != std::string::npos);
mxb_assert(pos != std::string::npos);
str = str.substr(0, pos);
json_t* data = mxs_json_pointer(json, relation);
@ -1244,7 +1244,7 @@ static inline bool is_null_relation(json_t* json, const char* relation)
static const char* json_type_to_string(const json_t* json)
{
ss_dassert(json);
mxb_assert(json);
if (json_is_object(json))
{
@ -1276,7 +1276,7 @@ static const char* json_type_to_string(const json_t* json)
}
else
{
ss_dassert(!true);
mxb_assert(!true);
return "an unknown type";
}
}
@ -1568,7 +1568,7 @@ static bool validate_ssl_json(json_t* params, object_type type)
static bool process_ssl_parameters(SERVER* server, json_t* params)
{
ss_dassert(server->server_ssl == NULL);
mxb_assert(server->server_ssl == NULL);
bool rval = true;
if (have_ssl_json(params))
@ -1640,7 +1640,7 @@ SERVER* runtime_create_server_from_json(json_t* json)
if (runtime_create_server(name, address, port.c_str(), protocol, authenticator))
{
rval = server_find_by_unique_name(name);
ss_dassert(rval);
mxb_assert(rval);
json_t* param = mxs_json_pointer(json, MXS_JSON_PTR_PARAMETERS);
if (!process_ssl_parameters(rval, param) ||
@ -1722,7 +1722,7 @@ bool runtime_alter_server_from_json(SERVER* server, json_t* new_json)
{
bool rval = false;
std::unique_ptr<json_t> old_json(server_to_json(server, ""));
ss_dassert(old_json.get());
mxb_assert(old_json.get());
if (is_valid_resource_body(new_json) &&
server_to_object_relations(server, old_json.get(), new_json))
@ -1731,7 +1731,7 @@ bool runtime_alter_server_from_json(SERVER* server, json_t* new_json)
json_t* parameters = mxs_json_pointer(new_json, MXS_JSON_PTR_PARAMETERS);
json_t* old_parameters = mxs_json_pointer(old_json.get(), MXS_JSON_PTR_PARAMETERS);
ss_dassert(old_parameters);
mxb_assert(old_parameters);
if (parameters)
{
@ -1782,7 +1782,7 @@ bool runtime_alter_server_relationships_from_json(SERVER* server, const char* ty
{
bool rval = false;
std::unique_ptr<json_t> old_json(server_to_json(server, ""));
ss_dassert(old_json.get());
mxb_assert(old_json.get());
if (is_valid_relationship_body(json))
{
@ -1932,7 +1932,7 @@ MXS_MONITOR* runtime_create_monitor_from_json(json_t* json)
if (runtime_create_monitor(name, module))
{
rval = monitor_find(name);
ss_dassert(rval);
mxb_assert(rval);
if (!runtime_alter_monitor_from_json(rval, json))
{
@ -1976,7 +1976,7 @@ Service* runtime_create_service_from_json(json_t* json)
if (runtime_create_service(name, router, params))
{
rval = service_internal_find(name);
ss_dassert(rval);
mxb_assert(rval);
// Performing an alter right after creation takes care of server relationships
if (!runtime_alter_service_from_json(rval, json))
@ -2068,7 +2068,7 @@ bool runtime_alter_monitor_from_json(MXS_MONITOR* monitor, json_t* new_json)
{
bool rval = false;
std::unique_ptr<json_t> old_json(monitor_to_json(monitor, ""));
ss_dassert(old_json.get());
mxb_assert(old_json.get());
if (is_valid_resource_body(new_json) &&
object_to_server_relations(monitor->name, old_json.get(), new_json))
@ -2078,7 +2078,7 @@ bool runtime_alter_monitor_from_json(MXS_MONITOR* monitor, json_t* new_json)
json_t* parameters = mxs_json_pointer(new_json, MXS_JSON_PTR_PARAMETERS);
json_t* old_parameters = mxs_json_pointer(old_json.get(), MXS_JSON_PTR_PARAMETERS);
ss_dassert(old_parameters);
mxb_assert(old_parameters);
if (parameters)
{
@ -2120,7 +2120,7 @@ bool runtime_alter_monitor_relationships_from_json(MXS_MONITOR* monitor, json_t*
{
bool rval = false;
std::unique_ptr<json_t> old_json(monitor_to_json(monitor, ""));
ss_dassert(old_json.get());
mxb_assert(old_json.get());
if (is_valid_relationship_body(json))
{
@ -2141,7 +2141,7 @@ bool runtime_alter_service_relationships_from_json(Service* service, const char*
{
bool rval = false;
std::unique_ptr<json_t> old_json(service_to_json(service, ""));
ss_dassert(old_json.get());
mxb_assert(old_json.get());
if (is_valid_relationship_body(json))
{
@ -2155,7 +2155,7 @@ bool runtime_alter_service_relationships_from_json(Service* service, const char*
}
else
{
ss_dassert(strcmp(type, CN_FILTERS) == 0);
mxb_assert(strcmp(type, CN_FILTERS) == 0);
rval = service_to_filter_relations(service, old_json.get(), j.get());
}
}
@ -2180,7 +2180,7 @@ bool runtime_alter_service_from_json(Service* service, json_t* new_json)
{
bool rval = false;
std::unique_ptr<json_t> old_json(service_to_json(service, ""));
ss_dassert(old_json.get());
mxb_assert(old_json.get());
if (is_valid_resource_body(new_json) &&
object_to_server_relations(service->name, old_json.get(), new_json) &&
@ -2190,7 +2190,7 @@ bool runtime_alter_service_from_json(Service* service, json_t* new_json)
json_t* parameters = mxs_json_pointer(new_json, MXS_JSON_PTR_PARAMETERS);
json_t* old_parameters = mxs_json_pointer(old_json.get(), MXS_JSON_PTR_PARAMETERS);
ss_dassert(old_parameters);
mxb_assert(old_parameters);
if (parameters)
{
@ -2598,7 +2598,7 @@ bool runtime_alter_maxscale_from_json(json_t* new_json)
{
rval = true;
json_t* old_json = config_maxscale_to_json("");
ss_dassert(old_json);
mxb_assert(old_json);
json_t* new_param = mxs_json_pointer(new_json, MXS_JSON_PTR_PARAMETERS);
json_t* old_param = mxs_json_pointer(old_json, MXS_JSON_PTR_PARAMETERS);

76
server/core/dcb.cc
View File

@ -202,7 +202,7 @@ dcb_alloc(dcb_role_t role, SERV_LISTENER *listener)
else
{
/** Otherwise the DCB is owned by the thread that allocates it */
ss_dassert(RoutingWorker::get_current_id() != -1);
mxb_assert(RoutingWorker::get_current_id() != -1);
newdcb->poll.owner = RoutingWorker::get_current();
}
@ -217,7 +217,7 @@ dcb_alloc(dcb_role_t role, SERV_LISTENER *listener)
static void
dcb_final_free(DCB *dcb)
{
ss_info_dassert(dcb->state == DCB_STATE_DISCONNECTED ||
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.");
@ -243,7 +243,7 @@ dcb_final_free(DCB *dcb)
* been closed.
*/
ss_dassert(dcb->dcb_role == DCB_ROLE_CLIENT_HANDLER ||
mxb_assert(dcb->dcb_role == DCB_ROLE_CLIENT_HANDLER ||
dcb->dcb_role == DCB_ROLE_SERVICE_LISTENER ||
dcb->dcb_role == DCB_ROLE_INTERNAL);
session_put_ref(local_session);
@ -761,7 +761,7 @@ dcb_read_SSL(DCB *dcb, GWBUF **head)
}
}
ss_dassert(gwbuf_length(*head) == (size_t)(start_length + nreadtotal));
mxb_assert(gwbuf_length(*head) == (size_t)(start_length + nreadtotal));
return nsingleread < 0 ? nsingleread : nreadtotal;
}
@ -1035,7 +1035,7 @@ int dcb_drain_writeq(DCB *dcb)
dcb_call_callback(dcb, DCB_REASON_DRAINED);
}
ss_dassert(dcb->writeqlen >= (uint32_t)total_written);
mxb_assert(dcb->writeqlen >= (uint32_t)total_written);
dcb->writeqlen -= total_written;
if (dcb->high_water_reached && DCB_BELOW_LOW_WATER(dcb))
@ -1097,7 +1097,7 @@ void dcb_close(DCB *dcb)
{
MXS_ALERT("dcb_close(%p) called by %d, owned by %d.",
dcb, current->id(), owner->id());
ss_dassert(owner == RoutingWorker::get_current());
mxb_assert(owner == RoutingWorker::get_current());
}
#endif
@ -1141,7 +1141,7 @@ void dcb_close(DCB *dcb)
else
{
RoutingWorker* worker = static_cast<RoutingWorker*>(dcb->poll.owner);
ss_dassert(worker);
mxb_assert(worker);
worker->register_zombie(dcb);
}
@ -1151,14 +1151,14 @@ void dcb_close(DCB *dcb)
++dcb->n_close;
// TODO: Will this happen on a regular basis?
MXS_WARNING("dcb_close(%p) called %u times.", dcb, dcb->n_close);
ss_dassert(!true);
mxb_assert(!true);
}
}
static void cb_dcb_close_in_owning_thread(MXB_WORKER*, void* data)
{
DCB* dcb = static_cast<DCB*>(data);
ss_dassert(dcb);
mxb_assert(dcb);
dcb_close(dcb);
}
@ -1172,7 +1172,7 @@ void dcb_close_in_owning_thread(DCB* dcb)
// TODO: preventing too early a deletion.
MXB_WORKER* worker = static_cast<MXB_WORKER*>(dcb->poll.owner); // The owning worker
ss_dassert(worker);
mxb_assert(worker);
intptr_t arg1 = (intptr_t)cb_dcb_close_in_owning_thread;
intptr_t arg2 = (intptr_t)dcb;
@ -1192,10 +1192,10 @@ void dcb_final_close(DCB* dcb)
{
MXS_ALERT("dcb_final_close(%p) called by %d, owned by %d.",
dcb, current->id(), owner->id());
ss_dassert(owner == current);
mxb_assert(owner == current);
}
#endif
ss_dassert(dcb->n_close != 0);
mxb_assert(dcb->n_close != 0);
if (dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER && // Backend DCB
dcb->state == DCB_STATE_POLLING && // Being polled
@ -2263,7 +2263,7 @@ int dcb_connect_SSL(DCB* dcb)
if ((NULL == dcb->server || NULL == dcb->server->server_ssl) ||
(NULL == dcb->ssl && dcb_create_SSL(dcb, dcb->server->server_ssl) != 0))
{
ss_dassert((NULL != dcb->server) && (NULL != dcb->server->server_ssl));
mxb_assert((NULL != dcb->server) && (NULL != dcb->server->server_ssl));
return -1;
}
dcb->ssl_state = SSL_HANDSHAKE_REQUIRED;
@ -2614,12 +2614,12 @@ int dcb_listen(DCB *dcb, const char *config, const char *protocol_name)
else
{
// We don't have a socket path or a network port
ss_dassert(false);
mxb_assert(false);
}
if (listener_socket < 0)
{
ss_dassert(listener_socket == -1);
mxb_assert(listener_socket == -1);
return -1;
}
@ -2760,7 +2760,7 @@ static void dcb_add_to_list_cb(int thread_id, void* data)
{
DCB *dcb = (DCB*)data;
ss_dassert(thread_id == static_cast<RoutingWorker*>(dcb->poll.owner)->id());
mxb_assert(thread_id == static_cast<RoutingWorker*>(dcb->poll.owner)->id());
dcb_add_to_list(dcb);
}
@ -2776,7 +2776,7 @@ static void dcb_add_to_list(DCB *dcb)
*/
int id = static_cast<RoutingWorker*>(dcb->poll.owner)->id();
ss_dassert(id == RoutingWorker::get_current_id());
mxb_assert(id == RoutingWorker::get_current_id());
if (this_unit.all_dcbs[id] == NULL)
{
@ -2866,7 +2866,7 @@ void dcb_process_idle_sessions(int thr)
{
if (dcb->dcb_role == DCB_ROLE_CLIENT_HANDLER)
{
ss_dassert(dcb->listener);
mxb_assert(dcb->listener);
SERVICE *service = dcb->listener->service;
if (service->conn_idle_timeout && dcb->state == DCB_STATE_POLLING)
@ -2910,7 +2910,7 @@ public:
dcb && atomic_load_int32(&m_more);
dcb = dcb->thread.next)
{
ss_dassert(dcb->session);
mxb_assert(dcb->session);
if (dcb->session->state != SESSION_STATE_DUMMY)
{
@ -2936,7 +2936,7 @@ private:
bool dcb_foreach(bool(*func)(DCB *dcb, void *data), void *data)
{
ss_dassert(RoutingWorker::get_current() == RoutingWorker::get(RoutingWorker::MAIN));
mxb_assert(RoutingWorker::get_current() == RoutingWorker::get(RoutingWorker::MAIN));
SerialDcbTask task(func, data);
RoutingWorker::execute_serially(task);
return task.more();
@ -2971,7 +2971,7 @@ int dcb_get_port(const DCB *dcb)
}
else
{
ss_dassert(dcb->ip.ss_family == AF_UNIX);
mxb_assert(dcb->ip.ss_family == AF_UNIX);
}
return rval;
@ -2980,13 +2980,13 @@ int dcb_get_port(const DCB *dcb)
static uint32_t dcb_process_poll_events(DCB *dcb, uint32_t events)
{
RoutingWorker* owner = static_cast<RoutingWorker*>(dcb->poll.owner);
ss_dassert(owner == RoutingWorker::get_current() ||
mxb_assert(owner == RoutingWorker::get_current() ||
dcb->dcb_role == DCB_ROLE_SERVICE_LISTENER);
uint32_t rc = MXB_POLL_NOP;
/* It isn't obvious that this is impossible */
/* ss_dassert(dcb->state != DCB_STATE_DISCONNECTED); */
/* mxb_assert(dcb->state != DCB_STATE_DISCONNECTED); */
if (DCB_STATE_DISCONNECTED == dcb->state)
{
return rc;
@ -3003,7 +3003,7 @@ static uint32_t dcb_process_poll_events(DCB *dcb, uint32_t events)
{
MXS_WARNING("Events reported for dcb(%p), owned by %d, that has been closed %" PRIu32 " times.",
dcb, owner->id(), dcb->n_close);
ss_dassert(!true);
mxb_assert(!true);
return rc;
}
@ -3241,7 +3241,7 @@ public:
void execute(Worker& worker)
{
ss_dassert(&worker == RoutingWorker::get_current());
mxb_assert(&worker == RoutingWorker::get_current());
RoutingWorker& rworker = static_cast<RoutingWorker&>(worker);
if (dcb_is_still_valid(m_dcb, rworker.id()))
@ -3386,10 +3386,10 @@ public:
{
RoutingWorker& rworker = static_cast<RoutingWorker&>(worker);
ss_dassert(rworker.id() == static_cast<RoutingWorker*>(m_dcb->poll.owner)->id());
mxb_assert(rworker.id() == static_cast<RoutingWorker*>(m_dcb->poll.owner)->id());
bool added = dcb_add_to_worker(&rworker, m_dcb, m_events);
ss_dassert(added);
mxb_assert(added);
if (!added)
{
@ -3442,7 +3442,7 @@ static bool dcb_add_to_worker(Worker* worker, DCB* dcb, uint32_t events)
if (!worker)
{
// No specific worker; indicates the DCB is a listening DCB.
ss_dassert(dcb->dcb_role == DCB_ROLE_SERVICE_LISTENER);
mxb_assert(dcb->dcb_role == DCB_ROLE_SERVICE_LISTENER);
// A listening DCB, we add it immediately.
if (add_fd_to_routing_workers(dcb->fd, events, (MXB_POLL_DATA*)dcb))
@ -3459,7 +3459,7 @@ static bool dcb_add_to_worker(Worker* worker, DCB* dcb, uint32_t events)
// otherwise we must move the adding to the main thread.
// TODO: Separate listening and other DCBs, as this is a mess.
RoutingWorker* worker = static_cast<RoutingWorker*>(dcb->poll.owner);
ss_dassert(worker);
mxb_assert(worker);
intptr_t arg1 = (intptr_t)dcb_add_to_list_cb;
intptr_t arg2 = (intptr_t)dcb;
@ -3475,7 +3475,7 @@ static bool dcb_add_to_worker(Worker* worker, DCB* dcb, uint32_t events)
}
else
{
ss_dassert(worker == dcb->poll.owner);
mxb_assert(worker == dcb->poll.owner);
if (worker == RoutingWorker::get_current())
{
@ -3493,12 +3493,12 @@ static bool dcb_add_to_worker(Worker* worker, DCB* dcb, uint32_t events)
// This will only happen for "cli" and "maxinfo" services that must
// be served by one thread as there otherwise deadlocks can occur.
AddDcbToWorker* task = new (std::nothrow) AddDcbToWorker(dcb, events);
ss_dassert(task);
mxb_assert(task);
if (task)
{
Worker* worker = static_cast<RoutingWorker*>(dcb->poll.owner);
ss_dassert(worker);
mxb_assert(worker);
if (worker->execute(std::unique_ptr<AddDcbToWorker>(task), Worker::EXECUTE_QUEUED))
{
@ -3568,9 +3568,9 @@ int poll_add_dcb(DCB *dcb)
}
else
{
ss_dassert(dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER);
ss_dassert(RoutingWorker::get_current_id() != -1);
ss_dassert(RoutingWorker::get_current() == dcb->poll.owner);
mxb_assert(dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER);
mxb_assert(RoutingWorker::get_current_id() != -1);
mxb_assert(RoutingWorker::get_current() == dcb->poll.owner);
new_state = DCB_STATE_POLLING;
owner = static_cast<RoutingWorker*>(dcb->poll.owner);
@ -3629,7 +3629,7 @@ int poll_remove_dcb(DCB *dcb)
* Only positive fds can be removed from epoll set.
*/
dcbfd = dcb->fd;
ss_dassert(dcbfd > 0 || dcb->dcb_role == DCB_ROLE_INTERNAL);
mxb_assert(dcbfd > 0 || dcb->dcb_role == DCB_ROLE_INTERNAL);
if (dcbfd > 0)
{
@ -3645,7 +3645,7 @@ int poll_remove_dcb(DCB *dcb)
else
{
Worker* worker = static_cast<Worker*>(dcb->poll.owner);
ss_dassert(worker);
mxb_assert(worker);
if (worker->remove_fd(dcbfd))
{
@ -3750,7 +3750,7 @@ json_t* dcb_to_json(DCB* dcb)
if (dcb->func.diagnostics_json)
{
json_t* json = dcb->func.diagnostics_json(dcb);
ss_dassert(json);
mxb_assert(json);
json_object_set_new(obj, "protocol_diagnostics", json);
}

12
server/core/event.cc
View File

@ -354,7 +354,7 @@ bool from_string(id_t* pId, const char* zValue)
void set_log_facility(id_t id, int32_t facility)
{
bool rv = false;
ss_dassert((id >= 0) && (id < N_EVENTS));
mxb_assert((id >= 0) && (id < N_EVENTS));
// We silently strip away other than the relevant bits.
facility = facility & LOG_FACMASK;
@ -366,7 +366,7 @@ void set_log_facility(id_t id, int32_t facility)
int32_t get_log_facility(id_t id)
{
ss_dassert((id >= 0) && (id < N_EVENTS));
mxb_assert((id >= 0) && (id < N_EVENTS));
const EVENT& event = this_unit.events[id];
@ -375,7 +375,7 @@ int32_t get_log_facility(id_t id)
void set_log_level(id_t id, int32_t level)
{
ss_dassert((id >= 0) && (id < N_EVENTS));
mxb_assert((id >= 0) && (id < N_EVENTS));
// We silently strip away other than the relevant bits.
level = level & LOG_PRIMASK;
@ -387,7 +387,7 @@ void set_log_level(id_t id, int32_t level)
int32_t get_log_level(id_t id)
{
ss_dassert((id >= 0) && (id < N_EVENTS));
mxb_assert((id >= 0) && (id < N_EVENTS));
const EVENT& event = this_unit.events[id];
@ -414,7 +414,7 @@ result_t configure(const char* zName, const char* zValue)
id_t id;
if (from_string(&id, event.c_str()))
{
ss_dassert((id >= 0) && (id < N_EVENTS));
mxb_assert((id >= 0) && (id < N_EVENTS));
if (property == CN_FACILITY)
{
@ -450,7 +450,7 @@ void log(id_t event_id,
{
va_list valist;
ss_dassert((event_id >= 0) && (event_id < N_EVENTS));
mxb_assert((event_id >= 0) && (event_id < N_EVENTS));
const EVENT& event = this_unit.events[event_id];

2
server/core/externcmd.cc
View File

@ -173,7 +173,7 @@ static const char* skip_whitespace(const char* ptr)
static const char* skip_prefix(const char* str)
{
const char* ptr = strchr(str, ':');
ss_dassert(ptr);
mxb_assert(ptr);
ptr++;
return skip_whitespace(ptr);

38
server/core/filter.cc
View File

@ -142,11 +142,11 @@ FilterDef::~FilterDef()
*/
void filter_free(const SFilterDef& filter)
{
ss_dassert(filter);
mxb_assert(filter);
// Removing the filter from the list will trigger deletion once it's no longer in use
Guard guard(this_unit.lock);
auto it = std::remove(this_unit.filters.begin(), this_unit.filters.end(), filter);
ss_dassert(it != this_unit.filters.end());
mxb_assert(it != this_unit.filters.end());
this_unit.filters.erase(it);
}
@ -167,14 +167,14 @@ SFilterDef filter_find(const char *name)
bool filter_can_be_destroyed(const SFilterDef& filter)
{
ss_dassert(filter);
mxb_assert(filter);
return !service_filter_in_use(filter);
}
void filter_destroy(const SFilterDef& filter)
{
ss_dassert(filter);
ss_dassert(filter_can_be_destroyed(filter));
mxb_assert(filter);
mxb_assert(filter_can_be_destroyed(filter));
filter_free(filter);
}
@ -195,21 +195,21 @@ void filter_destroy_instances()
const char* filter_def_get_name(const MXS_FILTER_DEF* filter_def)
{
const FilterDef* filter = static_cast<const FilterDef*>(filter_def);
ss_dassert(filter);
mxb_assert(filter);
return filter->name.c_str();
}
const char* filter_def_get_module_name(const MXS_FILTER_DEF* filter_def)
{
const FilterDef* filter = static_cast<const FilterDef*>(filter_def);
ss_dassert(filter);
mxb_assert(filter);
return filter->module.c_str();
}
MXS_FILTER* filter_def_get_instance(const MXS_FILTER_DEF* filter_def)
{
const FilterDef* filter = static_cast<const FilterDef*>(filter_def);
ss_dassert(filter);
mxb_assert(filter);
return filter->filter;
}
@ -262,7 +262,7 @@ dprintAllFilters(DCB *dcb)
*/
void dprintFilter(DCB *dcb, const SFilterDef& filter)
{
ss_dassert(filter);
mxb_assert(filter);
dcb_printf(dcb, "FilterDef %p (%s)\n", filter.get(), filter->name.c_str());
dcb_printf(dcb, "\tModule: %s\n", filter->module.c_str());
if (filter->obj && filter->filter)
@ -310,7 +310,7 @@ dListFilters(DCB *dcb)
void
filter_add_parameter(SFilterDef& filter, const char *name, const char *value)
{
ss_dassert(filter);
mxb_assert(filter);
CONFIG_CONTEXT ctx = {};
ctx.object = (char*)"";
@ -333,7 +333,7 @@ filter_add_parameter(SFilterDef& filter, const char *name, const char *value)
*/
MXS_DOWNSTREAM* filter_apply(const SFilterDef& filter, MXS_SESSION *session, MXS_DOWNSTREAM *downstream)
{
ss_dassert(filter);
mxb_assert(filter);
MXS_DOWNSTREAM *me;
if ((me = (MXS_DOWNSTREAM *)MXS_CALLOC(1, sizeof(MXS_DOWNSTREAM))) == NULL)
@ -368,7 +368,7 @@ MXS_DOWNSTREAM* filter_apply(const SFilterDef& filter, MXS_SESSION *session, MXS
*/
MXS_UPSTREAM* filter_upstream(const SFilterDef& filter, MXS_FILTER_SESSION *fsession, MXS_UPSTREAM *upstream)
{
ss_dassert(filter);
mxb_assert(filter);
MXS_UPSTREAM *me = NULL;
/*
@ -396,7 +396,7 @@ MXS_UPSTREAM* filter_upstream(const SFilterDef& filter, MXS_FILTER_SESSION *fses
json_t* filter_parameters_to_json(const SFilterDef& filter)
{
ss_dassert(filter);
mxb_assert(filter);
json_t* rval = json_object();
/** Add custom module parameters */
@ -409,7 +409,7 @@ json_t* filter_parameters_to_json(const SFilterDef& filter)
json_t* filter_json_data(const SFilterDef& filter, const char* host)
{
ss_dassert(filter);
mxb_assert(filter);
json_t* rval = json_object();
json_object_set_new(rval, CN_ID, json_string(filter->name.c_str()));
@ -443,7 +443,7 @@ json_t* filter_json_data(const SFilterDef& filter, const char* host)
json_t* filter_to_json(const SFilterDef& filter, const char* host)
{
ss_dassert(filter);
mxb_assert(filter);
string self = MXS_JSON_API_FILTERS;
self += filter->name;
return mxs_json_resource(host, self.c_str(), filter_json_data(filter, host));
@ -521,7 +521,7 @@ json_t* FilterSession::diagnostics_json() const
static bool create_filter_config(const SFilterDef& filter, const char *filename)
{
ss_dassert(filter);
mxb_assert(filter);
int file = open(filename, O_EXCL | O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
if (file == -1)
@ -537,7 +537,7 @@ static bool create_filter_config(const SFilterDef& filter, const char *filename)
dprintf(file, "%s=%s\n", CN_TYPE, CN_FILTER);
const MXS_MODULE* mod = get_module(filter->module.c_str(), NULL);
ss_dassert(mod);
mxb_assert(mod);
MXS_MODULE_PARAM no_common_params = {};
dump_param_list(file, filter->parameters, {CN_TYPE}, &no_common_params, mod->parameters);
@ -548,7 +548,7 @@ static bool create_filter_config(const SFilterDef& filter, const char *filename)
bool filter_serialize(const SFilterDef& filter)
{
ss_dassert(filter);
mxb_assert(filter);
bool rval = false;
char filename[PATH_MAX];
snprintf(filename, sizeof(filename), "%s/%s.cnf.tmp", get_config_persistdir(),
@ -565,7 +565,7 @@ bool filter_serialize(const SFilterDef& filter)
strcpy(final_filename, filename);
char *dot = strrchr(final_filename, '.');
ss_dassert(dot);
mxb_assert(dot);
*dot = '\0';
if (rename(filename, final_filename) == 0)

8
server/core/gateway.cc
View File

@ -1329,7 +1329,7 @@ int main(int argc, char **argv)
char* tmp_path;
int option_index;
MXS_CONFIG* cnf = config_get_global_options();
ss_dassert(cnf);
mxb_assert(cnf);
int *syslog_enabled = &cnf->syslog; /** Log to syslog */
int *maxlog_enabled = &cnf->maxlog; /** Log with MaxScale */
sigset_t sigpipe_mask;
@ -1343,7 +1343,7 @@ int main(int argc, char **argv)
config_init();
config_set_global_defaults();
ss_dassert(cnf);
mxb_assert(cnf);
maxscale_reset_starttime();
@ -2144,7 +2144,7 @@ int main(int argc, char **argv)
/**
* Successful start, notify the parent process that it can exit.
*/
ss_dassert(rc == MAXSCALE_SHUTDOWN);
mxb_assert(rc == MAXSCALE_SHUTDOWN);
if (daemon_mode)
{
write_child_exit_code(daemon_pipe[1], rc);
@ -2154,7 +2154,7 @@ int main(int argc, char **argv)
* Run worker 0 in the main thread.
*/
worker = RoutingWorker::get(RoutingWorker::MAIN);
ss_dassert(worker);
mxb_assert(worker);
worker->run();
/** Stop administrative interface */

2
server/core/hint.cc
View File

@ -125,7 +125,7 @@ hint_create_route(HINT *head, HINT_TYPE type, const char *data)
HINT *
hint_splice(HINT *head, HINT *list)
{
ss_dassert(list);
mxb_assert(list);
if (head)
{
HINT* tail = list;

18
server/core/housekeeper.cc
View File

@ -139,8 +139,8 @@ bool Housekeeper::init()
bool Housekeeper::start()
{
ss_dassert(hk); // init() has been called.
ss_dassert(hk->m_thread.get_id() == std::thread::id()); // start has not been called.
mxb_assert(hk); // init() has been called.
mxb_assert(hk->m_thread.get_id() == std::thread::id()); // start has not been called.
struct hkstart_result res;
sem_init(&res.sem, 0, 0);
@ -194,8 +194,8 @@ void Housekeeper::run()
void Housekeeper::stop()
{
ss_dassert(hk); // init() has been called.
ss_dassert(hk->m_thread.get_id() != std::thread::id()); // start has been called.
mxb_assert(hk); // init() has been called.
mxb_assert(hk->m_thread.get_id() != std::thread::id()); // start has been called.
atomic_store_uint32(&m_running, 0);
m_thread.join();
@ -242,7 +242,7 @@ json_t* Housekeeper::tasks_json(const char* host)
localtime_r(&ptr->nextdue, &tm);
asctime_r(&tm, buf);
char* nl = strchr(buf, '\n');
ss_dassert(nl);
mxb_assert(nl);
*nl = '\0';
json_t* obj = json_object();
@ -265,14 +265,14 @@ json_t* Housekeeper::tasks_json(const char* host)
void hktask_add(const char *name, TASKFN func, void *data, int frequency)
{
ss_dassert(hk);
mxb_assert(hk);
Task task(name, func, data, frequency);
hk->add(task);
}
void hktask_remove(const char *name)
{
ss_dassert(hk);
mxb_assert(hk);
hk->remove(name);
}
@ -321,12 +321,12 @@ void hkfinish()
void hkshow_tasks(DCB *pDcb)
{
ss_dassert(hk);
mxb_assert(hk);
hk->print_tasks(pDcb);
}
json_t* hk_tasks_json(const char* host)
{
ss_dassert(hk);
mxb_assert(hk);
return hk->tasks_json(host);
}

4
server/core/internal/session.hh
View File

@ -98,13 +98,13 @@ public:
void link_backend_dcb(DCB* dcb)
{
ss_dassert(m_dcb_set.count(dcb) == 0);
mxb_assert(m_dcb_set.count(dcb) == 0);
m_dcb_set.insert(dcb);
}
void unlink_backend_dcb(DCB* dcb)
{
ss_dassert(m_dcb_set.count(dcb) == 1);
mxb_assert(m_dcb_set.count(dcb) == 1);
m_dcb_set.erase(dcb);
}

8
server/core/json_api.cc
View File

@ -40,7 +40,7 @@ static json_t* self_link(const char* host, const char* endpoint)
json_t* mxs_json_resource(const char* host, const char* self, json_t* data)
{
ss_dassert(data && (json_is_array(data) || json_is_object(data) || json_is_null(data)));
mxb_assert(data && (json_is_array(data) || json_is_object(data) || json_is_null(data)));
json_t* rval = json_object();
json_object_set_new(rval, CN_LINKS, self_link(host, self));
json_object_set_new(rval, CN_DATA, data);
@ -70,7 +70,7 @@ json_t* mxs_json_relationship(const char* host, const char* endpoint)
void mxs_json_add_relation(json_t* rel, const char* id, const char* type)
{
json_t* data = json_object_get(rel, CN_DATA);
ss_dassert(data && json_is_array(data));
mxb_assert(data && json_is_array(data));
json_t* obj = json_object();
json_object_set_new(obj, CN_ID, json_string(id));
@ -213,8 +213,8 @@ static json_t* json_error_append(json_t* obj, const char* message)
json_t* err = json_error_detail(message);
json_t* arr = json_object_get(obj, ERRORS);
ss_dassert(arr);
ss_dassert(json_is_array(arr));
mxb_assert(arr);
mxb_assert(json_is_array(arr));
if (arr)
{

16
server/core/listener.cc
View File

@ -267,7 +267,7 @@ static const char* get_ssl_errors()
bool SSL_LISTENER_init(SSL_LISTENER* ssl)
{
ss_dassert(!ssl->ssl_init_done);
mxb_assert(!ssl->ssl_init_done);
bool rval = true;
switch (ssl->ssl_method_type)
@ -335,11 +335,11 @@ bool SSL_LISTENER_init(SSL_LISTENER* ssl)
}
else
{
ss_dassert(rsa_512 && rsa_1024);
mxb_assert(rsa_512 && rsa_1024);
SSL_CTX_set_tmp_rsa_callback(ctx, tmp_rsa_callback);
}
ss_dassert(ssl->ssl_ca_cert);
mxb_assert(ssl->ssl_ca_cert);
/* Load the CA certificate into the SSL_CTX structure */
if (!SSL_CTX_load_verify_locations(ctx, ssl->ssl_ca_cert, NULL))
@ -512,7 +512,7 @@ bool listener_serialize(const SERV_LISTENER *listener)
strcpy(final_filename, filename);
char *dot = strrchr(final_filename, '.');
ss_dassert(dot);
mxb_assert(dot);
*dot = '\0';
if (rename(filename, final_filename) == 0)
@ -590,14 +590,14 @@ static inline SERV_LISTENER* load_port(SERV_LISTENER const *const *const port)
SERV_LISTENER* listener_iterator_init(const SERVICE* service, LISTENER_ITERATOR* iter)
{
ss_dassert(iter);
mxb_assert(iter);
iter->current = load_port(&service->ports);
return iter->current;
}
SERV_LISTENER* listener_iterator_next(LISTENER_ITERATOR* iter)
{
ss_dassert(iter);
mxb_assert(iter);
if (iter->current)
{
@ -609,7 +609,7 @@ SERV_LISTENER* listener_iterator_next(LISTENER_ITERATOR* iter)
const char* listener_state_to_string(const SERV_LISTENER* listener)
{
ss_dassert(listener);
mxb_assert(listener);
if (listener->listener && listener->listener->session)
{
@ -622,7 +622,7 @@ const char* listener_state_to_string(const SERV_LISTENER* listener)
return "Running";
default:
ss_dassert(!true);
mxb_assert(!true);
return "Unknown";
}
}

8
server/core/load_utils.cc
View File

@ -116,7 +116,7 @@ static bool api_version_mismatch(const MXS_MODULE *mod_info, const char* module)
default:
MXS_ERROR("Unknown module type: 0x%02hhx", mod_info->modapi);
ss_dassert(!true);
mxb_assert(!true);
break;
}
@ -196,7 +196,7 @@ static bool check_module(const MXS_MODULE *mod_info, const char *type, const cha
void *load_module(const char *module, const char *type)
{
ss_dassert(module && type);
mxb_assert(module && type);
LOADED_MODULE *mod;
module = mxs_module_get_effective_name(module);
@ -480,7 +480,7 @@ bool modulecmd_cb(const MODULECMD *cmd, void *data)
std::string s = d->domain;
s += "/";
s += cmd->identifier;
ss_dassert(strcasecmp(d->domain, cmd->domain) == 0);
mxb_assert(strcasecmp(d->domain, cmd->domain) == 0);
json_object_set_new(obj, CN_LINKS, mxs_json_self_link(d->host, CN_MODULES, s.c_str()));
json_object_set_new(attr, CN_PARAMETERS, param);
@ -561,7 +561,7 @@ json_t* module_to_json(const MXS_MODULE* module, const char* host)
}
// This should always be non-NULL
ss_dassert(data);
mxb_assert(data);
return mxs_json_resource(host, MXS_JSON_API_MODULES, data);
}

2
server/core/log.cc
View File

@ -33,7 +33,7 @@ const char* LOGFILE_NAME = "maxscale.log";
size_t mxs_get_context(char* buffer, size_t len)
{
ss_dassert(len >= 20); // Needed for "9223372036854775807"
mxb_assert(len >= 20); // Needed for "9223372036854775807"
uint64_t session_id = session_get_current_id();

14
server/core/mariadb.cc
View File

@ -38,7 +38,7 @@ int get_info(MYSQL* pMysql, Callback pCallback, void* pCollection)
if (pResult)
{
ss_dassert(mysql_field_count(pMysql) == 5);
mxb_assert(mysql_field_count(pMysql) == 5);
MYSQL_ROW row;
@ -47,11 +47,11 @@ int get_info(MYSQL* pMysql, Callback pCallback, void* pCollection)
char* pEnd;
int64_t total = strtoll(row[2], &pEnd, 0);
ss_dassert(*pEnd == 0);
mxb_assert(*pEnd == 0);
int64_t used = strtoll(row[3], &pEnd, 0);
ss_dassert(*pEnd == 0);
mxb_assert(*pEnd == 0);
int64_t available = strtoll(row[4], &pEnd, 0);
ss_dassert(*pEnd == 0);
mxb_assert(*pEnd == 0);
pCallback(pCollection, row[0], row[1], total, used, available);
}
@ -101,9 +101,9 @@ void add_info_by_disk(std::map<std::string, disk::SizesAndPaths>* pSizes,
{
disk::SizesAndPaths& item = i->second;
ss_dassert(total == item.total());
ss_dassert(used == item.used());
ss_dassert(available == item.available());
mxb_assert(total == item.total());
mxb_assert(used == item.used());
mxb_assert(available == item.available());
item.add_path(zPath);
}

6
server/core/maxscale_pcre2.cc
View File

@ -141,8 +141,8 @@ mxs_pcre2_result_t mxs_pcre2_simple_match(const char* pattern, const char* subje
void mxs_pcre2_print_error(int errorcode, const char *module_name, const char *filename,
int line_num, const char* func_name)
{
ss_dassert(filename);
ss_dassert(func_name);
mxb_assert(filename);
mxb_assert(func_name);
if (mxs_log_is_priority_enabled(LOG_ERR))
{
// 120 should be enough to contain any error message according to pcre2 manual.
@ -158,7 +158,7 @@ bool mxs_pcre2_check_match_exclude(pcre2_code* re_match, pcre2_code* re_exclude,
pcre2_match_data* md, const char* subject,
int length, const char* calling_module)
{
ss_dassert((!re_match && !re_exclude) || (md && subject));
mxb_assert((!re_match && !re_exclude) || (md && subject));
bool rval = true;
int string_len = ((size_t)length == PCRE2_ZERO_TERMINATED) ? strlen(subject) : length;
if (re_match)

8
server/core/modulecmd.cc
View File

@ -143,8 +143,8 @@ static MODULECMD* command_create(const char *identifier, const char *domain,
int argc, modulecmd_arg_type_t* argv,
const char *description)
{
ss_dassert((argc && argv) || (argc == 0 && argv == NULL));
ss_dassert(description);
mxb_assert((argc && argv) || (argc == 0 && argv == NULL));
mxb_assert(description);
MODULECMD *rval = (MODULECMD*)MXS_MALLOC(sizeof(*rval));
char *id = MXS_STRDUP(identifier);
char *dm = MXS_STRDUP(domain);
@ -361,7 +361,7 @@ static bool process_argument(const MODULECMD *cmd, modulecmd_arg_type_t *type, c
break;
default:
ss_dassert(false);
mxb_assert(false);
MXS_ERROR("Undefined argument type: %0lx", type->type);
*err = "internal error";
break;
@ -715,7 +715,7 @@ const char* modulecmd_argtype_to_str(modulecmd_arg_type_t *type)
break;
default:
ss_dassert(false);
mxb_assert(false);
MXS_ERROR("Unknown type");
break;
}

30
server/core/modutil.cc
View File

@ -346,7 +346,7 @@ modutil_get_query(GWBUF *buf)
{
if (len >= 1 && len <= ~(size_t)0 - 1)
{
ss_dassert(!query_str);
mxb_assert(!query_str);
}
goto retblock;
}
@ -360,7 +360,7 @@ modutil_get_query(GWBUF *buf)
{
if (len >= 1 && len <= ~(size_t)0 - 1)
{
ss_dassert(!query_str);
mxb_assert(!query_str);
}
goto retblock;
}
@ -423,7 +423,7 @@ GWBUF *modutil_create_mysql_err_msg(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)
{
@ -490,7 +490,7 @@ int modutil_send_mysql_err_packet(DCB *dcb,
// Helper function for debug assertions
static bool only_one_packet(GWBUF* buffer)
{
ss_dassert(buffer);
mxb_assert(buffer);
uint8_t header[4] = {};
gwbuf_copy_data(buffer, 0, MYSQL_HEADER_LEN, header);
size_t packet_len = gw_mysql_get_byte3(header);
@ -542,7 +542,7 @@ GWBUF* modutil_get_next_MySQL_packet(GWBUF** p_readbuf)
}
}
ss_dassert(!packet || only_one_packet(packet));
mxb_assert(!packet || only_one_packet(packet));
return packet;
}
@ -593,7 +593,7 @@ static size_t get_complete_packets_length(GWBUF *buffer)
/** The buffer chain contains at least one incomplete packet */
else
{
ss_dassert(!buffer);
mxb_assert(!buffer);
break;
}
}
@ -633,8 +633,8 @@ GWBUF* modutil_get_complete_packets(GWBUF **p_readbuf)
#endif
complete = gwbuf_split(p_readbuf, total);
#ifdef SS_DEBUG
ss_dassert(gwbuf_length(complete) == total);
ss_dassert(*p_readbuf == NULL || before - total == gwbuf_length(*p_readbuf));
mxb_assert(gwbuf_length(complete) == total);
mxb_assert(*p_readbuf == NULL || before - total == gwbuf_length(*p_readbuf));
#endif
}
return complete;
@ -1041,7 +1041,7 @@ bool is_mysql_sp_end(const char* start, int len)
*/
GWBUF* modutil_create_query(const char* query)
{
ss_dassert(query);
mxb_assert(query);
size_t len = strlen(query) + 1; // Query plus the command byte
GWBUF* rval = gwbuf_alloc(len + MYSQL_HEADER_LEN);
@ -1232,7 +1232,7 @@ mxs_pcre2_result_t modutil_mysql_wildcard_match(const char* pattern, const char*
static inline bool is_next(mxs::Buffer::iterator it, mxs::Buffer::iterator end, const std::string& str)
{
ss_dassert(it != end);
mxb_assert(it != end);
for (auto s_it = str.begin(); s_it != str.end(); ++s_it, ++it)
{
if (it == end || *it != *s_it)
@ -1247,8 +1247,8 @@ static inline bool is_next(mxs::Buffer::iterator it, mxs::Buffer::iterator end,
static std::pair<bool, mxs::Buffer::iterator> probe_number(mxs::Buffer::iterator it,
mxs::Buffer::iterator end)
{
ss_dassert(it != end);
ss_dassert(isdigit(*it));
mxb_assert(it != end);
mxb_assert(isdigit(*it));
std::pair<bool, mxs::Buffer::iterator> rval = std::make_pair(true, it);
bool is_hex = *it == '0';
bool allow_hex = false;
@ -1302,7 +1302,7 @@ static std::pair<bool, mxs::Buffer::iterator> probe_number(mxs::Buffer::iterator
rval.first = false;
break;
}
ss_dassert(isdigit(*next_it));
mxb_assert(isdigit(*next_it));
}
else
{
@ -1568,7 +1568,7 @@ char* modutil_MySQL_bypass_whitespace(char* sql, size_t len)
if (i != end)
{
ss_dassert(*i == '\n');
mxb_assert(*i == '\n');
++i;
}
}
@ -1592,7 +1592,7 @@ char* modutil_MySQL_bypass_whitespace(char* sql, size_t len)
if (i != end)
{
ss_dassert(*i == '\n');
mxb_assert(*i == '\n');
++i;
}
break;

68
server/core/monitor.cc
View File

@ -351,7 +351,7 @@ monitor_stop_all()
*/
bool monitor_add_server(MXS_MONITOR *mon, SERVER *server)
{
ss_dassert(mon && server);
mxb_assert(mon && server);
bool rval = false;
if (monitor_server_in_use(server))
@ -647,7 +647,7 @@ MXS_MONITOR* monitor_repurpose_destroyed(const char* name, const char* module)
{
if (strcmp(ptr->name, name) == 0 && strcmp(ptr->module_name, module) == 0)
{
ss_dassert(!ptr->active);
mxb_assert(!ptr->active);
ptr->active = true;
rval = ptr;
}
@ -719,7 +719,7 @@ bool monitor_set_network_timeout(MXS_MONITOR *mon, int type, int value, const ch
default:
MXS_ERROR("Monitor setNetworkTimeout received an unsupported action type %i", type);
ss_dassert(!true);
mxb_assert(!true);
rval = false;
break;
}
@ -972,7 +972,7 @@ static mxs_monitor_event_t mon_get_event_type(MXS_MONITORED_SERVER* node)
if (prev == present)
{
/* This should never happen */
ss_dassert(false);
mxb_assert(false);
return UNDEFINED_EVENT;
}
@ -986,7 +986,7 @@ static mxs_monitor_event_t mon_get_event_type(MXS_MONITORED_SERVER* node)
else
{
/* Otherwise, was not running and still is not running. This should never happen. */
ss_dassert(false);
mxb_assert(false);
}
}
else
@ -1056,11 +1056,11 @@ static mxs_monitor_event_t mon_get_event_type(MXS_MONITORED_SERVER* node)
default:
/* This should never happen */
ss_dassert(false);
mxb_assert(false);
break;
}
ss_dassert(rval != UNDEFINED_EVENT);
mxb_assert(rval != UNDEFINED_EVENT);
return rval;
}
@ -1074,7 +1074,7 @@ const char* mon_get_event_name(mxs_monitor_event_t event)
}
}
ss_dassert(!true);
mxb_assert(!true);
return "undefined_event";
}
@ -1342,7 +1342,7 @@ int monitor_launch_command(MXS_MONITOR* mon, MXS_MONITORED_SERVER* ptr, EXTERNCM
}
else
{
ss_dassert(cmd->argv != NULL && cmd->argv[0] != NULL);
mxb_assert(cmd->argv != NULL && cmd->argv[0] != NULL);
// Construct a string with the script + arguments
char *scriptStr = NULL;
int totalStrLen = 0;
@ -1370,7 +1370,7 @@ int monitor_launch_command(MXS_MONITOR* mon, MXS_MONITORED_SERVER* ptr, EXTERNCM
currentPos += len;
spaceRemaining -= len;
}
ss_dassert(spaceRemaining > 0);
mxb_assert(spaceRemaining > 0);
*currentPos = '\0';
}
else
@ -1497,7 +1497,7 @@ bool mon_connection_is_ok(mxs_connect_result_t connect_result)
*/
void mon_log_connect_error(MXS_MONITORED_SERVER* database, mxs_connect_result_t rval)
{
ss_dassert(!mon_connection_is_ok(rval) && database);
mxb_assert(!mon_connection_is_ok(rval) && database);
const char TIMED_OUT[] = "Monitor timed out when connecting to server %s[%s:%d] : '%s'";
const char REFUSED[] = "Monitor was unable to connect to server %s[%s:%d] : '%s'";
auto srv = database->server;
@ -1578,7 +1578,7 @@ static bool create_monitor_config(const MXS_MONITOR *monitor, const char *filena
}
const MXS_MODULE* mod = get_module(monitor->module_name, NULL);
ss_dassert(mod);
mxb_assert(mod);
dump_param_list(file, monitor->parameters, {CN_TYPE, CN_SERVERS},
config_monitor_params, mod->parameters);
@ -1606,7 +1606,7 @@ bool monitor_serialize(const MXS_MONITOR *monitor)
strcpy(final_filename, filename);
char *dot = strrchr(final_filename, '.');
ss_dassert(dot);
mxb_assert(dot);
*dot = '\0';
if (rename(filename, final_filename) == 0)
@ -1735,7 +1735,7 @@ static const char* monitor_state_to_string(monitor_state_t state)
return "Stopped";
default:
ss_dassert(false);
mxb_assert(false);
return "Unknown";
}
}
@ -1950,7 +1950,7 @@ static void store_data(MXS_MONITOR *monitor, MXS_MONITORED_SERVER *master, uint8
uint8_t* ptr = data;
/** Store the data length */
ss_dassert(sizeof(size) == MMB_LEN_BYTES);
mxb_assert(sizeof(size) == MMB_LEN_BYTES);
ptr = mxs_set_byte4(ptr, size);
/** Then the schema version */
@ -1981,10 +1981,10 @@ static void store_data(MXS_MONITOR *monitor, MXS_MONITORED_SERVER *master, uint8
/** Calculate the CRC32 for the complete payload minus the CRC32 bytes */
uint32_t crc = crc32(0L, NULL, 0);
crc = crc32(crc, (uint8_t*)data + MMB_LEN_BYTES, size - MMB_LEN_CRC32);
ss_dassert(sizeof(crc) == MMB_LEN_CRC32);
mxb_assert(sizeof(crc) == MMB_LEN_CRC32);
ptr = mxs_set_byte4(ptr, crc);
ss_dassert(ptr - data == size + MMB_LEN_BYTES);
mxb_assert(ptr - data == size + MMB_LEN_BYTES);
}
static int get_data_file_path(MXS_MONITOR *monitor, char *path)
@ -2048,7 +2048,7 @@ static const char* process_server(MXS_MONITOR *monitor, const char *data, const
if (strcmp(db->server->name, data) == 0)
{
const unsigned char *sptr = (unsigned char*)strchr(data, '\0');
ss_dassert(sptr);
mxb_assert(sptr);
sptr++;
uint64_t status = maxscale::get_byteN(sptr, MMB_LEN_SERVER_STATUS);
@ -2133,11 +2133,11 @@ static bool process_data_file(MXS_MONITOR *monitor, MXS_MONITORED_SERVER **maste
MXS_ERROR("Possible corrupted journal file (unknown stored value). Ignoring.");
return false;
}
ss_dassert(prevptr != ptr);
mxb_assert(prevptr != ptr);
MXB_AT_DEBUG(prevptr = ptr);
}
ss_dassert(ptr == crc_ptr);
mxb_assert(ptr == crc_ptr);
return true;
}
@ -2213,7 +2213,7 @@ void load_server_journal(MXS_MONITOR *monitor, MXS_MONITORED_SERVER **master)
{
uint32_t size = 0;
size_t bytes = fread(&size, 1, MMB_LEN_BYTES, file);
ss_dassert(sizeof(size) == MMB_LEN_BYTES);
mxb_assert(sizeof(size) == MMB_LEN_BYTES);
if (bytes == MMB_LEN_BYTES)
{
@ -2333,7 +2333,7 @@ static bool journal_is_stale(MXS_MONITOR *monitor, time_t max_age)
MXS_MONITORED_SERVER* mon_get_monitored_server(const MXS_MONITOR* mon, SERVER* search_server)
{
ss_dassert(mon && search_server);
mxb_assert(mon && search_server);
for (MXS_MONITORED_SERVER* iter = mon->monitored_servers; iter != NULL; iter = iter->next)
{
if (iter->server == search_server)
@ -2347,7 +2347,7 @@ MXS_MONITORED_SERVER* mon_get_monitored_server(const MXS_MONITOR* mon, SERVER* s
int mon_config_get_servers(const MXS_CONFIG_PARAMETER* params, const char* key, const MXS_MONITOR* mon,
MXS_MONITORED_SERVER*** monitored_servers_out)
{
ss_dassert(monitored_servers_out != NULL && *monitored_servers_out == NULL);
mxb_assert(monitored_servers_out != NULL && *monitored_servers_out == NULL);
SERVER** servers = NULL;
int servers_size = config_get_server_list(params, key, &servers);
int found = 0;
@ -2371,7 +2371,7 @@ int mon_config_get_servers(const MXS_CONFIG_PARAMETER* params, const char* key,
}
MXS_FREE(servers);
ss_dassert(found <= servers_size);
mxb_assert(found <= servers_size);
if (found == 0)
{
MXS_FREE(monitored_array);
@ -2441,11 +2441,11 @@ void MonitorInstance::stop()
{
// This should only be called by monitor_stop(). NULL worker is allowed since the main worker may
// not exist during program start/stop.
ss_dassert(mxs_rworker_get_current() == NULL ||
mxb_assert(mxs_rworker_get_current() == NULL ||
mxs_rworker_get_current() == mxs_rworker_get(MXS_RWORKER_MAIN));
ss_dassert(Worker::state() != Worker::STOPPED);
ss_dassert(monitor_state() == MONITOR_STATE_STOPPING);
ss_dassert(m_thread_running.load() == true);
mxb_assert(Worker::state() != Worker::STOPPED);
mxb_assert(monitor_state() == MONITOR_STATE_STOPPING);
mxb_assert(m_thread_running.load() == true);
Worker::shutdown();
Worker::join();
@ -2465,11 +2465,11 @@ bool MonitorInstance::start(const MXS_CONFIG_PARAMETER* pParams)
{
// This should only be called by monitor_start(). NULL worker is allowed since the main worker may
// not exist during program start/stop.
ss_dassert(mxs_rworker_get_current() == NULL ||
mxb_assert(mxs_rworker_get_current() == NULL ||
mxs_rworker_get_current() == mxs_rworker_get(MXS_RWORKER_MAIN));
ss_dassert(Worker::state() == Worker::STOPPED);
ss_dassert(monitor_state() == MONITOR_STATE_STOPPED);
ss_dassert(m_thread_running.load() == false);
mxb_assert(Worker::state() == Worker::STOPPED);
mxb_assert(monitor_state() == MONITOR_STATE_STOPPED);
mxb_assert(m_thread_running.load() == false);
if (!m_checked)
{
@ -2521,7 +2521,7 @@ int64_t MonitorInstance::get_time_ms()
timespec t;
MXB_AT_DEBUG(int rv = )clock_gettime(CLOCK_MONOTONIC_COARSE, &t);
ss_dassert(rv == 0);
mxb_assert(rv == 0);
return t.tv_sec * 1000 + (t.tv_nsec / 1000000);
}
@ -2584,7 +2584,7 @@ void MonitorInstance::update_disk_space_status(MXS_MONITORED_SERVER* pMs)
MxsDiskSpaceThreshold* pDst =
pMs->server->disk_space_threshold ?
pMs->server->disk_space_threshold : m_monitor->disk_space_threshold;
ss_dassert(pDst);
mxb_assert(pDst);
int32_t star_max_percentage = -1;

12
server/core/mysql_binlog.cc
View File

@ -101,7 +101,7 @@ const char* column_type_to_string(uint8_t type)
case TABLE_COL_TYPE_GEOMETRY:
return "GEOMETRY";
default:
ss_dassert(false);
mxb_assert(false);
break;
}
return "UNKNOWN";
@ -535,7 +535,7 @@ size_t unpack_temporal_value(uint8_t type, uint8_t *ptr, uint8_t *metadata, int
break;
default:
ss_dassert(false);
mxb_assert(false);
break;
}
return temporal_field_size(type, metadata, length);
@ -569,7 +569,7 @@ void format_temporal_value(char *str, size_t size, uint8_t type, struct tm *tm)
default:
MXS_ERROR("Unexpected temporal type: %x %s", type, column_type_to_string(type));
ss_dassert(false);
mxb_assert(false);
break;
}
strftime(str, size, format, tm);
@ -620,7 +620,7 @@ size_t unpack_numeric_field(uint8_t *src, uint8_t type, uint8_t *metadata, uint8
break;
}
ss_dassert(size > 0);
mxb_assert(size > 0);
memcpy(dest, src, size);
return size;
}
@ -669,7 +669,7 @@ static uint64_t unpack_bytes(uint8_t *ptr, size_t bytes)
break;
default:
ss_dassert(false);
mxb_assert(false);
break;
}
@ -715,7 +715,7 @@ size_t unpack_decimal_field(uint8_t *ptr, uint8_t *metadata, double *val_float)
int extra = ibytes - 8;
ptr += extra;
ibytes -= extra;
ss_dassert(ibytes == 8);
mxb_assert(ibytes == 8);
}
val_i = unpack_bytes(ptr, ibytes);

4
server/core/mysql_utils.cc
View File

@ -103,7 +103,7 @@ uint64_t mxs_leint_value(const uint8_t* c)
}
else
{
ss_dassert(*c == 0xff);
mxb_assert(*c == 0xff);
MXS_ERROR("Unexpected length encoding '%x' encountered when reading "
"length-encoded integer.", *c);
}
@ -302,7 +302,7 @@ bool mxs_mysql_trim_quotes(char *s)
--end;
}
ss_dassert(end > i);
mxb_assert(end > i);
char quote;

4
server/core/poll.cc
View File

@ -146,7 +146,7 @@ dShowThreads(DCB *dcb)
for (int i = 0; i < n_threads; i++)
{
Worker* worker = RoutingWorker::get(i);
ss_dassert(worker);
mxb_assert(worker);
const char *state = "Unknown";
@ -169,7 +169,7 @@ dShowThreads(DCB *dcb)
break;
default:
ss_dassert(!true);
mxb_assert(!true);
}
uint32_t nCurrent;

76
server/core/query_classifier.cc
View File

@ -119,7 +119,7 @@ public:
~QCInfoCache()
{
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
for (auto a : m_infos)
{
@ -146,7 +146,7 @@ public:
if (entry.sql_mode == this_unit.qc_sql_mode)
{
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
this_unit.classifier->qc_info_dup(entry.pInfo);
pInfo = entry.pInfo;
@ -170,8 +170,8 @@ public:
void insert(const std::string& canonical_stmt, QC_STMT_INFO* pInfo)
{
ss_dassert(peek(canonical_stmt) == nullptr);
ss_dassert(this_unit.classifier);
mxb_assert(peek(canonical_stmt) == nullptr);
mxb_assert(this_unit.classifier);
int64_t cache_max_size = this_unit.cache_max_size();
int64_t size = canonical_stmt.size();
@ -219,11 +219,11 @@ private:
void erase(InfosByStmt::iterator& i)
{
ss_dassert(i != m_infos.end());
mxb_assert(i != m_infos.end());
m_stats.size -= i->first.size();
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
this_unit.classifier->qc_info_close(i->second.pInfo);
m_infos.erase(i);
@ -236,7 +236,7 @@ private:
bool erased = false;
auto i = m_infos.find(canonical_stmt);
ss_dassert(i != m_infos.end());
mxb_assert(i != m_infos.end());
if (i != m_infos.end())
{
@ -264,7 +264,7 @@ private:
int64_t freed_space = 0;
int bucket = dis(m_reng);
ss_dassert((bucket >= 0) && (bucket < static_cast<int>(m_infos.bucket_count())));
mxb_assert((bucket >= 0) && (bucket < static_cast<int>(m_infos.bucket_count())));
auto i = m_infos.begin(bucket);
@ -275,7 +275,7 @@ private:
freed_space += i->first.size();
MXB_AT_DEBUG(bool erased =) erase(i->first);
ss_dassert(erased);
mxb_assert(erased);
}
return freed_space;
@ -300,7 +300,7 @@ bool has_not_been_parsed(GWBUF* pStmt)
void info_object_close(void* pData)
{
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
this_unit.classifier->qc_info_close(static_cast<QC_STMT_INFO*>(pData));
}
@ -345,7 +345,7 @@ public:
if (!m_canonical.empty())
{
void* pData = gwbuf_get_buffer_object_data(m_pStmt, GWBUF_PARSING_INFO);
ss_dassert(pData);
mxb_assert(pData);
QC_STMT_INFO* pInfo = static_cast<QC_STMT_INFO*>(pData);
this_thread.pInfo_cache->insert(m_canonical, pInfo);
@ -365,7 +365,7 @@ bool qc_setup(const QC_CACHE_PROPERTIES* cache_properties,
const char* plugin_name, const char* plugin_args)
{
QC_TRACE();
ss_dassert(!this_unit.classifier);
mxb_assert(!this_unit.classifier);
if (!plugin_name || (*plugin_name == 0))
{
@ -385,7 +385,7 @@ bool qc_setup(const QC_CACHE_PROPERTIES* cache_properties,
this_unit.qc_sql_mode = sql_mode;
int64_t cache_max_size = (cache_properties ? cache_properties->max_size : 0);
ss_dassert(cache_max_size >= 0);
mxb_assert(cache_max_size >= 0);
if (cache_max_size)
{
@ -411,7 +411,7 @@ bool qc_setup(const QC_CACHE_PROPERTIES* cache_properties,
bool qc_process_init(uint32_t kind)
{
QC_TRACE();
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
const char* parse_using = getenv(QC_TRX_PARSE_USING);
@ -455,7 +455,7 @@ bool qc_process_init(uint32_t kind)
void qc_process_end(uint32_t kind)
{
QC_TRACE();
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
if (kind & QC_INIT_PLUGIN)
{
@ -491,7 +491,7 @@ void qc_unload(QUERY_CLASSIFIER* classifier)
bool qc_thread_init(uint32_t kind)
{
QC_TRACE();
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
bool rc = false;
@ -519,7 +519,7 @@ bool qc_thread_init(uint32_t kind)
void qc_thread_end(uint32_t kind)
{
QC_TRACE();
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
if (kind & QC_INIT_PLUGIN)
{
@ -533,7 +533,7 @@ void qc_thread_end(uint32_t kind)
qc_parse_result_t qc_parse(GWBUF* query, uint32_t collect)
{
QC_TRACE();
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
int32_t result = QC_QUERY_INVALID;
@ -546,7 +546,7 @@ qc_parse_result_t qc_parse(GWBUF* query, uint32_t collect)
uint32_t qc_get_type_mask(GWBUF* query)
{
QC_TRACE();
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
uint32_t type_mask = QUERY_TYPE_UNKNOWN;
@ -559,7 +559,7 @@ uint32_t qc_get_type_mask(GWBUF* query)
qc_query_op_t qc_get_operation(GWBUF* query)
{
QC_TRACE();
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
int32_t op = QUERY_OP_UNDEFINED;
@ -572,7 +572,7 @@ qc_query_op_t qc_get_operation(GWBUF* query)
char* qc_get_created_table_name(GWBUF* query)
{
QC_TRACE();
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
char* name = NULL;
@ -585,7 +585,7 @@ char* qc_get_created_table_name(GWBUF* query)
bool qc_is_drop_table_query(GWBUF* query)
{
QC_TRACE();
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
int32_t is_drop_table = 0;
@ -598,7 +598,7 @@ bool qc_is_drop_table_query(GWBUF* query)
char** qc_get_table_names(GWBUF* query, int* tblsize, bool fullnames)
{
QC_TRACE();
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
char** names = NULL;
*tblsize = 0;
@ -612,7 +612,7 @@ char** qc_get_table_names(GWBUF* query, int* tblsize, bool fullnames)
char* qc_get_canonical(GWBUF* query)
{
QC_TRACE();
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
char *rval;
@ -636,7 +636,7 @@ char* qc_get_canonical(GWBUF* query)
bool qc_query_has_clause(GWBUF* query)
{
QC_TRACE();
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
int32_t has_clause = 0;
@ -649,7 +649,7 @@ bool qc_query_has_clause(GWBUF* query)
void qc_get_field_info(GWBUF* query, const QC_FIELD_INFO** infos, size_t* n_infos)
{
QC_TRACE();
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
*infos = NULL;
@ -664,7 +664,7 @@ void qc_get_field_info(GWBUF* query, const QC_FIELD_INFO** infos, size_t* n_info
void qc_get_function_info(GWBUF* query, const QC_FUNCTION_INFO** infos, size_t* n_infos)
{
QC_TRACE();
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
*infos = NULL;
@ -679,7 +679,7 @@ void qc_get_function_info(GWBUF* query, const QC_FUNCTION_INFO** infos, size_t*
char** qc_get_database_names(GWBUF* query, int* sizep)
{
QC_TRACE();
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
char** names = NULL;
*sizep = 0;
@ -693,7 +693,7 @@ char** qc_get_database_names(GWBUF* query, int* sizep)
char* qc_get_prepare_name(GWBUF* query)
{
QC_TRACE();
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
char* name = NULL;
@ -706,7 +706,7 @@ char* qc_get_prepare_name(GWBUF* query)
GWBUF* qc_get_preparable_stmt(GWBUF* stmt)
{
QC_TRACE();
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
GWBUF* preparable_stmt = NULL;
@ -1141,7 +1141,7 @@ uint32_t qc_get_trx_type_mask_using(GWBUF* stmt, qc_trx_parse_using_t use)
break;
default:
ss_dassert(!true);
mxb_assert(!true);
}
return type_mask;
@ -1155,7 +1155,7 @@ uint32_t qc_get_trx_type_mask(GWBUF* stmt)
void qc_set_server_version(uint64_t version)
{
QC_TRACE();
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
this_unit.classifier->qc_set_server_version(version);
}
@ -1163,7 +1163,7 @@ void qc_set_server_version(uint64_t version)
uint64_t qc_get_server_version()
{
QC_TRACE();
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
uint64_t version;
@ -1175,7 +1175,7 @@ uint64_t qc_get_server_version()
qc_sql_mode_t qc_get_sql_mode()
{
QC_TRACE();
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
return this_unit.qc_sql_mode;
}
@ -1183,10 +1183,10 @@ qc_sql_mode_t qc_get_sql_mode()
void qc_set_sql_mode(qc_sql_mode_t sql_mode)
{
QC_TRACE();
ss_dassert(this_unit.classifier);
mxb_assert(this_unit.classifier);
int32_t rv = this_unit.classifier->qc_set_sql_mode(sql_mode);
ss_dassert(rv == QC_RESULT_OK);
mxb_assert(rv == QC_RESULT_OK);
if (rv == QC_RESULT_OK)
{
@ -1306,13 +1306,13 @@ bool qc_alter_from_json(json_t* pJson)
cache_properties.max_size = json_integer_value(pValue);
// If runtime_is_count_or_null() did its job, then we will not
// get here if the value is negative.
ss_dassert(cache_properties.max_size >= 0);
mxb_assert(cache_properties.max_size >= 0);
}
if (rv)
{
MXB_AT_DEBUG(bool set =) qc_set_cache_properties(&cache_properties);
ss_dassert(set);
mxb_assert(set);
}
}

14
server/core/queryclassifier.cc
View File

@ -134,7 +134,7 @@ uint32_t get_prepare_type(GWBUF* buffer)
}
}
ss_dassert((type & (QUERY_TYPE_PREPARE_STMT | QUERY_TYPE_PREPARE_NAMED_STMT)) == 0);
mxb_assert((type & (QUERY_TYPE_PREPARE_STMT | QUERY_TYPE_PREPARE_NAMED_STMT)) == 0);
return type;
}
@ -243,7 +243,7 @@ public:
void store(GWBUF* buffer, uint32_t id)
{
ss_dassert(mxs_mysql_get_command(buffer) == MXS_COM_STMT_PREPARE ||
mxb_assert(mxs_mysql_get_command(buffer) == MXS_COM_STMT_PREPARE ||
qc_query_is_type(qc_get_type_mask(buffer),
QUERY_TYPE_PREPARE_NAMED_STMT));
@ -258,7 +258,7 @@ public:
break;
default:
ss_dassert(!true);
mxb_assert(!true);
break;
}
}
@ -327,7 +327,7 @@ public:
}
else
{
ss_info_dassert(!true, "QueryClassifier::PSManager::erase called with invalid query");
mxb_assert_message(!true, "QueryClassifier::PSManager::erase called with invalid query");
}
}
@ -480,7 +480,7 @@ uint32_t QueryClassifier::get_route_target(uint8_t command, uint32_t qtype, HINT
}
else
{
ss_dassert(trx_active || load_active ||
mxb_assert(trx_active || load_active ||
(qc_query_is_type(qtype, QUERY_TYPE_WRITE) ||
qc_query_is_type(qtype, QUERY_TYPE_MASTER_READ) ||
qc_query_is_type(qtype, QUERY_TYPE_SESSION_WRITE) ||
@ -532,12 +532,12 @@ uint32_t QueryClassifier::get_route_target(uint8_t command, uint32_t qtype, HINT
case HINT_ROUTE_TO_UPTODATE_SERVER:
// TODO: Add generic target type, never to be seem by RWS.
ss_dassert(false);
mxb_assert(false);
break;
case HINT_ROUTE_TO_ALL:
// TODO: Add generic target type, never to be seem by RWS.
ss_dassert(false);
mxb_assert(false);
break;
case HINT_ROUTE_TO_LAST_USED:

52
server/core/resource.cc
View File

@ -290,7 +290,7 @@ HttpResponse cb_start_service(const HttpRequest& request)
HttpResponse cb_create_server(const HttpRequest& request)
{
ss_dassert(request.get_json());
mxb_assert(request.get_json());
if (runtime_create_server_from_json(request.get_json()))
{
@ -303,7 +303,7 @@ HttpResponse cb_create_server(const HttpRequest& request)
HttpResponse cb_alter_server(const HttpRequest& request)
{
SERVER* server = server_find_by_unique_name(request.uri_part(1).c_str());
ss_dassert(server && request.get_json());
mxb_assert(server && request.get_json());
if (runtime_alter_server_from_json(server, request.get_json()))
{
@ -316,7 +316,7 @@ HttpResponse cb_alter_server(const HttpRequest& request)
HttpResponse do_alter_server_relationship(const HttpRequest& request, const char* type)
{
SERVER* server = server_find_by_unique_name(request.uri_part(1).c_str());
ss_dassert(server && request.get_json());
mxb_assert(server && request.get_json());
if (runtime_alter_server_relationships_from_json(server, type, request.get_json()))
{
@ -338,7 +338,7 @@ HttpResponse cb_alter_server_monitor_relationship(const HttpRequest& request)
HttpResponse cb_create_monitor(const HttpRequest& request)
{
ss_dassert(request.get_json());
mxb_assert(request.get_json());
if (runtime_create_monitor_from_json(request.get_json()))
{
@ -350,7 +350,7 @@ HttpResponse cb_create_monitor(const HttpRequest& request)
HttpResponse cb_create_filter(const HttpRequest& request)
{
ss_dassert(request.get_json());
mxb_assert(request.get_json());
if (runtime_create_filter_from_json(request.get_json()))
{
@ -362,7 +362,7 @@ HttpResponse cb_create_filter(const HttpRequest& request)
HttpResponse cb_create_service(const HttpRequest& request)
{
ss_dassert(request.get_json());
mxb_assert(request.get_json());
if (runtime_create_service_from_json(request.get_json()))
{
@ -375,7 +375,7 @@ HttpResponse cb_create_service(const HttpRequest& request)
HttpResponse cb_create_service_listener(const HttpRequest& request)
{
Service* service = service_internal_find(request.uri_part(1).c_str());
ss_dassert(service && request.get_json());
mxb_assert(service && request.get_json());
if (runtime_create_listener_from_json(service, request.get_json()))
{
@ -388,7 +388,7 @@ HttpResponse cb_create_service_listener(const HttpRequest& request)
HttpResponse cb_alter_monitor(const HttpRequest& request)
{
MXS_MONITOR* monitor = monitor_find(request.uri_part(1).c_str());
ss_dassert(monitor && request.get_json());
mxb_assert(monitor && request.get_json());
if (runtime_alter_monitor_from_json(monitor, request.get_json()))
{
@ -401,7 +401,7 @@ HttpResponse cb_alter_monitor(const HttpRequest& request)
HttpResponse cb_alter_monitor_server_relationship(const HttpRequest& request)
{
MXS_MONITOR* monitor = monitor_find(request.uri_part(1).c_str());
ss_dassert(monitor && request.get_json());
mxb_assert(monitor && request.get_json());
if (runtime_alter_monitor_relationships_from_json(monitor, request.get_json()))
{
@ -414,7 +414,7 @@ HttpResponse cb_alter_monitor_server_relationship(const HttpRequest& request)
HttpResponse cb_alter_service(const HttpRequest& request)
{
Service* service = service_internal_find(request.uri_part(1).c_str());
ss_dassert(service && request.get_json());
mxb_assert(service && request.get_json());
if (runtime_alter_service_from_json(service, request.get_json()))
{
@ -427,7 +427,7 @@ HttpResponse cb_alter_service(const HttpRequest& request)
HttpResponse cb_alter_service_server_relationship(const HttpRequest& request)
{
Service* service = service_internal_find(request.uri_part(1).c_str());
ss_dassert(service && request.get_json());
mxb_assert(service && request.get_json());
if (runtime_alter_service_relationships_from_json(service, CN_SERVERS, request.get_json()))
{
@ -440,7 +440,7 @@ HttpResponse cb_alter_service_server_relationship(const HttpRequest& request)
HttpResponse cb_alter_service_filter_relationship(const HttpRequest& request)
{
Service* service = service_internal_find(request.uri_part(1).c_str());
ss_dassert(service && request.get_json());
mxb_assert(service && request.get_json());
if (runtime_alter_service_relationships_from_json(service, CN_FILTERS, request.get_json()))
{
@ -452,7 +452,7 @@ HttpResponse cb_alter_service_filter_relationship(const HttpRequest& request)
HttpResponse cb_alter_logs(const HttpRequest& request)
{
ss_dassert(request.get_json());
mxb_assert(request.get_json());
if (runtime_alter_logs_from_json(request.get_json()))
{
@ -464,7 +464,7 @@ HttpResponse cb_alter_logs(const HttpRequest& request)
HttpResponse cb_alter_qc(const HttpRequest& request)
{
ss_dassert(request.get_json());
mxb_assert(request.get_json());
if (runtime_alter_qc_from_json(request.get_json()))
{
@ -477,7 +477,7 @@ HttpResponse cb_alter_qc(const HttpRequest& request)
HttpResponse cb_delete_server(const HttpRequest& request)
{
SERVER* server = server_find_by_unique_name(request.uri_part(1).c_str());
ss_dassert(server);
mxb_assert(server);
if (runtime_destroy_server(server))
{
@ -490,7 +490,7 @@ HttpResponse cb_delete_server(const HttpRequest& request)
HttpResponse cb_delete_monitor(const HttpRequest& request)
{
MXS_MONITOR* monitor = monitor_find(request.uri_part(1).c_str());
ss_dassert(monitor);
mxb_assert(monitor);
if (runtime_destroy_monitor(monitor))
{
@ -504,7 +504,7 @@ HttpResponse cb_delete_listener(const HttpRequest& request)
{
Service* service = service_internal_find(request.uri_part(1).c_str());
ss_dassert(service);
mxb_assert(service);
std::string listener = request.uri_part(3);
if (!service_has_named_listener(service, listener.c_str()))
@ -522,7 +522,7 @@ HttpResponse cb_delete_listener(const HttpRequest& request)
HttpResponse cb_delete_service(const HttpRequest& request)
{
Service* service = service_internal_find(request.uri_part(1).c_str());
ss_dassert(service);
mxb_assert(service);
if (runtime_destroy_service(service))
{
@ -535,7 +535,7 @@ HttpResponse cb_delete_service(const HttpRequest& request)
HttpResponse cb_delete_filter(const HttpRequest& request)
{
auto filter = filter_find(request.uri_part(1).c_str());
ss_dassert(filter);
mxb_assert(filter);
if (runtime_destroy_filter(filter))
{
@ -552,7 +552,7 @@ HttpResponse cb_all_servers(const HttpRequest& request)
HttpResponse cb_get_server(const HttpRequest& request)
{
SERVER* server = server_find_by_unique_name(request.uri_part(1).c_str());
ss_dassert(server);
mxb_assert(server);
return HttpResponse(MHD_HTTP_OK, server_to_json(server, request.host()));
}
@ -564,7 +564,7 @@ HttpResponse cb_all_services(const HttpRequest& request)
HttpResponse cb_get_service(const HttpRequest& request)
{
Service* service = service_internal_find(request.uri_part(1).c_str());
ss_dassert(service);
mxb_assert(service);
return HttpResponse(MHD_HTTP_OK, service_to_json(service, request.host()));
}
@ -578,7 +578,7 @@ HttpResponse cb_get_service_listener(const HttpRequest& request)
{
Service* service = service_internal_find(request.uri_part(1).c_str());
std::string listener = request.uri_part(3);
ss_dassert(service);
mxb_assert(service);
if (!service_has_named_listener(service, listener.c_str()))
{
@ -598,7 +598,7 @@ HttpResponse cb_all_filters(const HttpRequest& request)
HttpResponse cb_get_filter(const HttpRequest& request)
{
auto filter = filter_find(request.uri_part(1).c_str());
ss_dassert(filter);
mxb_assert(filter);
return HttpResponse(MHD_HTTP_OK, filter_to_json(filter, request.host()));
}
@ -610,7 +610,7 @@ HttpResponse cb_all_monitors(const HttpRequest& request)
HttpResponse cb_get_monitor(const HttpRequest& request)
{
MXS_MONITOR* monitor = monitor_find(request.uri_part(1).c_str());
ss_dassert(monitor);
mxb_assert(monitor);
return HttpResponse(MHD_HTTP_OK, monitor_to_json(monitor, request.host()));
}
@ -641,7 +641,7 @@ HttpResponse cb_maxscale(const HttpRequest& request)
HttpResponse cb_alter_maxscale(const HttpRequest& request)
{
ss_dassert(request.get_json());
mxb_assert(request.get_json());
if (runtime_alter_maxscale_from_json(request.get_json()))
{
@ -730,7 +730,7 @@ HttpResponse cb_unix_user(const HttpRequest& request)
HttpResponse cb_create_user(const HttpRequest& request)
{
ss_dassert(request.get_json());
mxb_assert(request.get_json());
if (runtime_create_user_from_json(request.get_json()))
{

2
server/core/resultset.cc
View File

@ -183,7 +183,7 @@ std::unique_ptr<ResultSet> ResultSet::create(std::initializer_list<std::string>
void ResultSet::add_row(std::initializer_list<std::string> values)
{
ss_dassert(values.size() == m_columns.size());
mxb_assert(values.size() == m_columns.size());
m_rows.emplace_back(values);
}

46
server/core/routingworker.cc
View File

@ -178,7 +178,7 @@ RoutingWorker::~RoutingWorker()
// static
bool RoutingWorker::init()
{
ss_dassert(!this_unit.initialized);
mxb_assert(!this_unit.initialized);
this_unit.number_poll_spins = config_nbpolls();
this_unit.max_poll_sleep = config_pollsleep();
@ -273,12 +273,12 @@ bool RoutingWorker::init()
void RoutingWorker::finish()
{
ss_dassert(this_unit.initialized);
mxb_assert(this_unit.initialized);
for (int i = this_unit.id_max_worker; i >= this_unit.id_min_worker; --i)
{
RoutingWorker* pWorker = this_unit.ppWorkers[i];
ss_dassert(pWorker);
mxb_assert(pWorker);
delete pWorker;
this_unit.ppWorkers[i] = NULL;
@ -350,7 +350,7 @@ RoutingWorker* RoutingWorker::get(int worker_id)
worker_id = this_unit.id_main_worker;
}
ss_dassert((worker_id >= this_unit.id_min_worker) && (worker_id <= this_unit.id_max_worker));
mxb_assert((worker_id >= this_unit.id_min_worker) && (worker_id <= this_unit.id_max_worker));
return this_unit.ppWorkers[worker_id];
}
@ -386,7 +386,7 @@ bool RoutingWorker::start_threaded_workers()
if (i != this_unit.id_main_worker)
{
RoutingWorker* pWorker = this_unit.ppWorkers[i];
ss_dassert(pWorker);
mxb_assert(pWorker);
if (!pWorker->start())
{
@ -409,7 +409,7 @@ void RoutingWorker::join_threaded_workers()
if (i != this_unit.id_main_worker)
{
RoutingWorker* pWorker = this_unit.ppWorkers[i];
ss_dassert(pWorker);
mxb_assert(pWorker);
pWorker->join();
}
@ -435,7 +435,7 @@ RoutingWorker::SessionsById& RoutingWorker::session_registry()
void RoutingWorker::register_zombie(DCB* pDcb)
{
ss_dassert(pDcb->poll.owner == this);
mxb_assert(pDcb->poll.owner == this);
m_zombies.push_back(pDcb);
}
@ -548,7 +548,7 @@ void RoutingWorker::epoll_tick()
uint32_t RoutingWorker::epoll_instance_handler(MXB_POLL_DATA* pData, MXB_WORKER* pWorker, uint32_t events)
{
RoutingWorker* pThis = static_cast<RoutingWorker*>(pData);
ss_dassert(pThis == pWorker);
mxb_assert(pThis == pWorker);
return pThis->handle_epoll_events(events);
}
@ -598,7 +598,7 @@ size_t RoutingWorker::broadcast(Task* pTask, Semaphore* pSem)
for (int i = 0; i < nWorkers; ++i)
{
Worker* pWorker = this_unit.ppWorkers[i];
ss_dassert(pWorker);
mxb_assert(pWorker);
if (pWorker->execute(pTask, pSem, EXECUTE_AUTO))
{
@ -621,7 +621,7 @@ size_t RoutingWorker::broadcast(std::unique_ptr<DisposableTask> sTask)
for (int i = 0; i < nWorkers; ++i)
{
RoutingWorker* pWorker = this_unit.ppWorkers[i];
ss_dassert(pWorker);
mxb_assert(pWorker);
if (pWorker->post_disposable(pTask, EXECUTE_AUTO))
{
@ -644,7 +644,7 @@ size_t RoutingWorker::execute_serially(Task& task)
for (int i = 0; i < nWorkers; ++i)
{
RoutingWorker* pWorker = this_unit.ppWorkers[i];
ss_dassert(pWorker);
mxb_assert(pWorker);
if (pWorker->execute(&task, &sem, EXECUTE_AUTO))
{
@ -674,7 +674,7 @@ size_t RoutingWorker::broadcast_message(uint32_t msg_id, intptr_t arg1, intptr_t
for (int i = 0; i < nWorkers; ++i)
{
Worker* pWorker = this_unit.ppWorkers[i];
ss_dassert(pWorker);
mxb_assert(pWorker);
if (pWorker->post_message(msg_id, arg1, arg2))
{
@ -689,13 +689,13 @@ size_t RoutingWorker::broadcast_message(uint32_t msg_id, intptr_t arg1, intptr_t
void RoutingWorker::shutdown_all()
{
// NOTE: No logging here, this function must be signal safe.
ss_dassert((this_unit.next_worker_id == 0) || (this_unit.ppWorkers != NULL));
mxb_assert((this_unit.next_worker_id == 0) || (this_unit.ppWorkers != NULL));
int nWorkers = this_unit.next_worker_id;
for (int i = 0; i < nWorkers; ++i)
{
RoutingWorker* pWorker = this_unit.ppWorkers[i];
ss_dassert(pWorker);
mxb_assert(pWorker);
pWorker->shutdown();
}
@ -713,7 +713,7 @@ int64_t one_stats_get(int64_t Worker::STATISTICS::*what, enum ts_stats_type type
for (int i = 0; i < nWorkers; ++i)
{
RoutingWorker* pWorker = RoutingWorker::get(i);
ss_dassert(pWorker);
mxb_assert(pWorker);
const Worker::STATISTICS& s = pWorker->statistics();
@ -771,7 +771,7 @@ Worker::STATISTICS RoutingWorker::get_statistics()
for (int j = 0; j < this_unit.next_worker_id; ++j)
{
Worker* pWorker = RoutingWorker::get(j);
ss_dassert(pWorker);
mxb_assert(pWorker);
cs.n_fds[i] += pWorker->statistics().n_fds[i];
}
@ -784,7 +784,7 @@ Worker::STATISTICS RoutingWorker::get_statistics()
for (int j = 0; j < nWorkers; ++j)
{
Worker* pWorker = RoutingWorker::get(j);
ss_dassert(pWorker);
mxb_assert(pWorker);
cs.qtimes[i] += pWorker->statistics().qtimes[i];
cs.exectimes[i] += pWorker->statistics().exectimes[i];
@ -853,7 +853,7 @@ int64_t RoutingWorker::get_one_statistic(POLL_STAT what)
break;
default:
ss_dassert(!true);
mxb_assert(!true);
}
if (member)
@ -912,7 +912,7 @@ void RoutingWorker::get_qc_stats(std::vector<QC_CACHE_STATS>& all_stats)
void execute(Worker& worker)
{
int id = mxs::RoutingWorker::get_current_id();
ss_dassert(id >= 0);
mxb_assert(id >= 0);
QC_CACHE_STATS& stats = m_all_stats[id];
@ -1014,21 +1014,21 @@ size_t mxs_rworker_broadcast_message(uint32_t msg_id, intptr_t arg1, intptr_t ar
bool mxs_rworker_register_session(MXS_SESSION* session)
{
RoutingWorker* pWorker = RoutingWorker::get_current();
ss_dassert(pWorker);
mxb_assert(pWorker);
return pWorker->session_registry().add(session);
}
bool mxs_rworker_deregister_session(uint64_t id)
{
RoutingWorker* pWorker = RoutingWorker::get_current();
ss_dassert(pWorker);
mxb_assert(pWorker);
return pWorker->session_registry().remove(id);
}
MXS_SESSION* mxs_rworker_find_session(uint64_t id)
{
RoutingWorker* pWorker = RoutingWorker::get_current();
ss_dassert(pWorker);
mxb_assert(pWorker);
return pWorker->session_registry().lookup(id);
}
@ -1112,7 +1112,7 @@ public:
json_object_set_new(pJson, CN_ATTRIBUTES, pAttr);
json_object_set_new(pJson, CN_LINKS, mxs_json_self_link(m_zHost, CN_THREADS, ss.str().c_str()));
ss_dassert((size_t)idx < m_data.size());
mxb_assert((size_t)idx < m_data.size());
m_data[idx] = pJson;
}

2
server/core/secrets.cc
View File

@ -223,7 +223,7 @@ secrets_readKeys(const char* path)
mxs_strerror(eno));
return NULL;
}
ss_dassert(keys != NULL);
mxb_assert(keys != NULL);
/** Successfully loaded keys, log notification */
if (!reported)

14
server/core/server.cc
View File

@ -202,12 +202,12 @@ SERVER* server_alloc(const char *name, MXS_CONFIG_PARAMETER* params)
*/
void server_free(Server* server)
{
ss_dassert(server);
mxb_assert(server);
{
Guard guard(server_lock);
auto it = std::find(all_servers.begin(), all_servers.end(), server);
ss_dassert(it != all_servers.end());
mxb_assert(it != all_servers.end());
all_servers.erase(it);
}
@ -336,7 +336,7 @@ SERVER * server_find_by_unique_name(const char *name)
*/
int server_find_by_unique_names(char **server_names, int size, SERVER*** output)
{
ss_dassert(server_names && (size > 0));
mxb_assert(server_names && (size > 0));
SERVER **results = (SERVER**)MXS_CALLOC(size, sizeof(SERVER*));
if (!results)
@ -469,7 +469,7 @@ public:
void execute(Worker& worker)
{
RoutingWorker& rworker = static_cast<RoutingWorker&>(worker);
ss_dassert(&rworker == RoutingWorker::get_current());
mxb_assert(&rworker == RoutingWorker::get_current());
int thread_id = rworker.id();
dcb_persistent_clean_count(m_server->persistent[thread_id], thread_id, false);
@ -646,7 +646,7 @@ dListServers(DCB *dcb)
*/
char* server_status(const SERVER *server)
{
ss_dassert(server);
mxb_assert(server);
uint64_t server_status = server->status;
string result;
@ -938,7 +938,7 @@ static void server_parameter_free(SERVER_PARAM *tofree)
*/
static size_t server_get_parameter_nolock(const SERVER *server, const char *name, char* out, size_t size)
{
ss_dassert(SPINLOCK_IS_LOCKED(&server->lock));
mxb_assert(SPINLOCK_IS_LOCKED(&server->lock));
size_t len = 0;
SERVER_PARAM *param = server->parameters;
@ -1234,7 +1234,7 @@ bool server_serialize(const SERVER *server)
strcpy(final_filename, filename);
char *dot = strrchr(final_filename, '.');
ss_dassert(dot);
mxb_assert(dot);
*dot = '\0';
if (rename(filename, final_filename) == 0)

50
server/core/service.cc
View File

@ -168,8 +168,8 @@ Service::Service(const std::string& service_name, const std::string& router_name
m_wkey(mxs_rworker_create_key())
{
const MXS_MODULE* module = get_module(router_name.c_str(), MODULE_ROUTER);
ss_dassert(module);
ss_dassert(load_module(router_name.c_str(), MODULE_ROUTER) == module->module_object);
mxb_assert(module);
mxb_assert(load_module(router_name.c_str(), MODULE_ROUTER) == module->module_object);
router = (MXS_ROUTER_OBJECT*)module->module_object;
capabilities = module->module_capabilities;
@ -236,7 +236,7 @@ Service::~Service()
while (auto tmp = ports)
{
ports = ports->next;
ss_dassert(!tmp->active || maxscale_teardown_in_progress());
mxb_assert(!tmp->active || maxscale_teardown_in_progress());
listener_free(tmp);
}
@ -247,7 +247,7 @@ Service::~Service()
while (SERVER_REF* tmp = dbref)
{
ss_dassert(!tmp->active || maxscale_teardown_in_progress());
mxb_assert(!tmp->active || maxscale_teardown_in_progress());
dbref = dbref->next;
MXS_FREE(tmp);
}
@ -257,13 +257,13 @@ Service::~Service()
void service_free(Service* service)
{
ss_dassert(atomic_load_int(&service->client_count) == 0 || maxscale_teardown_in_progress());
ss_dassert(!service->active || maxscale_teardown_in_progress());
mxb_assert(atomic_load_int(&service->client_count) == 0 || maxscale_teardown_in_progress());
mxb_assert(!service->active || maxscale_teardown_in_progress());
{
LockGuard guard(this_unit.lock);
auto it = std::remove(this_unit.services.begin(), this_unit.services.end(), service);
ss_dassert(it != this_unit.services.end());
mxb_assert(it != this_unit.services.end());
this_unit.services.erase(it);
}
@ -275,10 +275,10 @@ void service_destroy(Service* service)
#ifdef SS_DEBUG
auto current = mxs::RoutingWorker::get_current();
auto main = mxs::RoutingWorker::get(mxs::RoutingWorker::MAIN);
ss_info_dassert(current == main, "Destruction of service must be done on the main worker");
mxb_assert_message(current == main, "Destruction of service must be done on the main worker");
#endif
ss_dassert(service->active);
mxb_assert(service->active);
atomic_store_int(&service->active, false);
char filename[PATH_MAX + 1];
@ -350,7 +350,7 @@ serviceStartPort(Service *service, SERV_LISTENER *port)
/* Should never happen, this guarantees it can't */
MXS_ERROR("Attempt to start port with null or incomplete service");
close_port(port);
ss_dassert(false);
mxb_assert(false);
return 0;
}
@ -399,7 +399,7 @@ serviceStartPort(Service *service, SERV_LISTENER *port)
// Add protocol and authenticator capabilities from the listener
const MXS_MODULE* proto_mod = get_module(port->protocol, MODULE_PROTOCOL);
const MXS_MODULE* auth_mod = get_module(authenticator_name, MODULE_AUTHENTICATOR);
ss_dassert(proto_mod && auth_mod);
mxb_assert(proto_mod && auth_mod);
service->capabilities |= proto_mod->module_capabilities | auth_mod->module_capabilities;
memcpy(&port->listener->authfunc, authfuncs, sizeof(MXS_AUTHENTICATOR));
@ -551,7 +551,7 @@ int serviceInitialize(Service *service)
bool serviceLaunchListener(Service *service, SERV_LISTENER *port)
{
ss_dassert(service->state != SERVICE_STATE_FAILED);
mxb_assert(service->state != SERVICE_STATE_FAILED);
bool rval = true;
LockGuard guard(service->lock);
@ -1082,7 +1082,7 @@ bool Service::set_filters(const std::vector<std::string>& filters)
flist.push_back(def);
const MXS_MODULE* module = get_module(def->module.c_str(), MODULE_FILTER);
ss_dassert(module);
mxb_assert(module);
my_capabilities |= module->module_capabilities;
if (def->obj->getCapabilities)
@ -1283,7 +1283,7 @@ dListServices(DCB *dcb)
for (Service* service : this_unit.services)
{
ss_dassert(service->stats.n_current >= 0);
mxb_assert(service->stats.n_current >= 0);
dcb_printf(dcb, "%-25s | %-17s | %6d | %14d | ",
service->name, service->routerModule,
service->stats.n_current, service->stats.n_sessions);
@ -1359,7 +1359,7 @@ bool Service::refresh_users()
{
bool ret = true;
int self = mxs_rworker_get_current_id();
ss_dassert(self >= 0);
mxb_assert(self >= 0);
time_t now = time(NULL);
// Use unique_lock instead of lock_guard to make the locking conditional
@ -1435,7 +1435,7 @@ bool Service::refresh_users()
int service_refresh_users(SERVICE *svc)
{
Service* service = static_cast<Service*>(svc);
ss_dassert(service);
mxb_assert(service);
return service->refresh_users() ? 0 : 1;
}
@ -1739,7 +1739,7 @@ bool service_server_in_use(const SERVER *server)
bool service_filter_in_use(const SFilterDef& filter)
{
ss_dassert(filter);
mxb_assert(filter);
LockGuard guard(this_unit.lock);
for (Service* service : this_unit.services)
@ -1811,7 +1811,7 @@ bool Service::dump_config(const char *filename) const
}
const MXS_MODULE* mod = get_module(m_router_name.c_str(), NULL);
ss_dassert(mod);
mxb_assert(mod);
dump_param_list(file, svc_config_param, {CN_TYPE, CN_FILTERS, CN_SERVERS},
config_service_params, mod->parameters);
@ -1839,7 +1839,7 @@ bool service_serialize(const Service *service)
strcpy(final_filename, filename);
char *dot = strrchr(final_filename, '.');
ss_dassert(dot);
mxb_assert(dot);
*dot = '\0';
if (rename(filename, final_filename) == 0)
@ -1920,7 +1920,7 @@ static const char* service_state_to_string(int state)
return "Allocated";
default:
ss_dassert(false);
mxb_assert(false);
return "Unknown";
}
}
@ -2200,7 +2200,7 @@ uint64_t service_get_version(const SERVICE *svc, service_version_which_t which)
}
else
{
ss_dassert(which == SERVICE_VERSION_MAX);
mxb_assert(which == SERVICE_VERSION_MAX);
v = 0;
}
@ -2225,7 +2225,7 @@ uint64_t service_get_version(const SERVICE *svc, service_version_which_t which)
}
else
{
ss_dassert(which == SERVICE_VERSION_MAX);
mxb_assert(which == SERVICE_VERSION_MAX);
if (server_version > v)
{
@ -2305,12 +2305,12 @@ void Service::update_basic_parameter(const std::string& key, const std::string&
else if (key == CN_MAX_RETRY_INTERVAL)
{
max_retry_interval = std::stoi(value);
ss_dassert(max_retry_interval > 0);
mxb_assert(max_retry_interval > 0);
}
else if (key == CN_MAX_CONNECTIONS)
{
max_connections = std::stoi(value);
ss_dassert(max_connections > 0);
mxb_assert(max_connections > 0);
}
else if (key == CN_CONNECTION_TIMEOUT)
{
@ -2319,7 +2319,7 @@ void Service::update_basic_parameter(const std::string& key, const std::string&
dcb_enable_session_timeouts();
}
ss_dassert(conn_idle_timeout >= 0);
mxb_assert(conn_idle_timeout >= 0);
}
else if (key == CN_AUTH_ALL_SERVERS)
{

44
server/core/session.cc
View File

@ -255,7 +255,7 @@ session_set_dummy(DCB *client_dcb)
void session_link_backend_dcb(MXS_SESSION *session, DCB *dcb)
{
ss_dassert(dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER);
mxb_assert(dcb->dcb_role == DCB_ROLE_BACKEND_HANDLER);
atomic_add(&session->refcount, 1);
dcb->session = session;
@ -365,7 +365,7 @@ static void session_free(MXS_SESSION *session)
static void session_final_free(MXS_SESSION *session)
{
ss_dassert(session->refcount == 0);
mxb_assert(session->refcount == 0);
session->state = SESSION_STATE_TO_BE_FREED;
@ -638,10 +638,10 @@ session_get_remote(const MXS_SESSION *session)
bool session_route_query(MXS_SESSION* session, GWBUF* buffer)
{
ss_dassert(session);
ss_dassert(session->head.routeQuery);
ss_dassert(session->head.instance);
ss_dassert(session->head.session);
mxb_assert(session);
mxb_assert(session->head.routeQuery);
mxb_assert(session->head.instance);
mxb_assert(session->head.session);
bool rv;
@ -663,10 +663,10 @@ bool session_route_query(MXS_SESSION* session, GWBUF* buffer)
bool session_route_reply(MXS_SESSION *session, GWBUF *buffer)
{
ss_dassert(session);
ss_dassert(session->tail.clientReply);
ss_dassert(session->tail.instance);
ss_dassert(session->tail.session);
mxb_assert(session);
mxb_assert(session->tail.clientReply);
mxb_assert(session->tail.instance);
mxb_assert(session->tail.session);
bool rv;
@ -933,7 +933,7 @@ void session_qualify_for_pool(MXS_SESSION* session)
bool session_valid_for_pool(const MXS_SESSION* session)
{
ss_dassert(session->state != SESSION_STATE_DUMMY);
mxb_assert(session->state != SESSION_STATE_DUMMY);
return session->qualifies_for_pooling;
}
@ -981,10 +981,10 @@ bool session_remove_variable(MXS_SESSION* session,
void session_set_response(MXS_SESSION *session, const MXS_UPSTREAM *up, GWBUF *buffer)
{
// Valid arguments.
ss_dassert(session && up && buffer);
mxb_assert(session && up && buffer);
// Valid state. Only one filter may terminate the execution and exactly once.
ss_dassert(!session->response.up.instance &&
mxb_assert(!session->response.up.instance &&
!session->response.up.session &&
!session->response.buffer);
@ -1007,8 +1007,8 @@ static void session_deliver_response(MXS_SESSION* session)
MXS_FILTER_SESSION* filter_session = session->response.up.session;
GWBUF* buffer = session->response.buffer;
ss_dassert(filter_session);
ss_dassert(buffer);
mxb_assert(filter_session);
mxb_assert(buffer);
session->response.up.clientReply(filter_instance, filter_session, buffer);
@ -1018,10 +1018,10 @@ static void session_deliver_response(MXS_SESSION* session)
session->response.buffer = NULL;
}
ss_dassert(!session->response.up.instance);
ss_dassert(!session->response.up.session);
ss_dassert(!session->response.up.clientReply);
ss_dassert(!session->response.buffer);
mxb_assert(!session->response.up.instance);
mxb_assert(!session->response.up.session);
mxb_assert(!session->response.up.clientReply);
mxb_assert(!session->response.buffer);
}
void session_set_retain_last_statements(uint32_t n)
@ -1109,7 +1109,7 @@ bool session_delay_routing(MXS_SESSION* session, MXS_DOWNSTREAM down, GWBUF* buf
try
{
Worker* worker = Worker::get_current();
ss_dassert(worker == session->client_dcb->poll.owner);
mxb_assert(worker == session->client_dcb->poll.owner);
std::unique_ptr<DelayedRoutingTask> task(new DelayedRoutingTask(session, down, buffer));
// Delay the routing for at least a millisecond
@ -1158,7 +1158,7 @@ const char* session_get_close_reason(const MXS_SESSION* session)
return "Too many connections";
default:
ss_dassert(!true);
mxb_assert(!true);
return "Internal error";
}
}
@ -1377,7 +1377,7 @@ void Session::retain_statement(GWBUF* pBuffer)
if (MYSQL_GET_COMMAND(pHeader) == MXS_COM_QUERY)
{
ss_dassert(m_last_statements.size() <= retain_last_statements);
mxb_assert(m_last_statements.size() <= retain_last_statements);
if (m_last_statements.size() == retain_last_statements)
{

2
server/core/session_command.cc
View File

@ -94,7 +94,7 @@ std::string SessionCommand::to_string()
void SessionCommand::mark_as_duplicate(const SessionCommand& rhs)
{
ss_dassert(eq(rhs));
mxb_assert(eq(rhs));
// The commands now share the mxs::Buffer that contains the actual command
m_buffer = rhs.m_buffer;
}

2
server/core/spinlock.cc
View File

@ -83,7 +83,7 @@ spinlock_acquire_nowait(const SPINLOCK *const_lock)
void spinlock_release(const SPINLOCK *const_lock)
{
SPINLOCK *lock = (SPINLOCK*)const_lock;
ss_dassert(lock->lock != 0);
mxb_assert(lock->lock != 0);
#if SPINLOCK_PROFILE
if (lock->waiting > lock->max_waiting)
{

20
server/core/statistics.cc
View File

@ -59,7 +59,7 @@ static size_t get_cache_line_size()
*/
void ts_stats_init()
{
ss_dassert(!stats_initialized);
mxb_assert(!stats_initialized);
thread_count = config_threadcount();
cache_linesize = get_cache_line_size();
stats_size = thread_count * cache_linesize;
@ -71,7 +71,7 @@ void ts_stats_init()
*/
void ts_stats_end()
{
ss_dassert(stats_initialized);
mxb_assert(stats_initialized);
}
/**
@ -81,7 +81,7 @@ void ts_stats_end()
*/
ts_stats_t ts_stats_alloc()
{
ss_dassert(stats_initialized);
mxb_assert(stats_initialized);
return MXS_CALLOC(thread_count, cache_linesize);
}
@ -92,7 +92,7 @@ ts_stats_t ts_stats_alloc()
*/
void ts_stats_free(ts_stats_t stats)
{
ss_dassert(stats_initialized);
mxb_assert(stats_initialized);
MXS_FREE(stats);
}
@ -106,7 +106,7 @@ void ts_stats_free(ts_stats_t stats)
*/
int64_t ts_stats_sum(ts_stats_t stats)
{
ss_dassert(stats_initialized);
mxb_assert(stats_initialized);
int64_t sum = 0;
for (size_t i = 0; i < stats_size; i += cache_linesize)
@ -128,7 +128,7 @@ int64_t ts_stats_sum(ts_stats_t stats)
*/
int64_t ts_stats_get(ts_stats_t stats, enum ts_stats_type type)
{
ss_dassert(stats_initialized);
mxb_assert(stats_initialized);
int64_t best = type == TS_STATS_MAX ? LONG_MIN : (type == TS_STATS_MIX ? LONG_MAX : 0);
for (size_t i = 0; i < stats_size; i += cache_linesize)
@ -163,21 +163,21 @@ int64_t ts_stats_get(ts_stats_t stats, enum ts_stats_type type)
void ts_stats_increment(ts_stats_t stats, int thread_id)
{
ss_dassert(thread_id < thread_count);
mxb_assert(thread_id < thread_count);
int64_t *item = (int64_t*)MXS_PTR(stats, thread_id * cache_linesize);
*item += 1;
}
void ts_stats_set(ts_stats_t stats, int value, int thread_id)
{
ss_dassert(thread_id < thread_count);
mxb_assert(thread_id < thread_count);
int64_t *item = (int64_t*)MXS_PTR(stats, thread_id * cache_linesize);
*item = value;
}
void ts_stats_set_max(ts_stats_t stats, int value, int thread_id)
{
ss_dassert(thread_id < thread_count);
mxb_assert(thread_id < thread_count);
int64_t *item = (int64_t*)MXS_PTR(stats, thread_id * cache_linesize);
if (value > *item)
@ -188,7 +188,7 @@ void ts_stats_set_max(ts_stats_t stats, int value, int thread_id)
void ts_stats_set_min(ts_stats_t stats, int value, int thread_id)
{
ss_dassert(thread_id < thread_count);
mxb_assert(thread_id < thread_count);
int64_t *item = (int64_t*)MXS_PTR(stats, thread_id * cache_linesize);
if (value < *item)

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

@ -28,7 +28,7 @@ timespec timespec_subtract(const timespec& later, const timespec& earlier)
{
timespec result = { 0, 0 };
ss_dassert((later.tv_sec > earlier.tv_sec) ||
mxb_assert((later.tv_sec > earlier.tv_sec) ||
((later.tv_sec == earlier.tv_sec) && (later.tv_nsec > earlier.tv_nsec)));
if (later.tv_nsec >= earlier.tv_nsec)

6
server/core/test/test_atomic.cc
View File

@ -33,7 +33,7 @@ void test_add(void* data)
{
atomic_add(&expected, id);
atomic_add(&expected, -id);
ss_dassert(atomic_load_int32(&expected) >= 0);
mxb_assert(atomic_load_int32(&expected) >= 0);
}
}
@ -45,7 +45,7 @@ void test_load_store(void* data)
{
if (atomic_load_int32(&expected) % NTHR == id)
{
ss_dassert(atomic_add(&expected, 1) % NTHR == id + 1);
mxb_assert(atomic_add(&expected, 1) % NTHR == id + 1);
}
}
}
@ -72,7 +72,7 @@ void test_cas(void* data)
loops++;
}
ss_dassert(loops > 0);
mxb_assert(loops > 0);
}
int run_test(void(*func)(void*))

236
server/core/test/test_buffer.cc
View File

@ -109,9 +109,9 @@ void split_buffer(int n, int offset)
int len = gwbuf_length(buffer);
GWBUF* newbuf = gwbuf_split(&buffer, cutoff);
ss_info_dassert(buffer && newbuf, "Both buffers should be non-NULL");
ss_info_dassert(gwbuf_length(newbuf) == cutoff, "New buffer should be have correct length");
ss_info_dassert(gwbuf_length(buffer) == len - cutoff, "Old buffer should be have correct length");
mxb_assert_message(buffer && newbuf, "Both buffers should be non-NULL");
mxb_assert_message(gwbuf_length(newbuf) == cutoff, "New buffer should be have correct length");
mxb_assert_message(gwbuf_length(buffer) == len - cutoff, "Old buffer should be have correct length");
gwbuf_free(buffer);
gwbuf_free(newbuf);
}
@ -124,8 +124,8 @@ void consume_buffer(int n, int offset)
int len = gwbuf_length(buffer);
buffer = gwbuf_consume(buffer, cutoff);
ss_info_dassert(buffer, "Buffer should be non-NULL");
ss_info_dassert(gwbuf_length(buffer) == len - cutoff, "Buffer should be have correct length");
mxb_assert_message(buffer, "Buffer should be non-NULL");
mxb_assert_message(gwbuf_length(buffer) == len - cutoff, "Buffer should be have correct length");
gwbuf_free(buffer);
}
@ -138,8 +138,8 @@ void copy_buffer(int n, int offset)
uint8_t dest[cutoff];
memset(dest, 0, sizeof(dest));
ss_info_dassert(gwbuf_copy_data(buffer, 0, cutoff, dest) == cutoff, "All bytes should be read");
ss_info_dassert(memcmp(data, dest, sizeof(dest)) == 0, "Data should be OK");
mxb_assert_message(gwbuf_copy_data(buffer, 0, cutoff, dest) == cutoff, "All bytes should be read");
mxb_assert_message(memcmp(data, dest, sizeof(dest)) == 0, "Data should be OK");
gwbuf_free(buffer);
MXS_FREE(data);
}
@ -151,56 +151,56 @@ void test_split()
size_t tailsize = 20;
GWBUF* oldchain = gwbuf_append(gwbuf_alloc(headsize), gwbuf_alloc(tailsize));
ss_info_dassert(gwbuf_length(oldchain) == headsize + tailsize, "Allocated buffer should be 30 bytes");
mxb_assert_message(gwbuf_length(oldchain) == headsize + tailsize, "Allocated buffer should be 30 bytes");
GWBUF* newchain = gwbuf_split(&oldchain, headsize + 5);
ss_info_dassert(newchain && oldchain, "Both chains should be non-NULL");
ss_info_dassert(gwbuf_length(newchain) == headsize + 5, "New chain should be 15 bytes long");
ss_info_dassert(GWBUF_LENGTH(newchain) == headsize && GWBUF_LENGTH(newchain->next) == 5,
mxb_assert_message(newchain && oldchain, "Both chains should be non-NULL");
mxb_assert_message(gwbuf_length(newchain) == headsize + 5, "New chain should be 15 bytes long");
mxb_assert_message(GWBUF_LENGTH(newchain) == headsize && GWBUF_LENGTH(newchain->next) == 5,
"The new chain should have a 10 byte buffer and a 5 byte buffer");
ss_info_dassert(gwbuf_length(oldchain) == tailsize - 5, "Old chain should be 15 bytes long");
ss_info_dassert(GWBUF_LENGTH(oldchain) == tailsize - 5 && oldchain->next == NULL,
mxb_assert_message(gwbuf_length(oldchain) == tailsize - 5, "Old chain should be 15 bytes long");
mxb_assert_message(GWBUF_LENGTH(oldchain) == tailsize - 5 && oldchain->next == NULL,
"The old chain should have a 15 byte buffer and no next buffer");
gwbuf_free(oldchain);
gwbuf_free(newchain);
oldchain = gwbuf_append(gwbuf_alloc(headsize), gwbuf_alloc(tailsize));
newchain = gwbuf_split(&oldchain, headsize);
ss_info_dassert(gwbuf_length(newchain) == headsize, "New chain should be 10 bytes long");
ss_info_dassert(gwbuf_length(oldchain) == tailsize, "Old chain should be 20 bytes long");
ss_info_dassert(oldchain->tail == oldchain, "Old chain tail should point to old chain");
ss_info_dassert(oldchain->next == NULL, "Old chain should not have next buffer");
ss_info_dassert(newchain->tail == newchain, "Old chain tail should point to old chain");
ss_info_dassert(newchain->next == NULL, "new chain should not have next buffer");
mxb_assert_message(gwbuf_length(newchain) == headsize, "New chain should be 10 bytes long");
mxb_assert_message(gwbuf_length(oldchain) == tailsize, "Old chain should be 20 bytes long");
mxb_assert_message(oldchain->tail == oldchain, "Old chain tail should point to old chain");
mxb_assert_message(oldchain->next == NULL, "Old chain should not have next buffer");
mxb_assert_message(newchain->tail == newchain, "Old chain tail should point to old chain");
mxb_assert_message(newchain->next == NULL, "new chain should not have next buffer");
gwbuf_free(oldchain);
gwbuf_free(newchain);
oldchain = gwbuf_append(gwbuf_alloc(headsize), gwbuf_alloc(tailsize));
newchain = gwbuf_split(&oldchain, headsize + tailsize);
ss_info_dassert(newchain, "New chain should be non-NULL");
ss_info_dassert(gwbuf_length(newchain) == headsize + tailsize, "New chain should be 30 bytes long");
ss_info_dassert(oldchain == NULL, "Old chain should be NULL");
mxb_assert_message(newchain, "New chain should be non-NULL");
mxb_assert_message(gwbuf_length(newchain) == headsize + tailsize, "New chain should be 30 bytes long");
mxb_assert_message(oldchain == NULL, "Old chain should be NULL");
gwbuf_free(newchain);
/** Splitting of contiguous memory */
GWBUF* buffer = gwbuf_alloc(10);
GWBUF* newbuf = gwbuf_split(&buffer, 5);
ss_info_dassert(buffer != newbuf, "gwbuf_split should return different pointers");
ss_info_dassert(gwbuf_length(buffer) == 5 && GWBUF_LENGTH(buffer) == 5, "Old buffer should be 5 bytes");
ss_info_dassert(gwbuf_length(newbuf) == 5 && GWBUF_LENGTH(newbuf) == 5, "New buffer should be 5 bytes");
ss_info_dassert(buffer->tail == buffer, "Old buffer's tail should point to itself");
ss_info_dassert(newbuf->tail == newbuf, "New buffer's tail should point to itself");
ss_info_dassert(buffer->next == NULL, "Old buffer's next pointer should be NULL");
ss_info_dassert(newbuf->next == NULL, "New buffer's next pointer should be NULL");
mxb_assert_message(buffer != newbuf, "gwbuf_split should return different pointers");
mxb_assert_message(gwbuf_length(buffer) == 5 && GWBUF_LENGTH(buffer) == 5, "Old buffer should be 5 bytes");
mxb_assert_message(gwbuf_length(newbuf) == 5 && GWBUF_LENGTH(newbuf) == 5, "New buffer should be 5 bytes");
mxb_assert_message(buffer->tail == buffer, "Old buffer's tail should point to itself");
mxb_assert_message(newbuf->tail == newbuf, "New buffer's tail should point to itself");
mxb_assert_message(buffer->next == NULL, "Old buffer's next pointer should be NULL");
mxb_assert_message(newbuf->next == NULL, "New buffer's next pointer should be NULL");
gwbuf_free(buffer);
gwbuf_free(newbuf);
/** Bad parameter tests */
GWBUF* ptr = NULL;
ss_info_dassert(gwbuf_split(NULL, 0) == NULL, "gwbuf_split with NULL parameter should return NULL");
ss_info_dassert(gwbuf_split(&ptr, 0) == NULL, "gwbuf_split with pointer to a NULL value should return NULL");
mxb_assert_message(gwbuf_split(NULL, 0) == NULL, "gwbuf_split with NULL parameter should return NULL");
mxb_assert_message(gwbuf_split(&ptr, 0) == NULL, "gwbuf_split with pointer to a NULL value should return NULL");
buffer = gwbuf_alloc(10);
ss_info_dassert(gwbuf_split(&buffer, 0) == NULL, "gwbuf_split with length of 0 should return NULL");
ss_info_dassert(gwbuf_length(buffer) == 10, "Buffer should be 10 bytes");
mxb_assert_message(gwbuf_split(&buffer, 0) == NULL, "gwbuf_split with length of 0 should return NULL");
mxb_assert_message(gwbuf_length(buffer) == 10, "Buffer should be 10 bytes");
gwbuf_free(buffer);
/** Splitting near buffer boudaries */
@ -223,45 +223,45 @@ void test_load_and_copy()
GWBUF* head = gwbuf_alloc_and_load(4, data);
GWBUF* tail = gwbuf_alloc_and_load(4, data + 4);
ss_info_dassert(memcmp(GWBUF_DATA(head), data, 4) == 0, "Loading 4 bytes should succeed");
ss_info_dassert(memcmp(GWBUF_DATA(tail), data + 4, 4) == 0, "Loading 4 bytes should succeed");
mxb_assert_message(memcmp(GWBUF_DATA(head), data, 4) == 0, "Loading 4 bytes should succeed");
mxb_assert_message(memcmp(GWBUF_DATA(tail), data + 4, 4) == 0, "Loading 4 bytes should succeed");
memset(dest, 0, sizeof(dest));
ss_info_dassert(gwbuf_copy_data(head, 0, 4, dest) == 4, "Copying 4 bytes should succeed");
ss_info_dassert(memcmp(dest, data, 4) == 0, "Copied data should be from 1 to 4");
mxb_assert_message(gwbuf_copy_data(head, 0, 4, dest) == 4, "Copying 4 bytes should succeed");
mxb_assert_message(memcmp(dest, data, 4) == 0, "Copied data should be from 1 to 4");
memset(dest, 0, sizeof(dest));
ss_info_dassert(gwbuf_copy_data(tail, 0, 4, dest) == 4, "Copying 4 bytes should succeed");
ss_info_dassert(memcmp(dest, data + 4, 4) == 0, "Copied data should be from 5 to 8");
mxb_assert_message(gwbuf_copy_data(tail, 0, 4, dest) == 4, "Copying 4 bytes should succeed");
mxb_assert_message(memcmp(dest, data + 4, 4) == 0, "Copied data should be from 5 to 8");
head = gwbuf_append(head, tail);
memset(dest, 0, sizeof(dest));
ss_info_dassert(gwbuf_copy_data(head, 0, 8, dest) == 8, "Copying 8 bytes should succeed");
ss_info_dassert(memcmp(dest, data, 8) == 0, "Copied data should be from 1 to 8");
mxb_assert_message(gwbuf_copy_data(head, 0, 8, dest) == 8, "Copying 8 bytes should succeed");
mxb_assert_message(memcmp(dest, data, 8) == 0, "Copied data should be from 1 to 8");
memset(dest, 0, sizeof(dest));
ss_info_dassert(gwbuf_copy_data(head, 4, 4, dest) == 4, "Copying 4 bytes at offset 4 should succeed");
ss_info_dassert(memcmp(dest, data + 4, 4) == 0, "Copied data should be from 5 to 8");
mxb_assert_message(gwbuf_copy_data(head, 4, 4, dest) == 4, "Copying 4 bytes at offset 4 should succeed");
mxb_assert_message(memcmp(dest, data + 4, 4) == 0, "Copied data should be from 5 to 8");
memset(dest, 0, sizeof(dest));
ss_info_dassert(gwbuf_copy_data(head, 2, 4, dest) == 4, "Copying 4 bytes at offset 2 should succeed");
ss_info_dassert(memcmp(dest, data + 2, 4) == 0, "Copied data should be from 5 to 8");
mxb_assert_message(gwbuf_copy_data(head, 2, 4, dest) == 4, "Copying 4 bytes at offset 2 should succeed");
mxb_assert_message(memcmp(dest, data + 2, 4) == 0, "Copied data should be from 5 to 8");
memset(dest, 0, sizeof(dest));
ss_info_dassert(gwbuf_copy_data(head, 0, 10, dest) == 8, "Copying 10 bytes should only copy 8 bytes");
ss_info_dassert(memcmp(dest, data, 8) == 0, "Copied data should be from 1 to 8");
mxb_assert_message(gwbuf_copy_data(head, 0, 10, dest) == 8, "Copying 10 bytes should only copy 8 bytes");
mxb_assert_message(memcmp(dest, data, 8) == 0, "Copied data should be from 1 to 8");
memset(dest, 0, sizeof(dest));
ss_info_dassert(gwbuf_copy_data(head, 0, 0, dest) == 0, "Copying 0 bytes should not copy any bytes");
mxb_assert_message(gwbuf_copy_data(head, 0, 0, dest) == 0, "Copying 0 bytes should not copy any bytes");
memset(dest, 0, sizeof(dest));
ss_info_dassert(gwbuf_copy_data(head, 0, -1, dest) == sizeof(data),
mxb_assert_message(gwbuf_copy_data(head, 0, -1, dest) == sizeof(data),
"Copying -1 bytes should copy all available data (cast to unsigned)");
ss_info_dassert(memcmp(dest, data, 8) == 0, "Copied data should be from 1 to 8");
mxb_assert_message(memcmp(dest, data, 8) == 0, "Copied data should be from 1 to 8");
ss_info_dassert(gwbuf_copy_data(head, -1, -1, dest) == 0,
mxb_assert_message(gwbuf_copy_data(head, -1, -1, dest) == 0,
"Copying -1 bytes at an offset of -1 should not copy any bytes");
ss_info_dassert(gwbuf_copy_data(head, -1, 0, dest) == 0,
mxb_assert_message(gwbuf_copy_data(head, -1, 0, dest) == 0,
"Copying 0 bytes at an offset of -1 should not copy any bytes");
gwbuf_free(head);
@ -283,27 +283,27 @@ void test_consume()
GWBUF* buffer = gwbuf_append(gwbuf_alloc_and_load(5, data),
gwbuf_alloc_and_load(5, data + 5));
ss_info_dassert(gwbuf_consume(buffer, 0) == buffer,
mxb_assert_message(gwbuf_consume(buffer, 0) == buffer,
"Consuming 0 bytes from a buffer should return original buffer");
ss_info_dassert(gwbuf_length(buffer) == 10, "Buffer should be 10 bytes after consuming 0 bytes");
mxb_assert_message(gwbuf_length(buffer) == 10, "Buffer should be 10 bytes after consuming 0 bytes");
buffer = gwbuf_consume(buffer, 1);
ss_info_dassert(GWBUF_LENGTH(buffer) == 4, "First buffer should be 4 bytes long");
ss_info_dassert(buffer->next, "Buffer should have next pointer set");
ss_info_dassert(GWBUF_LENGTH(buffer->next) == 5, "Next buffer should be 5 bytes long");
ss_info_dassert(gwbuf_length(buffer) == 9, "Buffer should be 9 bytes after consuming 1 bytes");
ss_info_dassert(*((uint8_t*)buffer->start) == 2, "First byte should be 2");
mxb_assert_message(GWBUF_LENGTH(buffer) == 4, "First buffer should be 4 bytes long");
mxb_assert_message(buffer->next, "Buffer should have next pointer set");
mxb_assert_message(GWBUF_LENGTH(buffer->next) == 5, "Next buffer should be 5 bytes long");
mxb_assert_message(gwbuf_length(buffer) == 9, "Buffer should be 9 bytes after consuming 1 bytes");
mxb_assert_message(*((uint8_t*)buffer->start) == 2, "First byte should be 2");
buffer = gwbuf_consume(buffer, 5);
ss_info_dassert(buffer->next == NULL, "Buffer should not have the next pointer set");
ss_info_dassert(GWBUF_LENGTH(buffer) == 4, "Buffer should be 4 bytes after consuming 6 bytes");
ss_info_dassert(gwbuf_length(buffer) == 4, "Buffer should be 4 bytes after consuming 6 bytes");
ss_info_dassert(*((uint8_t*)buffer->start) == 7, "First byte should be 7");
ss_info_dassert(gwbuf_consume(buffer, 4) == NULL, "Consuming all bytes should return NULL");
mxb_assert_message(buffer->next == NULL, "Buffer should not have the next pointer set");
mxb_assert_message(GWBUF_LENGTH(buffer) == 4, "Buffer should be 4 bytes after consuming 6 bytes");
mxb_assert_message(gwbuf_length(buffer) == 4, "Buffer should be 4 bytes after consuming 6 bytes");
mxb_assert_message(*((uint8_t*)buffer->start) == 7, "First byte should be 7");
mxb_assert_message(gwbuf_consume(buffer, 4) == NULL, "Consuming all bytes should return NULL");
buffer = gwbuf_append(gwbuf_alloc_and_load(5, data),
gwbuf_alloc_and_load(5, data + 5));
ss_info_dassert(gwbuf_consume(buffer, 100) == NULL,
mxb_assert_message(gwbuf_consume(buffer, 100) == NULL,
"Consuming more bytes than are available should return NULL");
@ -329,26 +329,26 @@ void test_compare()
GWBUF* rhs = NULL;
// Both NULL
ss_dassert(gwbuf_compare(lhs, rhs) == 0);
mxb_assert(gwbuf_compare(lhs, rhs) == 0);
// Either (but not both) NULL
lhs = gwbuf_alloc_and_load(10, data);
ss_dassert(gwbuf_compare(lhs, rhs) > 0);
ss_dassert(gwbuf_compare(rhs, lhs) < 0);
mxb_assert(gwbuf_compare(lhs, rhs) > 0);
mxb_assert(gwbuf_compare(rhs, lhs) < 0);
// The same array
ss_dassert(gwbuf_compare(lhs, lhs) == 0);
mxb_assert(gwbuf_compare(lhs, lhs) == 0);
// Identical array
gwbuf_free(rhs);
rhs = gwbuf_alloc_and_load(10, data);
ss_dassert(gwbuf_compare(lhs, rhs) == 0);
mxb_assert(gwbuf_compare(lhs, rhs) == 0);
// One shorter
gwbuf_free(rhs);
rhs = gwbuf_alloc_and_load(9, data + 1);
ss_dassert(gwbuf_compare(lhs, rhs) > 0);
ss_dassert(gwbuf_compare(rhs, lhs) < 0);
mxb_assert(gwbuf_compare(lhs, rhs) > 0);
mxb_assert(gwbuf_compare(rhs, lhs) < 0);
// One segmented, but otherwise identical.
gwbuf_free(rhs);
@ -357,8 +357,8 @@ void test_compare()
rhs = gwbuf_append(rhs, gwbuf_alloc_and_load(3, data + 3));
rhs = gwbuf_append(rhs, gwbuf_alloc_and_load(4, data + 3 + 3));
ss_dassert(gwbuf_compare(lhs, rhs) == 0);
ss_dassert(gwbuf_compare(rhs, rhs) == 0);
mxb_assert(gwbuf_compare(lhs, rhs) == 0);
mxb_assert(gwbuf_compare(rhs, rhs) == 0);
// Both segmented, but otherwise identical.
gwbuf_free(lhs);
@ -366,8 +366,8 @@ void test_compare()
lhs = gwbuf_append(lhs, gwbuf_alloc_and_load(5, data));
lhs = gwbuf_append(lhs, gwbuf_alloc_and_load(5, data + 5));
ss_dassert(gwbuf_compare(lhs, rhs) == 0);
ss_dassert(gwbuf_compare(rhs, lhs) == 0);
mxb_assert(gwbuf_compare(lhs, rhs) == 0);
mxb_assert(gwbuf_compare(rhs, lhs) == 0);
// Both segmented and of same length, but different.
gwbuf_free(lhs);
@ -375,8 +375,8 @@ void test_compare()
lhs = gwbuf_append(lhs, gwbuf_alloc_and_load(5, data + 5)); // Values in different order
lhs = gwbuf_append(lhs, gwbuf_alloc_and_load(5, data));
ss_dassert(gwbuf_compare(lhs, rhs) > 0); // 5 > 1
ss_dassert(gwbuf_compare(rhs, lhs) < 0); // 5 > 1
mxb_assert(gwbuf_compare(lhs, rhs) > 0); // 5 > 1
mxb_assert(gwbuf_compare(rhs, lhs) < 0); // 5 > 1
// Identical, but one containing empty segments.
gwbuf_free(rhs);
@ -387,8 +387,8 @@ void test_compare()
rhs = gwbuf_append(rhs, gwbuf_alloc_and_load(5, data));
rhs = gwbuf_append(rhs, gwbuf_alloc_and_load(0, data));
ss_dassert(gwbuf_compare(lhs, rhs) == 0);
ss_dassert(gwbuf_compare(rhs, lhs) == 0);
mxb_assert(gwbuf_compare(lhs, rhs) == 0);
mxb_assert(gwbuf_compare(rhs, lhs) == 0);
gwbuf_free(lhs);
gwbuf_free(rhs);
@ -413,12 +413,12 @@ void test_clone()
GWBUF* o = original;
GWBUF* c = clone;
ss_dassert(gwbuf_length(o) == gwbuf_length(c));
mxb_assert(gwbuf_length(o) == gwbuf_length(c));
while (o)
{
ss_dassert(c);
ss_dassert(GWBUF_LENGTH(o) == GWBUF_LENGTH(c));
mxb_assert(c);
mxb_assert(GWBUF_LENGTH(o) == GWBUF_LENGTH(c));
const char* i = (char*)GWBUF_DATA(o);
const char* end = i + GWBUF_LENGTH(o);
@ -426,7 +426,7 @@ void test_clone()
while (i != end)
{
ss_dassert(*i == *j);
mxb_assert(*i == *j);
++i;
++j;
}
@ -435,7 +435,7 @@ void test_clone()
c = c->next;
}
ss_dassert(c == NULL);
mxb_assert(c == NULL);
gwbuf_free(clone);
gwbuf_free(original);
@ -464,48 +464,48 @@ test1()
fprintf(stderr, "\t..done\nAllocated buffer of size %lu.", size);
buflen = GWBUF_LENGTH(buffer);
fprintf(stderr, "\nBuffer length is now %lu", buflen);
ss_info_dassert(size == buflen, "Incorrect buffer size");
ss_info_dassert(0 == GWBUF_EMPTY(buffer), "Buffer should not be empty");
ss_info_dassert(GWBUF_IS_TYPE_UNDEFINED(buffer), "Buffer type should be undefined");
mxb_assert_message(size == buflen, "Incorrect buffer size");
mxb_assert_message(0 == GWBUF_EMPTY(buffer), "Buffer should not be empty");
mxb_assert_message(GWBUF_IS_TYPE_UNDEFINED(buffer), "Buffer type should be undefined");
fprintf(stderr, "\t..done\nSet a property for the buffer");
gwbuf_add_property(buffer, (char*)"name", (char*)"value");
ss_info_dassert(0 == strcmp("value", gwbuf_get_property(buffer, (char*)"name")),
mxb_assert_message(0 == strcmp("value", gwbuf_get_property(buffer, (char*)"name")),
"Should now have correct property");
strcpy((char*)GWBUF_DATA(buffer), "The quick brown fox jumps over the lazy dog");
fprintf(stderr, "\t..done\nLoad some data into the buffer");
ss_info_dassert('q' == GWBUF_DATA_CHAR(buffer, 4), "Fourth character of buffer must be 'q'");
ss_info_dassert(-1 == GWBUF_DATA_CHAR(buffer, 105), "Hundred and fifth character of buffer must return -1");
ss_info_dassert(0 == GWBUF_IS_SQL(buffer), "Must say buffer is not SQL, as it does not have marker");
mxb_assert_message('q' == GWBUF_DATA_CHAR(buffer, 4), "Fourth character of buffer must be 'q'");
mxb_assert_message(-1 == GWBUF_DATA_CHAR(buffer, 105), "Hundred and fifth character of buffer must return -1");
mxb_assert_message(0 == GWBUF_IS_SQL(buffer), "Must say buffer is not SQL, as it does not have marker");
strcpy((char*)GWBUF_DATA(buffer), "1234\x03SELECT * FROM sometable");
fprintf(stderr, "\t..done\nLoad SQL data into the buffer");
ss_info_dassert(1 == GWBUF_IS_SQL(buffer), "Must say buffer is SQL, as it does have marker");
mxb_assert_message(1 == GWBUF_IS_SQL(buffer), "Must say buffer is SQL, as it does have marker");
clone = gwbuf_clone(buffer);
fprintf(stderr, "\t..done\nCloned buffer");
buflen = GWBUF_LENGTH(clone);
fprintf(stderr, "\nCloned buffer length is now %lu", buflen);
ss_info_dassert(size == buflen, "Incorrect buffer size");
ss_info_dassert(0 == GWBUF_EMPTY(clone), "Cloned buffer should not be empty");
mxb_assert_message(size == buflen, "Incorrect buffer size");
mxb_assert_message(0 == GWBUF_EMPTY(clone), "Cloned buffer should not be empty");
fprintf(stderr, "\t..done\n");
gwbuf_free(clone);
fprintf(stderr, "Freed cloned buffer");
fprintf(stderr, "\t..done\n");
buffer = gwbuf_consume(buffer, bite1);
ss_info_dassert(NULL != buffer, "Buffer should not be null");
mxb_assert_message(NULL != buffer, "Buffer should not be null");
buflen = GWBUF_LENGTH(buffer);
fprintf(stderr, "Consumed %lu bytes, now have %lu, should have %lu", bite1, buflen, size - bite1);
ss_info_dassert((size - bite1) == buflen, "Incorrect buffer size");
ss_info_dassert(0 == GWBUF_EMPTY(buffer), "Buffer should not be empty");
mxb_assert_message((size - bite1) == buflen, "Incorrect buffer size");
mxb_assert_message(0 == GWBUF_EMPTY(buffer), "Buffer should not be empty");
fprintf(stderr, "\t..done\n");
buffer = gwbuf_consume(buffer, bite2);
ss_info_dassert(NULL != buffer, "Buffer should not be null");
mxb_assert_message(NULL != buffer, "Buffer should not be null");
buflen = GWBUF_LENGTH(buffer);
fprintf(stderr, "Consumed %lu bytes, now have %lu, should have %lu", bite2, buflen, size - bite1 - bite2);
ss_info_dassert((size - bite1 - bite2) == buflen, "Incorrect buffer size");
ss_info_dassert(0 == GWBUF_EMPTY(buffer), "Buffer should not be empty");
mxb_assert_message((size - bite1 - bite2) == buflen, "Incorrect buffer size");
mxb_assert_message(0 == GWBUF_EMPTY(buffer), "Buffer should not be empty");
fprintf(stderr, "\t..done\n");
buffer = gwbuf_consume(buffer, bite3);
fprintf(stderr, "Consumed %lu bytes, should have null buffer", bite3);
ss_info_dassert(NULL == buffer, "Buffer should be null");
mxb_assert_message(NULL == buffer, "Buffer should be null");
/* Buffer list tests */
size = 100000;
@ -513,26 +513,26 @@ test1()
fprintf(stderr, "\t..done\nAllocated buffer of size %lu.", size);
buflen = GWBUF_LENGTH(buffer);
fprintf(stderr, "\nBuffer length is now %lu", buflen);
ss_info_dassert(size == buflen, "Incorrect buffer size");
ss_info_dassert(0 == GWBUF_EMPTY(buffer), "Buffer should not be empty");
ss_info_dassert(GWBUF_IS_TYPE_UNDEFINED(buffer), "Buffer type should be undefined");
mxb_assert_message(size == buflen, "Incorrect buffer size");
mxb_assert_message(0 == GWBUF_EMPTY(buffer), "Buffer should not be empty");
mxb_assert_message(GWBUF_IS_TYPE_UNDEFINED(buffer), "Buffer type should be undefined");
extra = gwbuf_alloc(size);
buflen = GWBUF_LENGTH(buffer);
fprintf(stderr, "\t..done\nAllocated extra buffer of size %lu.", size);
ss_info_dassert(size == buflen, "Incorrect buffer size");
mxb_assert_message(size == buflen, "Incorrect buffer size");
buffer = gwbuf_append(buffer, extra);
buflen = gwbuf_length(buffer);
fprintf(stderr, "\t..done\nAppended extra buffer to original buffer to create list of size %lu", buflen);
ss_info_dassert((size * 2) == gwbuf_length(buffer), "Incorrect size for set of buffers");
mxb_assert_message((size * 2) == gwbuf_length(buffer), "Incorrect size for set of buffers");
buffer = gwbuf_rtrim(buffer, 60000);
buflen = GWBUF_LENGTH(buffer);
fprintf(stderr, "\t..done\nTrimmed 60 bytes from buffer, now size is %lu.", buflen);
ss_info_dassert((size - 60000) == buflen, "Incorrect buffer size");
mxb_assert_message((size - 60000) == buflen, "Incorrect buffer size");
buffer = gwbuf_rtrim(buffer, 60000);
buflen = GWBUF_LENGTH(buffer);
fprintf(stderr, "\t..done\nTrimmed another 60 bytes from buffer, now size is %lu.", buflen);
ss_info_dassert(100000 == buflen, "Incorrect buffer size");
ss_info_dassert(buffer == extra, "The buffer pointer should now point to the extra buffer");
mxb_assert_message(100000 == buflen, "Incorrect buffer size");
mxb_assert_message(buffer == extra, "The buffer pointer should now point to the extra buffer");
fprintf(stderr, "\t..done\n");
gwbuf_free(buffer);
/** gwbuf_clone_all test */
@ -541,16 +541,16 @@ test1()
size_t tailsize = 20;
GWBUF* tail = gwbuf_alloc(tailsize);
ss_info_dassert(head && tail, "Head and tail buffers should both be non-NULL");
mxb_assert_message(head && tail, "Head and tail buffers should both be non-NULL");
GWBUF* append = gwbuf_append(head, tail);
ss_info_dassert(append == head, "gwbuf_append should return head");
ss_info_dassert(append->next == tail, "After append tail should be in the next pointer of head");
ss_info_dassert(append->tail == tail, "After append tail should be in the tail pointer of head");
mxb_assert_message(append == head, "gwbuf_append should return head");
mxb_assert_message(append->next == tail, "After append tail should be in the next pointer of head");
mxb_assert_message(append->tail == tail, "After append tail should be in the tail pointer of head");
GWBUF* all_clones = gwbuf_clone(head);
ss_info_dassert(all_clones && all_clones->next, "Cloning all should work");
ss_info_dassert(GWBUF_LENGTH(all_clones) == headsize, "First buffer should be 10 bytes");
ss_info_dassert(GWBUF_LENGTH(all_clones->next) == tailsize, "Second buffer should be 20 bytes");
ss_info_dassert(gwbuf_length(all_clones) == headsize + tailsize, "Total buffer length should be 30 bytes");
mxb_assert_message(all_clones && all_clones->next, "Cloning all should work");
mxb_assert_message(GWBUF_LENGTH(all_clones) == headsize, "First buffer should be 10 bytes");
mxb_assert_message(GWBUF_LENGTH(all_clones->next) == tailsize, "Second buffer should be 20 bytes");
mxb_assert_message(gwbuf_length(all_clones) == headsize + tailsize, "Total buffer length should be 30 bytes");
gwbuf_free(all_clones);
gwbuf_free(head);

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

@ -424,7 +424,7 @@ int test_event_configuration()
}
else
{
ss_dassert(c.what == What::LEVEL);
mxb_assert(c.what == What::LEVEL);
int32_t level = event::get_log_level(c.id);

6
server/core/test/test_hint.cc
View File

@ -51,9 +51,9 @@ test1()
char* name = MXS_STRDUP_A("name");
hint = hint_create_parameter(NULL, name, "value");
MXS_FREE(name);
ss_info_dassert(NULL != hint, "New hint list should not be null");
ss_info_dassert(0 == strcmp("value", (char*)hint->value), "Hint value should be correct");
ss_info_dassert(0 != hint_exists(&hint, HINT_PARAMETER), "Hint of parameter type should exist");
mxb_assert_message(NULL != hint, "New hint list should not be null");
mxb_assert_message(0 == strcmp("value", (char*)hint->value), "Hint value should be correct");
mxb_assert_message(0 != hint_exists(&hint, HINT_PARAMETER), "Hint of parameter type should exist");
fprintf(stderr, "\t..done\nFree hints.");
if (NULL != hint)
{

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

@ -32,8 +32,8 @@ int main(int argc, char** argv)
cout << "Converted Linux time: " << converted_now << endl;
cout << "Converted HTTP-date: " << converted_date << endl;
ss_dassert(now == converted_now);
ss_dassert(date == converted_date);
mxb_assert(now == converted_now);
mxb_assert(date == converted_date);
return 0;
}

42
server/core/test/test_json.cc
View File

@ -259,33 +259,33 @@ int test1()
json_error_t err = {};
json_t* json = json_loads(test1_json, 0, &err);
ss_dassert(json);
mxb_assert(json);
ss_dassert(mxs_json_pointer(json, "") == json);
ss_dassert(mxs_json_pointer(json, "links") == json_object_get(json, "links"));
ss_dassert(json_is_string(mxs_json_pointer(json, "links/self")));
mxb_assert(mxs_json_pointer(json, "") == json);
mxb_assert(mxs_json_pointer(json, "links") == json_object_get(json, "links"));
mxb_assert(json_is_string(mxs_json_pointer(json, "links/self")));
ss_dassert(mxs_json_pointer(json, "data") == json_object_get(json, "data"));
ss_dassert(json_is_array(mxs_json_pointer(json, "data")));
mxb_assert(mxs_json_pointer(json, "data") == json_object_get(json, "data"));
mxb_assert(json_is_array(mxs_json_pointer(json, "data")));
ss_dassert(json_is_object(mxs_json_pointer(json, "data/0")));
ss_dassert(json_is_string(mxs_json_pointer(json, "data/0/id")));
mxb_assert(json_is_object(mxs_json_pointer(json, "data/0")));
mxb_assert(json_is_string(mxs_json_pointer(json, "data/0/id")));
string s = json_string_value(mxs_json_pointer(json, "data/0/id"));
ss_dassert(s == "server1");
mxb_assert(s == "server1");
ss_dassert(json_is_object(mxs_json_pointer(json, "data/1")));
ss_dassert(json_is_string(mxs_json_pointer(json, "data/1/id")));
mxb_assert(json_is_object(mxs_json_pointer(json, "data/1")));
mxb_assert(json_is_string(mxs_json_pointer(json, "data/1/id")));
s = json_string_value(mxs_json_pointer(json, "data/1/id"));
ss_dassert(s == "server2");
mxb_assert(s == "server2");
ss_dassert(json_is_object(mxs_json_pointer(json, "data/0/attributes")));
ss_dassert(json_is_object(mxs_json_pointer(json, "data/0/attributes/parameters")));
ss_dassert(json_is_integer(mxs_json_pointer(json, "data/0/attributes/parameters/port")));
mxb_assert(json_is_object(mxs_json_pointer(json, "data/0/attributes")));
mxb_assert(json_is_object(mxs_json_pointer(json, "data/0/attributes/parameters")));
mxb_assert(json_is_integer(mxs_json_pointer(json, "data/0/attributes/parameters/port")));
int i = json_integer_value(mxs_json_pointer(json, "data/0/attributes/parameters/port"));
ss_dassert(i == 3000);
mxb_assert(i == 3000);
ss_dassert(json_is_array(mxs_json_pointer(json, "data/0/attributes/slaves")));
ss_dassert(json_array_size(mxs_json_pointer(json, "data/0/attributes/slaves")) == 3);
mxb_assert(json_is_array(mxs_json_pointer(json, "data/0/attributes/slaves")));
mxb_assert(json_array_size(mxs_json_pointer(json, "data/0/attributes/slaves")) == 3);
json_decref(json);
@ -300,7 +300,7 @@ int test2()
err = mxs_json_error("%s", "This is an error!");
s = json_dumps(err, 0);
printf("%s\n", s);
ss_dassert(strcmp(s, "{\"errors\": [{\"detail\": \"This is an error!\"}]}") == 0);
mxb_assert(strcmp(s, "{\"errors\": [{\"detail\": \"This is an error!\"}]}") == 0);
MXS_FREE(s);
json_decref(err);
@ -308,13 +308,13 @@ int test2()
err = mxs_json_error_append(NULL, "%s", "This is an error!");
s = json_dumps(err, 0);
printf("%s\n", s);
ss_dassert(strcmp(s, "{\"errors\": [{\"detail\": \"This is an error!\"}]}") == 0);
mxb_assert(strcmp(s, "{\"errors\": [{\"detail\": \"This is an error!\"}]}") == 0);
MXS_FREE(s);
err = mxs_json_error_append(err, "%s", "This is another error!");
s = json_dumps(err, 0);
printf("%s\n", s);
ss_dassert(strcmp(s,
mxb_assert(strcmp(s,
"{\"errors\": [{\"detail\": \"This is an error!\"}, "
"{\"detail\": \"This is another error!\"}]}") == 0);
MXS_FREE(s);

92
server/core/test/test_log.cc
View File

@ -44,7 +44,7 @@ int main(int argc, char* argv[])
succp = mxs_log_init(NULL, "/tmp", MXS_LOG_TARGET_FS);
ss_info_dassert(succp, "Log manager initialization failed");
mxb_assert_message(succp, "Log manager initialization failed");
t = time(NULL);
localtime_r(&t, &tm);
@ -58,55 +58,55 @@ int main(int argc, char* argv[])
logstr = ("First write with flush.");
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("Second write with flush.");
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("Third write, no flush.");
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("Fourth write, no flush. Next flush only.");
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = "My name is %s %d years and %d months.";
err = MXS_INFO(logstr, "TraceyTracey", 3, 7);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = "My name is Tracey Tracey 47 years and 7 months.";
err = MXS_INFO("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = "My name is Stacey %s";
err = MXS_INFO(logstr, " ");
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = "My name is Philip";
err = MXS_INFO("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = "Philip.";
err = MXS_INFO("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = "Ph%dlip.";
err = MXS_INFO(logstr, 1);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("A terrible error has occurred!");
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("Hi, how are you?");
err = MXS_NOTICE("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("I'm doing fine!");
err = MXS_NOTICE("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("Rather more surprising, at least at first sight, is the fact that a reference to "
"a[i] can also be written as *(a+i). In evaluating a[i], C converts it to *(a+i) "
@ -114,128 +114,128 @@ int main(int argc, char* argv[])
"of this equivalence, it follows that &a[i] and a+i are also identical: a+i is the "
"address of the i-th element beyond a.");
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("I was wondering, you know, it has been such a lovely weather whole morning and I "
"thought that would you like to come to my place and have a little piece of cheese "
"with us. Just me and my mom - and you, of course. Then, if you wish, we could "
"listen to the radio and keep company for our little Steven, my mom's cat, you know.");
err = MXS_NOTICE("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("\tTEST 3 - test enabling and disabling logs.");
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
skygw_log_disable(LOG_INFO);
logstr = ("1.\tWrite once to ERROR and twice to MESSAGE log.");
err = MXS_NOTICE("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
err = MXS_INFO("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
skygw_log_enable(LOG_INFO);
logstr = ("2.\tWrite to once to ERROR, twice to MESSAGE and "
"three times to TRACE log.");
err = MXS_NOTICE("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
err = MXS_INFO("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
skygw_log_disable(LOG_ERR);
logstr = ("3.\tWrite to once to MESSAGE and twice to TRACE log.");
err = MXS_NOTICE("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
err = MXS_INFO("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
skygw_log_disable(LOG_NOTICE);
skygw_log_disable(LOG_INFO);
logstr = ("4.\tWrite to none.");
err = MXS_NOTICE("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
err = MXS_INFO("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
skygw_log_enable(LOG_ERR);
skygw_log_enable(LOG_NOTICE);
logstr = ("4.\tWrite once to ERROR and twice to MESSAGE log.");
err = MXS_NOTICE("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
err = MXS_INFO("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
skygw_log_enable(LOG_INFO);
logstr = ("\tTEST 4 - test spreading logs down to other logs.");
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("1.\tWrite to ERROR and thus also to MESSAGE and TRACE logs.");
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("2.\tWrite to MESSAGE and thus to TRACE logs.");
err = MXS_NOTICE("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
skygw_log_enable(LOG_INFO);
logstr = ("3.\tWrite to TRACE log only.");
err = MXS_INFO("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
skygw_log_disable(LOG_NOTICE);
logstr = ("4.\tWrite to ERROR and thus also to TRACE log. "
"MESSAGE is disabled.");
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("5.\tThis should not appear anywhere since MESSAGE "
"is disabled.");
err = MXS_NOTICE("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
skygw_log_enable(LOG_INFO);
logstr = ("6.\tWrite to ERROR and thus also to MESSAGE and TRACE logs.");
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("7.\tWrite to MESSAGE and thus to TRACE logs.");
err = MXS_NOTICE("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("8.\tWrite to TRACE log only.");
skygw_log_enable(LOG_INFO);
err = MXS_INFO("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
skygw_log_disable(LOG_NOTICE);
logstr = ("9.\tWrite to ERROR and thus also to TRACE log. "
"MESSAGE is disabled");
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("10.\tThis should not appear anywhere since MESSAGE is "
"disabled.");
err = MXS_NOTICE("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
skygw_log_enable(LOG_NOTICE);
@ -244,20 +244,20 @@ int main(int argc, char* argv[])
(int)3,
"foo",
(int)3);
ss_dassert(err == 0);
mxb_assert(err == 0);
err = MXS_ERROR("12.\tWrite to MESSAGE and TRACE log some "
"formattings "
": %d %s %d",
(int)3,
"foo",
(int)3);
ss_dassert(err == 0);
mxb_assert(err == 0);
err = MXS_ERROR("13.\tWrite to TRACE log some formattings "
": %d %s %d",
(int)3,
"foo",
(int)3);
ss_dassert(err == 0);
mxb_assert(err == 0);
mxs_log_finish();

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

@ -80,7 +80,7 @@ int main(int argc, char** argv)
{
fprintf(stderr, "Error, log manager initialization failed.\n");
}
ss_dassert(succp);
mxb_assert(succp);
skygw_log_disable(LOG_INFO);
skygw_log_disable(LOG_NOTICE);

256
server/core/test/test_modutil.cc
View File

@ -53,16 +53,16 @@ test1()
fprintf(stderr,
"testmodutil : Rudimentary tests.");
buffer = gwbuf_alloc(100);
ss_info_dassert(GWBUF_IS_CONTIGUOUS(buffer), "Allocated buffer should be continuos");
mxb_assert_message(GWBUF_IS_CONTIGUOUS(buffer), "Allocated buffer should be continuos");
memset(GWBUF_DATA(buffer), 0, GWBUF_LENGTH(buffer));
ss_info_dassert(0 == modutil_is_SQL(buffer), "Default buffer should be diagnosed as not SQL");
mxb_assert_message(0 == modutil_is_SQL(buffer), "Default buffer should be diagnosed as not SQL");
/* There would ideally be some straightforward way to create a SQL buffer? */
fprintf(stderr, "\t..done\nExtract SQL from buffer");
ss_info_dassert(0 == modutil_extract_SQL(buffer, &sql, &length), "Default buffer should fail");
mxb_assert_message(0 == modutil_extract_SQL(buffer, &sql, &length), "Default buffer should fail");
fprintf(stderr, "\t..done\nExtract SQL from buffer different way?");
ss_info_dassert(0 == modutil_MySQL_Query(buffer, &sql, &length, &residual), "Default buffer should fail");
mxb_assert_message(0 == modutil_MySQL_Query(buffer, &sql, &length, &residual), "Default buffer should fail");
fprintf(stderr, "\t..done\nReplace SQL in buffer");
ss_info_dassert(0 == modutil_replace_SQL(buffer, (char*)"select * from some_table;"),
mxb_assert_message(0 == modutil_replace_SQL(buffer, (char*)"select * from some_table;"),
"Default buffer should fail");
fprintf(stderr, "\t..done\nTidy up.");
gwbuf_free(buffer);
@ -81,7 +81,7 @@ test2()
/** Allocate space for the COM_QUERY header and payload */
buffer = gwbuf_alloc(5 + 128);
ss_info_dassert((buffer != NULL), "Buffer should not be null");
mxb_assert_message((buffer != NULL), "Buffer should not be null");
memset(query, ';', 128);
memset(query + 128, '\0', 1);
@ -92,7 +92,7 @@ test2()
*((unsigned char*)buffer->start + 4) = 0x03;
memcpy((uint8_t*)buffer->start + 5, query, strlen(query));
char* result = modutil_get_SQL(buffer);
ss_dassert(strcmp(result, query) == 0);
mxb_assert(strcmp(result, query) == 0);
gwbuf_free(buffer);
MXS_FREE(result);
fprintf(stderr, "\t..done\n");
@ -164,27 +164,27 @@ void test_single_sql_packet1()
/** Single packet */
GWBUF* buffer = gwbuf_alloc_and_load(sizeof(ok), ok);
GWBUF* complete = modutil_get_complete_packets(&buffer);
ss_info_dassert(buffer == NULL, "Old buffer should be NULL");
ss_info_dassert(complete, "Complete packet buffer should not be NULL");
ss_info_dassert(gwbuf_length(complete) == sizeof(ok), "Complete packet buffer should contain enough data");
ss_info_dassert(memcmp(GWBUF_DATA(complete), ok, GWBUF_LENGTH(complete)) == 0,
mxb_assert_message(buffer == NULL, "Old buffer should be NULL");
mxb_assert_message(complete, "Complete packet buffer should not be NULL");
mxb_assert_message(gwbuf_length(complete) == sizeof(ok), "Complete packet buffer should contain enough data");
mxb_assert_message(memcmp(GWBUF_DATA(complete), ok, GWBUF_LENGTH(complete)) == 0,
"Complete packet buffer's data should be equal to original data");
gwbuf_free(complete);
/** Partial single packet */
buffer = gwbuf_alloc_and_load(sizeof(ok) - 4, ok);
complete = modutil_get_complete_packets(&buffer);
ss_info_dassert(buffer, "Old buffer should be not NULL");
ss_info_dassert(complete == NULL, "Complete packet buffer should be NULL");
ss_info_dassert(gwbuf_length(buffer) == sizeof(ok) - 4, "Old buffer should contain right amount of data");
mxb_assert_message(buffer, "Old buffer should be not NULL");
mxb_assert_message(complete == NULL, "Complete packet buffer should be NULL");
mxb_assert_message(gwbuf_length(buffer) == sizeof(ok) - 4, "Old buffer should contain right amount of data");
/** Add the missing data */
buffer = gwbuf_append(buffer, gwbuf_alloc_and_load(4, ok + sizeof(ok) - 4));
complete = modutil_get_complete_packets(&buffer);
ss_info_dassert(buffer == NULL, "Old buffer should be NULL");
ss_info_dassert(complete, "Complete packet buffer should not be NULL");
ss_info_dassert(complete->next, "The complete packet should be a chain of buffers");
ss_info_dassert(gwbuf_length(complete) == sizeof(ok), "Buffer should contain all data");
mxb_assert_message(buffer == NULL, "Old buffer should be NULL");
mxb_assert_message(complete, "Complete packet buffer should not be NULL");
mxb_assert_message(complete->next, "The complete packet should be a chain of buffers");
mxb_assert_message(gwbuf_length(complete) == sizeof(ok), "Buffer should contain all data");
gwbuf_free(complete);
}
@ -194,11 +194,11 @@ void test_multiple_sql_packets1()
/** All of the data */
GWBUF* buffer = gwbuf_alloc_and_load(sizeof(resultset), resultset);
GWBUF* complete = modutil_get_complete_packets(&buffer);
ss_info_dassert(buffer == NULL, "Old buffer should be NULL");
ss_info_dassert(complete, "Complete packet buffer should not be NULL");
ss_info_dassert(gwbuf_length(complete) == sizeof(resultset),
mxb_assert_message(buffer == NULL, "Old buffer should be NULL");
mxb_assert_message(complete, "Complete packet buffer should not be NULL");
mxb_assert_message(gwbuf_length(complete) == sizeof(resultset),
"Complete packet buffer should contain enough data");
ss_info_dassert(memcmp(GWBUF_DATA(complete), resultset, GWBUF_LENGTH(complete)) == 0,
mxb_assert_message(memcmp(GWBUF_DATA(complete), resultset, GWBUF_LENGTH(complete)) == 0,
"Complete packet buffer's data should be equal to original data");
gwbuf_free(complete);
@ -206,18 +206,18 @@ void test_multiple_sql_packets1()
GWBUF* head = gwbuf_alloc_and_load(7, resultset);
GWBUF* tail = gwbuf_alloc_and_load(sizeof(resultset) - 7, resultset + 7);
complete = modutil_get_complete_packets(&head);
ss_info_dassert(head, "Old buffer should not be NULL");
ss_info_dassert(complete, "Complete buffer should not be NULL");
ss_info_dassert(gwbuf_length(complete) == 5, "Complete buffer should contain first packet only");
ss_info_dassert(gwbuf_length(head) == 2, "Complete buffer should contain first packet only");
mxb_assert_message(head, "Old buffer should not be NULL");
mxb_assert_message(complete, "Complete buffer should not be NULL");
mxb_assert_message(gwbuf_length(complete) == 5, "Complete buffer should contain first packet only");
mxb_assert_message(gwbuf_length(head) == 2, "Complete buffer should contain first packet only");
gwbuf_free(complete);
/** All packets are available */
head = gwbuf_append(head, tail);
complete = modutil_get_complete_packets(&head);
ss_info_dassert(head == NULL, "Old buffer should be NULL");
ss_info_dassert(complete, "Complete packet buffer should not be NULL");
ss_info_dassert(gwbuf_length(complete) == sizeof(resultset) - 5,
mxb_assert_message(head == NULL, "Old buffer should be NULL");
mxb_assert_message(complete, "Complete packet buffer should not be NULL");
mxb_assert_message(gwbuf_length(complete) == sizeof(resultset) - 5,
"Complete packet should be sizeof(resultset) - 5 bytes");
gwbuf_free(complete);
@ -230,12 +230,12 @@ void test_multiple_sql_packets1()
complete = modutil_get_complete_packets(&head);
int headlen = gwbuf_length(head);
int completelen = complete ? gwbuf_length(complete) : 0;
ss_info_dassert(headlen + completelen == sizeof(resultset),
mxb_assert_message(headlen + completelen == sizeof(resultset),
"Both buffers should sum up to sizeof(resutlset) bytes");
uint8_t databuf[sizeof(resultset)];
gwbuf_copy_data(complete, 0, completelen, databuf);
gwbuf_copy_data(head, 0, headlen, databuf + completelen);
ss_info_dassert(memcmp(databuf, resultset, sizeof(resultset)) == 0, "Data should be OK");
mxb_assert_message(memcmp(databuf, resultset, sizeof(resultset)) == 0, "Data should be OK");
gwbuf_free(head);
gwbuf_free(complete);
}
@ -253,48 +253,48 @@ void test_multiple_sql_packets1()
}
while (total < sizeof(resultset));
ss_info_dassert(gwbuf_length(head) == sizeof(resultset), "Head should be sizeof(resulset) bytes long");
mxb_assert_message(gwbuf_length(head) == sizeof(resultset), "Head should be sizeof(resulset) bytes long");
complete = modutil_get_complete_packets(&head);
ss_info_dassert(head == NULL, "Head should be NULL");
ss_info_dassert(complete, "Complete should not be NULL");
ss_info_dassert(gwbuf_length(complete) == sizeof(resultset),
mxb_assert_message(head == NULL, "Head should be NULL");
mxb_assert_message(complete, "Complete should not be NULL");
mxb_assert_message(gwbuf_length(complete) == sizeof(resultset),
"Complete should be sizeof(resulset) bytes long");
unsigned int headlen = gwbuf_length(head);
unsigned int completelen = complete ? gwbuf_length(complete) : 0;
uint8_t databuf[sizeof(resultset)];
ss_info_dassert(gwbuf_copy_data(complete, 0, completelen, databuf) == completelen,
mxb_assert_message(gwbuf_copy_data(complete, 0, completelen, databuf) == completelen,
"Expected data should be readable");
ss_info_dassert(gwbuf_copy_data(head, 0, headlen, databuf + completelen) == headlen,
mxb_assert_message(gwbuf_copy_data(head, 0, headlen, databuf + completelen) == headlen,
"Expected data should be readable");
ss_info_dassert(memcmp(databuf, resultset, sizeof(resultset)) == 0, "Data should be OK");
mxb_assert_message(memcmp(databuf, resultset, sizeof(resultset)) == 0, "Data should be OK");
/** Fragmented buffer split into multiple chains and then reassembled as a complete resultset */
GWBUF* half = complete;
GWBUF* quarter = gwbuf_split(&half, gwbuf_length(half) / 2);
head = gwbuf_split(&quarter, gwbuf_length(quarter) / 2);
ss_info_dassert(half && quarter && head, "gwbuf_split should work");
mxb_assert_message(half && quarter && head, "gwbuf_split should work");
complete = modutil_get_complete_packets(&head);
ss_info_dassert(complete && head, "Both buffers should have data");
ss_info_dassert(gwbuf_length(complete) + gwbuf_length(head) + gwbuf_length(quarter)
mxb_assert_message(complete && head, "Both buffers should have data");
mxb_assert_message(gwbuf_length(complete) + gwbuf_length(head) + gwbuf_length(quarter)
+ gwbuf_length(half) == sizeof(resultset), "25% of data should be available");
quarter = gwbuf_append(gwbuf_append(complete, head), quarter);
complete = modutil_get_complete_packets(&quarter);
ss_info_dassert(gwbuf_length(complete) + gwbuf_length(quarter) +
mxb_assert_message(gwbuf_length(complete) + gwbuf_length(quarter) +
gwbuf_length(half) == sizeof(resultset), "50% of data should be available");
half = gwbuf_append(gwbuf_append(complete, quarter), half);
complete = modutil_get_complete_packets(&half);
ss_info_dassert(complete, "Complete should not be NULL");
ss_info_dassert(half == NULL, "Old buffer should be NULL");
ss_info_dassert(gwbuf_length(complete) == sizeof(resultset), "Complete should contain 100% of data");
mxb_assert_message(complete, "Complete should not be NULL");
mxb_assert_message(half == NULL, "Old buffer should be NULL");
mxb_assert_message(gwbuf_length(complete) == sizeof(resultset), "Complete should contain 100% of data");
completelen = gwbuf_length(complete);
ss_info_dassert(gwbuf_copy_data(complete, 0, completelen, databuf) == completelen,
mxb_assert_message(gwbuf_copy_data(complete, 0, completelen, databuf) == completelen,
"All data should be readable");
ss_info_dassert(memcmp(databuf, resultset, sizeof(resultset)) == 0, "Data should be OK");
mxb_assert_message(memcmp(databuf, resultset, sizeof(resultset)) == 0, "Data should be OK");
gwbuf_free(complete);
}
@ -310,10 +310,10 @@ void test_single_sql_packet2()
buffer = gwbuf_alloc_and_load(sizeof(ok), ok);
next = modutil_get_next_MySQL_packet(&buffer);
ss_info_dassert(buffer == NULL, "Old buffer should be NULL");
ss_info_dassert(next, "Next packet buffer should not be NULL");
ss_info_dassert(gwbuf_length(next) == sizeof(ok), "Next packet buffer should contain enough data");
ss_info_dassert(memcmp(GWBUF_DATA(next), ok, GWBUF_LENGTH(next)) == 0,
mxb_assert_message(buffer == NULL, "Old buffer should be NULL");
mxb_assert_message(next, "Next packet buffer should not be NULL");
mxb_assert_message(gwbuf_length(next) == sizeof(ok), "Next packet buffer should contain enough data");
mxb_assert_message(memcmp(GWBUF_DATA(next), ok, GWBUF_LENGTH(next)) == 0,
"Next packet buffer's data should be equal to original data");
gwbuf_free(buffer);
gwbuf_free(next);
@ -321,18 +321,18 @@ void test_single_sql_packet2()
/** Partial single packet */
buffer = gwbuf_alloc_and_load(sizeof(ok) - 4, ok);
next = modutil_get_next_MySQL_packet(&buffer);
ss_info_dassert(buffer, "Old buffer should be not NULL");
ss_info_dassert(next == NULL, "Next packet buffer should be NULL");
ss_info_dassert(gwbuf_length(buffer) == sizeof(ok) - 4, "Old buffer should contain right amount of data");
mxb_assert_message(buffer, "Old buffer should be not NULL");
mxb_assert_message(next == NULL, "Next packet buffer should be NULL");
mxb_assert_message(gwbuf_length(buffer) == sizeof(ok) - 4, "Old buffer should contain right amount of data");
/** Add the missing data */
buffer = gwbuf_append(buffer, gwbuf_alloc_and_load(4, ok + sizeof(ok) - 4));
next = modutil_get_next_MySQL_packet(&buffer);
ss_info_dassert(buffer == NULL, "Old buffer should be NULL");
ss_info_dassert(next, "Next packet buffer should not be NULL");
mxb_assert_message(buffer == NULL, "Old buffer should be NULL");
mxb_assert_message(next, "Next packet buffer should not be NULL");
//To be put back when the current realloc behaviour is replaced with splitting behaviour.
//ss_info_dassert(next->next, "The next packet should be a chain of buffers");
ss_info_dassert(gwbuf_length(next) == sizeof(ok), "Buffer should contain all data");
//mxb_assert_message(next->next, "The next packet should be a chain of buffers");
mxb_assert_message(gwbuf_length(next) == sizeof(ok), "Buffer should contain all data");
gwbuf_free(next);
}
@ -348,38 +348,38 @@ void test_multiple_sql_packets2()
for (unsigned int i = 0; i < N_PACKETS; i++)
{
GWBUF* next = modutil_get_next_MySQL_packet(&buffer);
ss_info_dassert(next, "Next packet buffer should not be NULL");
ss_info_dassert(gwbuf_length(next) == packets[i].length,
mxb_assert_message(next, "Next packet buffer should not be NULL");
mxb_assert_message(gwbuf_length(next) == packets[i].length,
"Next packet buffer should contain enough data");
ss_info_dassert(memcmp(GWBUF_DATA(next), &resultset[packets[i].index], GWBUF_LENGTH(next)) == 0,
mxb_assert_message(memcmp(GWBUF_DATA(next), &resultset[packets[i].index], GWBUF_LENGTH(next)) == 0,
"Next packet buffer's data should be equal to original data");
gwbuf_free(next);
}
ss_info_dassert(buffer == NULL, "Buffer should be NULL");
mxb_assert_message(buffer == NULL, "Buffer should be NULL");
size_t len;
// Exactly one packet
len = PACKET_1_LEN;
buffer = gwbuf_alloc_and_load(len, resultset);
next = modutil_get_next_MySQL_packet(&buffer);
ss_info_dassert(buffer == NULL, "Old buffer should be NULL.");
ss_info_dassert(next, "Next should not be NULL.");
ss_info_dassert(GWBUF_LENGTH(next) == PACKET_1_LEN, "Length should match.");
mxb_assert_message(buffer == NULL, "Old buffer should be NULL.");
mxb_assert_message(next, "Next should not be NULL.");
mxb_assert_message(GWBUF_LENGTH(next) == PACKET_1_LEN, "Length should match.");
gwbuf_free(next);
// Slightly less than one packet
len = PACKET_1_LEN - 1;
buffer = gwbuf_alloc_and_load(len, resultset);
next = modutil_get_next_MySQL_packet(&buffer);
ss_info_dassert(buffer, "Old buffer should not be NULL.");
ss_info_dassert(next == NULL, "Next should be NULL.");
mxb_assert_message(buffer, "Old buffer should not be NULL.");
mxb_assert_message(next == NULL, "Next should be NULL.");
GWBUF *tail = gwbuf_alloc_and_load(sizeof(resultset) - len, resultset + len);
buffer = gwbuf_append(buffer, tail);
next = modutil_get_next_MySQL_packet(&buffer);
ss_info_dassert(buffer, "Old buffer should not be NULL.");
ss_info_dassert(next, "Next should not be NULL.");
ss_info_dassert(gwbuf_length(next) == PACKET_1_LEN, "Length should match.");
mxb_assert_message(buffer, "Old buffer should not be NULL.");
mxb_assert_message(next, "Next should not be NULL.");
mxb_assert_message(gwbuf_length(next) == PACKET_1_LEN, "Length should match.");
gwbuf_free(buffer);
gwbuf_free(next);
@ -387,22 +387,22 @@ void test_multiple_sql_packets2()
len = PACKET_1_LEN + 1;
buffer = gwbuf_alloc_and_load(len, resultset);
next = modutil_get_next_MySQL_packet(&buffer);
ss_info_dassert(buffer, "Old buffer should not be NULL.");
ss_info_dassert(next, "Next should not be NULL.");
ss_info_dassert(GWBUF_LENGTH(next) == PACKET_1_LEN, "Length should match.");
mxb_assert_message(buffer, "Old buffer should not be NULL.");
mxb_assert_message(next, "Next should not be NULL.");
mxb_assert_message(GWBUF_LENGTH(next) == PACKET_1_LEN, "Length should match.");
gwbuf_free(next);
next = modutil_get_next_MySQL_packet(&buffer);
ss_info_dassert(buffer, "Old buffer should not be NULL.");
ss_info_dassert(next == NULL, "Next should be NULL.");
mxb_assert_message(buffer, "Old buffer should not be NULL.");
mxb_assert_message(next == NULL, "Next should be NULL.");
tail = gwbuf_alloc_and_load(sizeof(resultset) - len, resultset + len);
buffer = gwbuf_append(buffer, tail);
next = modutil_get_next_MySQL_packet(&buffer);
ss_info_dassert(buffer, "Old buffer should not be NULL.");
ss_info_dassert(next, "Next should not be NULL.");
ss_info_dassert(gwbuf_length(next) == PACKET_2_LEN, "Length should match.");
ss_info_dassert(memcmp(GWBUF_DATA(next), &resultset[PACKET_2_IDX], GWBUF_LENGTH(next)) == 0,
mxb_assert_message(buffer, "Old buffer should not be NULL.");
mxb_assert_message(next, "Next should not be NULL.");
mxb_assert_message(gwbuf_length(next) == PACKET_2_LEN, "Length should match.");
mxb_assert_message(memcmp(GWBUF_DATA(next), &resultset[PACKET_2_IDX], GWBUF_LENGTH(next)) == 0,
"Next packet buffer's data should be equal to original data");
gwbuf_free(buffer);
gwbuf_free(next);
@ -417,12 +417,12 @@ void test_multiple_sql_packets2()
next = modutil_get_next_MySQL_packet(&head);
int headlen = gwbuf_length(head);
int nextlen = next ? gwbuf_length(next) : 0;
ss_info_dassert(headlen + nextlen == sizeof(resultset),
mxb_assert_message(headlen + nextlen == sizeof(resultset),
"Both buffers should sum up to sizeof(resutlset) bytes");
uint8_t databuf[sizeof(resultset)];
gwbuf_copy_data(next, 0, nextlen, databuf);
gwbuf_copy_data(head, 0, headlen, databuf + nextlen);
ss_info_dassert(memcmp(databuf, resultset, sizeof(resultset)) == 0, "Data should be OK");
mxb_assert_message(memcmp(databuf, resultset, sizeof(resultset)) == 0, "Data should be OK");
gwbuf_free(head);
gwbuf_free(next);
}
@ -443,37 +443,37 @@ void test_multiple_sql_packets2()
for (unsigned int i = 0; i < N_PACKETS; i++)
{
GWBUF* next = modutil_get_next_MySQL_packet(&buffer);
ss_info_dassert(next, "Next packet buffer should not be NULL");
ss_info_dassert(gwbuf_length(next) == packets[i].length,
mxb_assert_message(next, "Next packet buffer should not be NULL");
mxb_assert_message(gwbuf_length(next) == packets[i].length,
"Next packet buffer should contain enough data");
next = gwbuf_make_contiguous(next);
ss_info_dassert(memcmp(GWBUF_DATA(next), &resultset[packets[i].index], GWBUF_LENGTH(next)) == 0,
mxb_assert_message(memcmp(GWBUF_DATA(next), &resultset[packets[i].index], GWBUF_LENGTH(next)) == 0,
"Next packet buffer's data should be equal to original data");
gwbuf_free(next);
}
ss_info_dassert(buffer == NULL, "Buffer should be NULL");
mxb_assert_message(buffer == NULL, "Buffer should be NULL");
}
void test_strnchr_esc_mysql()
{
char comment1[] = "This will -- fail.";
ss_info_dassert(strnchr_esc_mysql(comment1, '.', sizeof(comment1) - 1) == NULL,
mxb_assert_message(strnchr_esc_mysql(comment1, '.', sizeof(comment1) - 1) == NULL,
"Commented character should return NULL");
char comment2[] = "This will # fail.";
ss_info_dassert(strnchr_esc_mysql(comment2, '.', sizeof(comment2) - 1) == NULL,
mxb_assert_message(strnchr_esc_mysql(comment2, '.', sizeof(comment2) - 1) == NULL,
"Commented character should return NULL");
char comment3[] = "This will fail/* . */";
ss_info_dassert(strnchr_esc_mysql(comment3, '.', sizeof(comment3) - 1) == NULL,
mxb_assert_message(strnchr_esc_mysql(comment3, '.', sizeof(comment3) - 1) == NULL,
"Commented character should return NULL");
char comment4[] = "This will not /* . */ fail.";
ss_info_dassert(strnchr_esc_mysql(comment4, '.', sizeof(comment4) - 1) == strrchr(comment4, '.'),
mxb_assert_message(strnchr_esc_mysql(comment4, '.', sizeof(comment4) - 1) == strrchr(comment4, '.'),
"Uncommented character should be matched");
char comment5[] = "This will fail/* . ";
ss_info_dassert(strnchr_esc_mysql(comment5, '.', sizeof(comment5) - 1) == NULL, "Bad comment should fail");
mxb_assert_message(strnchr_esc_mysql(comment5, '.', sizeof(comment5) - 1) == NULL, "Bad comment should fail");
}
@ -481,56 +481,56 @@ void test_strnchr_esc()
{
/** Single escaped and quoted characters */
char esc1[] = "This will fail\\.";
ss_info_dassert(strnchr_esc(esc1, '.', sizeof(esc1) - 1) == NULL,
mxb_assert_message(strnchr_esc(esc1, '.', sizeof(esc1) - 1) == NULL,
"Only escaped character should return NULL");
ss_info_dassert(strnchr_esc_mysql(esc1, '.', sizeof(esc1) - 1) == NULL,
mxb_assert_message(strnchr_esc_mysql(esc1, '.', sizeof(esc1) - 1) == NULL,
"Only escaped character should return NULL");
char esc2[] = "This will fail\".\"";
ss_info_dassert(strnchr_esc(esc1, '.', sizeof(esc1) - 1) == NULL,
mxb_assert_message(strnchr_esc(esc1, '.', sizeof(esc1) - 1) == NULL,
"Only escaped character should return NULL");
ss_info_dassert(strnchr_esc_mysql(esc1, '.', sizeof(esc1) - 1) == NULL,
mxb_assert_message(strnchr_esc_mysql(esc1, '.', sizeof(esc1) - 1) == NULL,
"Only escaped character should return NULL");
char esc3[] = "This will fail'.'";
ss_info_dassert(strnchr_esc(esc1, '.', sizeof(esc1) - 1) == NULL,
mxb_assert_message(strnchr_esc(esc1, '.', sizeof(esc1) - 1) == NULL,
"Only escaped character should return NULL");
ss_info_dassert(strnchr_esc_mysql(esc1, '.', sizeof(esc1) - 1) == NULL,
mxb_assert_message(strnchr_esc_mysql(esc1, '.', sizeof(esc1) - 1) == NULL,
"Only escaped character should return NULL");
/** Test escaped and quoted characters */
char str1[] = "this \\. is a test.";
ss_info_dassert(strnchr_esc(str1, '.', sizeof(str1) - 1) == strrchr(str1, '.'),
mxb_assert_message(strnchr_esc(str1, '.', sizeof(str1) - 1) == strrchr(str1, '.'),
"Escaped characters should be ignored");
ss_info_dassert(strnchr_esc_mysql(str1, '.', sizeof(str1) - 1) == strrchr(str1, '.'),
mxb_assert_message(strnchr_esc_mysql(str1, '.', sizeof(str1) - 1) == strrchr(str1, '.'),
"Escaped characters should be ignored");
char str2[] = "this \"is . \" a test .";
ss_info_dassert(strnchr_esc(str2, '.', sizeof(str2) - 1) == strrchr(str2, '.'),
mxb_assert_message(strnchr_esc(str2, '.', sizeof(str2) - 1) == strrchr(str2, '.'),
"Double quoted characters should be ignored");
ss_info_dassert(strnchr_esc_mysql(str2, '.', sizeof(str2) - 1) == strrchr(str2, '.'),
mxb_assert_message(strnchr_esc_mysql(str2, '.', sizeof(str2) - 1) == strrchr(str2, '.'),
"Double quoted characters should be ignored");
char str3[] = "this 'is . ' a test .";
ss_info_dassert(strnchr_esc(str3, '.', sizeof(str3) - 1) == strrchr(str3, '.'),
mxb_assert_message(strnchr_esc(str3, '.', sizeof(str3) - 1) == strrchr(str3, '.'),
"Double quoted characters should be ignored");
ss_info_dassert(strnchr_esc_mysql(str3, '.', sizeof(str3) - 1) == strrchr(str3, '.'),
mxb_assert_message(strnchr_esc_mysql(str3, '.', sizeof(str3) - 1) == strrchr(str3, '.'),
"Double quoted characters should be ignored");
/** Bad quotation tests */
char bad1[] = "This will \" fail.";
ss_info_dassert(strnchr_esc(bad1, '.', sizeof(bad1) - 1) == NULL, "Bad quotation should fail");
ss_info_dassert(strnchr_esc_mysql(bad1, '.', sizeof(bad1) - 1) == NULL, "Bad quotation should fail");
mxb_assert_message(strnchr_esc(bad1, '.', sizeof(bad1) - 1) == NULL, "Bad quotation should fail");
mxb_assert_message(strnchr_esc_mysql(bad1, '.', sizeof(bad1) - 1) == NULL, "Bad quotation should fail");
char bad2[] = "This will ' fail.";
ss_info_dassert(strnchr_esc(bad2, '.', sizeof(bad2) - 1) == NULL, "Bad quotation should fail");
ss_info_dassert(strnchr_esc_mysql(bad2, '.', sizeof(bad2) - 1) == NULL, "Bad quotation should fail");
mxb_assert_message(strnchr_esc(bad2, '.', sizeof(bad2) - 1) == NULL, "Bad quotation should fail");
mxb_assert_message(strnchr_esc_mysql(bad2, '.', sizeof(bad2) - 1) == NULL, "Bad quotation should fail");
char bad3[] = "This will \" fail. '";
ss_info_dassert(strnchr_esc(bad3, '.', sizeof(bad3) - 1) == NULL, "Different quote pairs should fail");
ss_info_dassert(strnchr_esc_mysql(bad3, '.', sizeof(bad3) - 1) == NULL, "Different quote pairs should fail");
mxb_assert_message(strnchr_esc(bad3, '.', sizeof(bad3) - 1) == NULL, "Different quote pairs should fail");
mxb_assert_message(strnchr_esc_mysql(bad3, '.', sizeof(bad3) - 1) == NULL, "Different quote pairs should fail");
char bad4[] = "This will ' fail. \"";
ss_info_dassert(strnchr_esc(bad4, '.', sizeof(bad4) - 1) == NULL, "Different quote pairs should fail");
ss_info_dassert(strnchr_esc_mysql(bad4, '.', sizeof(bad4) - 1) == NULL, "Different quote pairs should fail");
mxb_assert_message(strnchr_esc(bad4, '.', sizeof(bad4) - 1) == NULL, "Different quote pairs should fail");
mxb_assert_message(strnchr_esc_mysql(bad4, '.', sizeof(bad4) - 1) == NULL, "Different quote pairs should fail");
}
GWBUF* create_buffer(size_t size)
@ -560,9 +560,9 @@ void test_large_packets()
size_t before = gwbuf_length(buffer);
GWBUF* complete = modutil_get_complete_packets(&buffer);
ss_info_dassert(buffer == NULL, "Original buffer should be NULL");
ss_info_dassert(complete, "Complete buffer should not be NULL");
ss_info_dassert(gwbuf_length(complete) == before, "Complete buffer should contain all data");
mxb_assert_message(buffer == NULL, "Original buffer should be NULL");
mxb_assert_message(complete, "Complete buffer should not be NULL");
mxb_assert_message(gwbuf_length(complete) == before, "Complete buffer should contain all data");
gwbuf_free(complete);
}
@ -572,8 +572,8 @@ void test_large_packets()
GWBUF* buffer = create_buffer(0x00ffffff - i);
buffer = gwbuf_rtrim(buffer, 4);
GWBUF* complete = modutil_get_complete_packets(&buffer);
ss_info_dassert(buffer, "Incomplete buffer is not NULL");
ss_info_dassert(complete == NULL, "The complete buffer is NULL");
mxb_assert_message(buffer, "Incomplete buffer is not NULL");
mxb_assert_message(complete == NULL, "The complete buffer is NULL");
gwbuf_free(buffer);
}
@ -581,12 +581,12 @@ void test_large_packets()
for (int i = 2; i < 8; i++)
{
GWBUF* buffer = gwbuf_append(create_buffer(0x00ffffff), create_buffer(i));
ss_dassert(gwbuf_length(buffer) == 0xffffffUL + i + 8);
mxb_assert(gwbuf_length(buffer) == 0xffffffUL + i + 8);
GWBUF_RTRIM(buffer->next, 1)
GWBUF* complete = modutil_get_complete_packets(&buffer);
ss_info_dassert(buffer, "Incomplete buffer is not NULL");
ss_info_dassert(complete, "The complete buffer is not NULL");
ss_info_dassert(gwbuf_length(complete) == 0xffffff + 4, "Length should be correct");
mxb_assert_message(buffer, "Incomplete buffer is not NULL");
mxb_assert_message(complete, "The complete buffer is not NULL");
mxb_assert_message(gwbuf_length(complete) == 0xffffff + 4, "Length should be correct");
gwbuf_free(buffer);
gwbuf_free(complete);
}
@ -602,31 +602,31 @@ void test_bypass_whitespace()
char* sql;
sql = bypass_whitespace("SELECT");
ss_info_dassert(*sql == 'S', "1");
mxb_assert_message(*sql == 'S', "1");
sql = bypass_whitespace(" SELECT");
ss_info_dassert(*sql == 'S', "2");
mxb_assert_message(*sql == 'S', "2");
sql = bypass_whitespace("\tSELECT");
ss_info_dassert(*sql == 'S', "3");
mxb_assert_message(*sql == 'S', "3");
sql = bypass_whitespace("\nSELECT");
ss_info_dassert(*sql == 'S', "4");
mxb_assert_message(*sql == 'S', "4");
sql = bypass_whitespace("/* comment */SELECT");
ss_info_dassert(*sql == 'S', "5");
mxb_assert_message(*sql == 'S', "5");
sql = bypass_whitespace(" /* comment */ SELECT");
ss_info_dassert(*sql == 'S', "6");
mxb_assert_message(*sql == 'S', "6");
sql = bypass_whitespace("-- comment\nSELECT");
ss_info_dassert(*sql == 'S', "7");
mxb_assert_message(*sql == 'S', "7");
sql = bypass_whitespace("-- comment\n /* comment */ SELECT");
ss_info_dassert(*sql == 'S', "8");
mxb_assert_message(*sql == 'S', "8");
sql = bypass_whitespace("# comment\nSELECT");
ss_info_dassert(*sql == 'S', "9");
mxb_assert_message(*sql == 'S', "9");
}
int main(int argc, char **argv)

18
server/core/test/test_server.cc
View File

@ -66,32 +66,32 @@ test1()
/* Server tests */
fprintf(stderr, "testserver : creating server called MyServer");
server = server_alloc("uniquename", params.params());
ss_info_dassert(server, "Allocating the server should not fail");
mxb_assert_message(server, "Allocating the server should not fail");
char buf[120];
fprintf(stderr, "\t..done\nTest Parameter for Server.");
ss_info_dassert(!server_get_parameter(server, "name", buf, sizeof(buf)), "Parameter should be null when not set");
mxb_assert_message(!server_get_parameter(server, "name", buf, sizeof(buf)), "Parameter should be null when not set");
server_add_parameter(server, "name", "value");
ss_dassert(server_get_parameter(server, "name", buf, sizeof(buf)));
ss_info_dassert(strcmp("value", buf) == 0, "Parameter should be returned correctly");
mxb_assert(server_get_parameter(server, "name", buf, sizeof(buf)));
mxb_assert_message(strcmp("value", buf) == 0, "Parameter should be returned correctly");
fprintf(stderr, "\t..done\nTesting Unique Name for Server.");
ss_info_dassert(NULL == server_find_by_unique_name("non-existent"),
mxb_assert_message(NULL == server_find_by_unique_name("non-existent"),
"Should not find non-existent unique name.");
ss_info_dassert(server == server_find_by_unique_name("uniquename"), "Should find by unique name.");
mxb_assert_message(server == server_find_by_unique_name("uniquename"), "Should find by unique name.");
fprintf(stderr, "\t..done\nTesting Status Setting for Server.");
status = server_status(server);
ss_info_dassert(0 == strcmp("Running", status), "Status of Server should be Running by default.");
mxb_assert_message(0 == strcmp("Running", status), "Status of Server should be Running by default.");
if (NULL != status)
{
MXS_FREE(status);
}
server_set_status_nolock(server, SERVER_MASTER);
status = server_status(server);
ss_info_dassert(0 == strcmp("Master, Running", status), "Should find correct status.");
mxb_assert_message(0 == strcmp("Master, Running", status), "Should find correct status.");
server_clear_status_nolock(server, SERVER_MASTER);
MXS_FREE(status);
status = server_status(server);
ss_info_dassert(0 == strcmp("Running", status),
mxb_assert_message(0 == strcmp("Running", status),
"Status of Server should be Running after master status cleared.");
if (NULL != status)
{

14
server/core/test/test_service.cc
View File

@ -66,19 +66,19 @@ test1()
fprintf(stderr,
"testservice : creating service called MyService with router nonexistent");
service = service_alloc("MyService", "non-existent", NULL);
ss_info_dassert(NULL == service, "New service with invalid router should be null");
ss_info_dassert(0 == service_isvalid(service), "Service must not be valid after incorrect creation");
mxb_assert_message(NULL == service, "New service with invalid router should be null");
mxb_assert_message(0 == service_isvalid(service), "Service must not be valid after incorrect creation");
fprintf(stderr, "\t..done\nValid service creation, router testroute.");
service = service_alloc("MyService", "readconnroute", NULL);
ss_info_dassert(NULL != service, "New service with valid router must not be null");
ss_info_dassert(0 != service_isvalid(service), "Service must be valid after creation");
ss_info_dassert(0 == strcmp("MyService", service->name), "Service must have given name");
mxb_assert_message(NULL != service, "New service with valid router must not be null");
mxb_assert_message(0 != service_isvalid(service), "Service must be valid after creation");
mxb_assert_message(0 == strcmp("MyService", service->name), "Service must have given name");
fprintf(stderr, "\t..done\nAdding protocol testprotocol.");
ss_info_dassert(serviceCreateListener(service, "TestProtocol", "mariadbclient",
mxb_assert_message(serviceCreateListener(service, "TestProtocol", "mariadbclient",
"localhost", 9876, "MySQLAuth", NULL, NULL),
"Add Protocol should succeed");
ss_info_dassert(0 != serviceHasListener(service, "TestProtocol", "mariadbclient", "localhost", 9876),
mxb_assert_message(0 != serviceHasListener(service, "TestProtocol", "mariadbclient", "localhost", 9876),
"Service should have new protocol as requested");
return 0;

22
server/core/test/test_session_track.cc
View File

@ -174,44 +174,44 @@ void test1()
//BEGIN
buffer = gwbuf_alloc_and_load(PACKET_1_LEN, resultset1 + PACKET_1_IDX);
mxs_mysql_get_session_track_info(buffer, &proto);
ss_dassert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "T_______", 8) == 0);
mxb_assert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "T_______", 8) == 0);
gwbuf_free(buffer);
//COMMIT
buffer = gwbuf_alloc_and_load(PACKET_2_LEN, resultset1 + PACKET_2_IDX);
mxs_mysql_get_session_track_info(buffer, &proto);
ss_dassert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "________", 8) == 0);
mxb_assert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "________", 8) == 0);
gwbuf_free(buffer);
//START TRANSACTION
buffer = gwbuf_alloc_and_load(PACKET_3_LEN, resultset1 + PACKET_3_IDX);
mxs_mysql_get_session_track_info(buffer, &proto);
ss_dassert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "T_______", 8) == 0);
mxb_assert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "T_______", 8) == 0);
gwbuf_free(buffer);
//START TRANSACTION READ ONLY
buffer = gwbuf_alloc_and_load(PACKET_4_LEN, resultset1 + PACKET_4_IDX);
mxs_mysql_get_session_track_info(buffer, &proto);
ss_dassert(strncmp(gwbuf_get_property(buffer, (char *)"trx_characteristics"),
mxb_assert(strncmp(gwbuf_get_property(buffer, (char *)"trx_characteristics"),
"START TRANSACTION READ ONLY;", 28) == 0);
gwbuf_free(buffer);
//COMMIT
buffer = gwbuf_alloc_and_load(PACKET_5_LEN, resultset1 + PACKET_5_IDX);
mxs_mysql_get_session_track_info(buffer, &proto);
ss_dassert(gwbuf_get_property(buffer, (char *)"trx_characteristics") == NULL);
ss_dassert(gwbuf_get_property(buffer, (char *)"trx_state") == NULL);
mxb_assert(gwbuf_get_property(buffer, (char *)"trx_characteristics") == NULL);
mxb_assert(gwbuf_get_property(buffer, (char *)"trx_state") == NULL);
gwbuf_free(buffer);
//SET AUTOCOMMIT=0;
buffer = gwbuf_alloc_and_load(PACKET_6_LEN, resultset1 + PACKET_6_IDX);
mxs_mysql_get_session_track_info(buffer, &proto);
ss_dassert(strncmp(gwbuf_get_property(buffer, (char *)"autocommit"), "OFF", 3) == 0);
mxb_assert(strncmp(gwbuf_get_property(buffer, (char *)"autocommit"), "OFF", 3) == 0);
gwbuf_free(buffer);
//INSERT INTO t1 VALUES(1);
buffer = gwbuf_alloc_and_load(PACKET_7_LEN, resultset1 + PACKET_7_IDX);
mxs_mysql_get_session_track_info(buffer, &proto);
ss_dassert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "I___W___", 8) == 0);
mxb_assert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "I___W___", 8) == 0);
gwbuf_free(buffer);
//COMMIT
buffer = gwbuf_alloc_and_load(PACKET_8_LEN, resultset1 + PACKET_8_IDX);
mxs_mysql_get_session_track_info(buffer, &proto);
ss_dassert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "________", 8) == 0);
mxb_assert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "________", 8) == 0);
gwbuf_free(buffer);
}
@ -224,7 +224,7 @@ void test2()
proto.num_eof_packets = 0;
buffer = gwbuf_alloc_and_load(sizeof(resultset2), resultset2);
mxs_mysql_get_session_track_info(buffer, &proto);
ss_dassert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "I_R_W___", 8) == 0);
mxb_assert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "I_R_W___", 8) == 0);
gwbuf_free(buffer);
}
@ -236,7 +236,7 @@ void test3()
fprintf(stderr, "test_session_track: protocol state test\n");
buffer = gwbuf_alloc_and_load(sizeof(resultset2), resultset2);
mxs_mysql_get_session_track_info(buffer, &proto);
ss_dassert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "I_R_W___", 8) == 0);
mxb_assert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "I_R_W___", 8) == 0);
gwbuf_free(buffer);
}

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

@ -204,7 +204,7 @@ int main(int argc, char* argv[])
}
else
{
ss_dassert(n == 2);
mxb_assert(n == 2);
ifstream in(argv[argc - 1]);

18
server/core/test/test_users.cc
View File

@ -45,31 +45,31 @@ static int test1()
fprintf(stderr,
"testusers : Initialise the user table.");
users = users_alloc();
ss_info_dassert(NULL != users, "Allocating user table should not return NULL.");
mxb_assert_message(NULL != users, "Allocating user table should not return NULL.");
fprintf(stderr, "\t..done\nAdd a user");
rv = users_add(users, "username", "authorisation", USER_ACCOUNT_ADMIN);
ss_info_dassert(rv, "Should add one user");
mxb_assert_message(rv, "Should add one user");
rv = users_auth(users, "username", "authorisation");
ss_info_dassert(rv, "Fetch valid user must not return NULL");
mxb_assert_message(rv, "Fetch valid user must not return NULL");
rv = users_auth(users, "username", "newauth");
ss_info_dassert(rv == 0, "Fetch invalid user must return NULL");
mxb_assert_message(rv == 0, "Fetch invalid user must return NULL");
fprintf(stderr, "\t..done\nAdd another user");
rv = users_add(users, "username2", "authorisation2", USER_ACCOUNT_ADMIN);
ss_info_dassert(rv, "Should add one user");
mxb_assert_message(rv, "Should add one user");
fprintf(stderr, "\t..done\nDelete a user.");
rv = users_delete(users, "username");
ss_info_dassert(rv, "Should delete just one user");
mxb_assert_message(rv, "Should delete just one user");
fprintf(stderr, "\t..done\nDump users table.");
json_t* dump = users_to_json(users);
ss_info_dassert(dump, "Users should be dumped");
mxb_assert_message(dump, "Users should be dumped");
USERS* loaded_users = users_from_json(dump);
ss_info_dassert(dump, "Users should be loaded");
mxb_assert_message(dump, "Users should be loaded");
json_decref(dump);
rv = users_auth(loaded_users, "username2", "authorisation2");
users_free(loaded_users);
ss_info_dassert(rv, "Loaded users should contain users");
mxb_assert_message(rv, "Loaded users should contain users");
fprintf(stderr, "\t..done\nFree user table.");
users_free(users);

18
server/core/test/test_utils.cc
View File

@ -134,34 +134,34 @@ int test_checksums()
sum1.update(d1);
sum1.finalize();
sum2.finalize(d1);
ss_dassert(sum1 == sum2);
mxb_assert(sum1 == sum2);
sum1.reset();
sum2.reset();
// Check that the hex strings match
ss_dassert(sum1.hex() == sum2.hex());
mxb_assert(sum1.hex() == sum2.hex());
std::string saved = sum1.hex();
// The checksum must not be empty
ss_dassert(!saved.empty());
mxb_assert(!saved.empty());
// Repeat the same test, should produce the same checksums
sum1.update(d1);
sum1.finalize();
sum2.finalize(d1);
ss_dassert(sum1 == sum2);
ss_dassert(sum1.hex() == saved);
ss_dassert(sum2.hex() == saved);
mxb_assert(sum1 == sum2);
mxb_assert(sum1.hex() == saved);
mxb_assert(sum2.hex() == saved);
sum1.reset();
sum2.reset();
// Check that different buffers but same content produce the same checksum
sum1.finalize(d2);
sum2.finalize(d1);
ss_dassert(sum1 == sum2);
ss_dassert(sum1.hex() == saved);
ss_dassert(sum2.hex() == saved);
mxb_assert(sum1 == sum2);
mxb_assert(sum1.hex() == saved);
mxb_assert(sum2.hex() == saved);
gwbuf_free(d1);
gwbuf_free(d2);

18
server/core/utils.cc
View File

@ -779,7 +779,7 @@ char* replace_literal(char* haystack, const char* needle, const char* replacemen
}
rc = regcomp(&re, search_re, REG_EXTENDED | REG_ICASE);
ss_info_dassert(rc == 0, "Regex check");
mxb_assert_message(rc == 0, "Regex check");
if (rc != 0)
{
@ -901,7 +901,7 @@ bool utils_init()
PCRE2_SIZE erroffset;
int errcode;
ss_info_dassert(remove_comments_re == NULL, "utils_init called multiple times");
mxb_assert_message(remove_comments_re == NULL, "utils_init called multiple times");
remove_comments_re = pcre2_compile(remove_comments_pattern, PCRE2_ZERO_TERMINATED, 0, &errcode,
&erroffset, NULL);
if (remove_comments_re == NULL)
@ -909,7 +909,7 @@ bool utils_init()
rval = false;
}
ss_info_dassert(replace_quoted_re == NULL, "utils_init called multiple times");
mxb_assert_message(replace_quoted_re == NULL, "utils_init called multiple times");
replace_quoted_re = pcre2_compile(replace_quoted_pattern, PCRE2_ZERO_TERMINATED, 0, &errcode,
&erroffset, NULL);
if (replace_quoted_re == NULL)
@ -917,7 +917,7 @@ bool utils_init()
rval = false;
}
ss_info_dassert(replace_values_re == NULL, "utils_init called multiple times");
mxb_assert_message(replace_values_re == NULL, "utils_init called multiple times");
replace_values_re = pcre2_compile(replace_values_pattern, PCRE2_ZERO_TERMINATED, 0, &errcode,
&erroffset, NULL);
if (replace_values_re == NULL)
@ -989,14 +989,14 @@ static void set_port(struct sockaddr_storage *addr, uint16_t port)
else
{
MXS_ERROR("Unknown address family: %d", (int)addr->ss_family);
ss_dassert(false);
mxb_assert(false);
}
}
int open_network_socket(enum mxs_socket_type type, struct sockaddr_storage *addr, const char *host,
uint16_t port)
{
ss_dassert(type == MXS_SOCKET_NETWORK || type == MXS_SOCKET_LISTENER);
mxb_assert(type == MXS_SOCKET_NETWORK || type == MXS_SOCKET_LISTENER);
struct addrinfo *ai = NULL, hint = {};
int so = 0, rc = 0;
hint.ai_socktype = SOCK_STREAM;
@ -1152,7 +1152,7 @@ std::string to_hex(uint8_t value)
uint64_t get_byteN(const uint8_t* ptr, int bytes)
{
uint64_t rval = 0;
ss_dassert(bytes >= 0 && bytes <= (int)sizeof(rval));
mxb_assert(bytes >= 0 && bytes <= (int)sizeof(rval));
for (int i = 0; i < bytes; i++)
{
rval += (uint64_t)ptr[i] << (i * 8);
@ -1162,7 +1162,7 @@ uint64_t get_byteN(const uint8_t* ptr, int bytes)
uint8_t* set_byteN(uint8_t* ptr, uint64_t value, int bytes)
{
ss_dassert(bytes >= 0 && bytes <= (int)sizeof(value));
mxb_assert(bytes >= 0 && bytes <= (int)sizeof(value));
for (int i = 0; i < bytes; i++)
{
ptr[i] = (uint8_t)(value >> (i * 8));
@ -1181,7 +1181,7 @@ std::string string_printf(const char* format, ...)
if (characters < 0)
{
// Encoding (programmer) error.
ss_dassert(!true);
mxb_assert(!true);
MXS_ERROR("Could not format the string %s.", format);
}
else if (characters > 0)

6
server/modules/authenticator/GSSAPI/GSSAPIAuth/gssapi_auth.cc
View File

@ -298,7 +298,7 @@ static bool gssapi_auth_extract(DCB *dcb, GWBUF *read_buffer)
default:
MXS_ERROR("Unexpected authentication state: %d", auth->state);
ss_dassert(false);
mxb_assert(false);
break;
}
@ -419,7 +419,7 @@ static int auth_cb(void *data, int columns, char** rows, char** row_names)
*/
static bool validate_user(gssapi_auth_t *auth, DCB *dcb, MYSQL_session *session, const char *princ)
{
ss_dassert(princ);
mxb_assert(princ);
size_t len = sizeof(gssapi_auth_query) + strlen(session->user) * 2 +
strlen(session->db) * 2 + strlen(dcb->remote) + strlen(princ) * 2;
char sql[len + 1];
@ -635,7 +635,7 @@ int gssapi_auth_load_users(SERV_LISTENER *listener)
if (res)
{
ss_dassert(mysql_num_fields(res) == GSSAPI_USERS_QUERY_NUM_FIELDS);
mxb_assert(mysql_num_fields(res) == GSSAPI_USERS_QUERY_NUM_FIELDS);
MYSQL_ROW row;
while ((row = mysql_fetch_row(res)))

4
server/modules/authenticator/MySQLAuth/mysql_auth.cc
View File

@ -144,12 +144,12 @@ static bool open_instance_database(const char *path, sqlite3 **handle)
sqlite3* get_handle(MYSQL_AUTH* instance)
{
int i = mxs_rworker_get_current_id();
ss_dassert(i >= 0);
mxb_assert(i >= 0);
if (instance->handles[i] == NULL)
{
MXB_AT_DEBUG(bool rval = )open_instance_database(":memory:", &instance->handles[i]);
ss_dassert(rval);
mxb_assert(rval);
}
return instance->handles[i];

2
server/modules/authenticator/MySQLBackendAuth/mysql_backend_auth.cc
View File

@ -100,7 +100,7 @@ static bool auth_backend_extract(DCB *dcb, GWBUF *buf)
default:
MXS_ERROR("Unexpected call to MySQLBackendAuth::extract");
ss_dassert(false);
mxb_assert(false);
break;
}

4
server/modules/authenticator/PAM/PAMAuth/pam_client_session.cc
View File

@ -61,7 +61,7 @@ bool store_client_password(DCB *dcb, GWBUF *buffer)
*/
int user_services_cb(void *data, int columns, char** column_vals, char** column_names)
{
ss_dassert(columns == 1);
mxb_assert(columns == 1);
PamClientSession::StringVector* results = static_cast<PamClientSession::StringVector*>(data);
if (column_vals[0])
{
@ -413,7 +413,7 @@ bool PamClientSession::extract(DCB *dcb, GWBUF *buffer)
default:
MXS_ERROR("Unexpected authentication state: %d", m_state);
ss_dassert(!true);
mxb_assert(!true);
break;
}
return rval;

6
server/modules/authenticator/PAM/PAMAuth/pam_instance.cc
View File

@ -209,7 +209,7 @@ int PamInstance::load_users(SERVICE* service)
delete_old_users();
if (res)
{
ss_dassert(mysql_num_fields(res) == PAM_USERS_QUERY_NUM_FIELDS);
mxb_assert(mysql_num_fields(res) == PAM_USERS_QUERY_NUM_FIELDS);
MXS_NOTICE("Loaded %llu users for service %s.", mysql_num_rows(res),
service->name);
MYSQL_ROW row;
@ -242,7 +242,7 @@ int PamInstance::load_users(SERVICE* service)
void PamInstance::diagnostic(DCB* dcb)
{
json_t* array = diagnostic_json();
ss_dassert(json_is_array(array));
mxb_assert(json_is_array(array));
string result, separator;
size_t index;
@ -269,7 +269,7 @@ void PamInstance::diagnostic(DCB* dcb)
static int diag_cb_json(void *data, int columns, char **row, char **field_names)
{
ss_dassert(columns == NUM_FIELDS);
mxb_assert(columns == NUM_FIELDS);
json_t* obj = json_object();
for (int i = 0; i < columns; i++)
{

4
server/modules/filter/binlogfilter/binlogfiltersession.cc
View File

@ -306,7 +306,7 @@ static void extract_header(register const uint8_t *event,
bool BinlogFilterSession::checkEvent(GWBUF* buffer,
const REP_HEADER& hdr)
{
ss_dassert(!m_is_large);
mxb_assert(!m_is_large);
uint8_t *event = GWBUF_DATA(buffer);
@ -512,7 +512,7 @@ void BinlogFilterSession::replaceEvent(GWBUF** ppPacket)
uint32_t orig_event_type = 0;
// If size < BINLOG_EVENT_HDR_LEN + crc32 add rand_event to buff contiguos
ss_dassert(m_skip == true);
mxb_assert(m_skip == true);
/**
* RAND_EVENT is:

2
server/modules/filter/cache/cache.cc vendored
View File

@ -135,7 +135,7 @@ cache_result_t Cache::get_default_key(const char* zDefault_db,
const GWBUF* pQuery,
CACHE_KEY* pKey)
{
ss_dassert(GWBUF_IS_CONTIGUOUS(pQuery));
mxb_assert(GWBUF_IS_CONTIGUOUS(pQuery));
char *pSql;
int length;

8
server/modules/filter/cache/cache_storage_api.c vendored
View File

@ -16,16 +16,16 @@
size_t cache_key_hash(const CACHE_KEY* key)
{
ss_dassert(key);
ss_dassert(sizeof(key->data) == sizeof(size_t));
mxb_assert(key);
mxb_assert(sizeof(key->data) == sizeof(size_t));
return key->data;
}
bool cache_key_equal_to(const CACHE_KEY* lhs, const CACHE_KEY* rhs)
{
ss_dassert(lhs);
ss_dassert(rhs);
mxb_assert(lhs);
mxb_assert(rhs);
return lhs->data == rhs->data;
}

10
server/modules/filter/cache/cachefilter.cc vendored
View File

@ -93,11 +93,11 @@ void cache_config_reset(CACHE_CONFIG& config)
*/
bool cache_command_show(const MODULECMD_ARG* pArgs, json_t** output)
{
ss_dassert(pArgs->argc == 1);
ss_dassert(MODULECMD_GET_TYPE(&pArgs->argv[1].type) == MODULECMD_ARG_FILTER);
mxb_assert(pArgs->argc == 1);
mxb_assert(MODULECMD_GET_TYPE(&pArgs->argv[1].type) == MODULECMD_ARG_FILTER);
const MXS_FILTER_DEF* pFilterDef = pArgs->argv[1].value.filter;
ss_dassert(pFilterDef);
mxb_assert(pFilterDef);
CacheFilter* pFilter = reinterpret_cast<CacheFilter*>(filter_def_get_instance(pFilterDef));
MXS_EXCEPTION_GUARD(*output = pFilter->cache().show_json());
@ -296,7 +296,7 @@ CacheFilter* CacheFilter::create(const char* zName, MXS_CONFIG_PARAMETER* ppPara
break;
default:
ss_dassert(!true);
mxb_assert(!true);
}
}
@ -444,7 +444,7 @@ bool CacheFilter::process_params(MXS_CONFIG_PARAMETER *ppParams, CACHE_CONFIG& c
}
else
{
ss_dassert(config.max_resultset_size != 0);
mxb_assert(config.max_resultset_size != 0);
if ((config.max_size != 0) && (config.max_resultset_size > config.max_size))
{

4
server/modules/filter/cache/cachefilter.hh vendored
View File

@ -26,12 +26,12 @@ public:
Cache& cache()
{
ss_dassert(m_sCache.get());
mxb_assert(m_sCache.get());
return *m_sCache.get();
}
const Cache& cache() const
{
ss_dassert(m_sCache.get());
mxb_assert(m_sCache.get());
return *m_sCache.get();
}

84
server/modules/filter/cache/cachefiltersession.cc vendored
View File

@ -152,7 +152,7 @@ bool is_select_statement(GWBUF* pStmt)
int len;
MXB_AT_DEBUG(int rc = ) modutil_extract_SQL(pStmt, &pSql, &len);
ss_dassert(rc == 1);
mxb_assert(rc == 1);
char* pSql_end = pSql + len;
@ -202,7 +202,7 @@ CacheFilterSession::CacheFilterSession(MXS_SESSION* pSession, Cache* pCache, cha
if (!session_add_variable(pSession, SV_MAXSCALE_CACHE_POPULATE,
&CacheFilterSession::set_cache_populate, this))
{
ss_dassert(!true);
mxb_assert(!true);
MXS_ERROR("Could not add MaxScale user variable '%s', dynamically "
"enabling/disabling the populating of the cache is not possible.",
SV_MAXSCALE_CACHE_POPULATE);
@ -211,7 +211,7 @@ CacheFilterSession::CacheFilterSession(MXS_SESSION* pSession, Cache* pCache, cha
if (!session_add_variable(pSession, SV_MAXSCALE_CACHE_USE,
&CacheFilterSession::set_cache_use, this))
{
ss_dassert(!true);
mxb_assert(!true);
MXS_ERROR("Could not add MaxScale user variable '%s', dynamically "
"enabling/disabling the using of the cache not possible.",
SV_MAXSCALE_CACHE_USE);
@ -220,7 +220,7 @@ CacheFilterSession::CacheFilterSession(MXS_SESSION* pSession, Cache* pCache, cha
if (!session_add_variable(pSession, SV_MAXSCALE_CACHE_SOFT_TTL,
&CacheFilterSession::set_cache_soft_ttl, this))
{
ss_dassert(!true);
mxb_assert(!true);
MXS_ERROR("Could not add MaxScale user variable '%s', dynamically "
"setting the soft TTL not possible.",
SV_MAXSCALE_CACHE_SOFT_TTL);
@ -229,7 +229,7 @@ CacheFilterSession::CacheFilterSession(MXS_SESSION* pSession, Cache* pCache, cha
if (!session_add_variable(pSession, SV_MAXSCALE_CACHE_HARD_TTL,
&CacheFilterSession::set_cache_hard_ttl, this))
{
ss_dassert(!true);
mxb_assert(!true);
MXS_ERROR("Could not add MaxScale user variable '%s', dynamically "
"setting the hard TTL not possible.",
SV_MAXSCALE_CACHE_HARD_TTL);
@ -247,8 +247,8 @@ CacheFilterSession* CacheFilterSession::Create(Cache* pCache, MXS_SESSION* pSess
{
CacheFilterSession* pCacheFilterSession = NULL;
ss_dassert(pSession->client_dcb);
ss_dassert(pSession->client_dcb->data);
mxb_assert(pSession->client_dcb);
mxb_assert(pSession->client_dcb->data);
const char* zDb = mxs_mysql_get_current_db(pSession);
char* zDefaultDb = NULL;
@ -280,9 +280,9 @@ int CacheFilterSession::routeQuery(GWBUF* pPacket)
uint8_t* pData = static_cast<uint8_t*>(GWBUF_DATA(pPacket));
// All of these should be guaranteed by RCAP_TYPE_TRANSACTION_TRACKING
ss_dassert(GWBUF_IS_CONTIGUOUS(pPacket));
ss_dassert(GWBUF_LENGTH(pPacket) >= MYSQL_HEADER_LEN + 1);
ss_dassert(MYSQL_GET_PAYLOAD_LEN(pData) + MYSQL_HEADER_LEN == GWBUF_LENGTH(pPacket));
mxb_assert(GWBUF_IS_CONTIGUOUS(pPacket));
mxb_assert(GWBUF_LENGTH(pPacket) >= MYSQL_HEADER_LEN + 1);
mxb_assert(MYSQL_GET_PAYLOAD_LEN(pData) + MYSQL_HEADER_LEN == GWBUF_LENGTH(pPacket));
routing_action_t action = ROUTING_CONTINUE;
@ -295,7 +295,7 @@ int CacheFilterSession::routeQuery(GWBUF* pPacket)
{
case MXS_COM_INIT_DB:
{
ss_dassert(!m_zUseDb);
mxb_assert(!m_zUseDb);
size_t len = MYSQL_GET_PAYLOAD_LEN(pData) - 1; // Remove the command byte.
m_zUseDb = (char*)MXS_MALLOC(len + 1);
@ -410,7 +410,7 @@ int CacheFilterSession::clientReply(GWBUF* pData)
default:
MXS_ERROR("Internal cache logic broken, unexpected state: %d", m_state);
ss_dassert(!true);
mxb_assert(!true);
rv = send_upstream();
reset_response_state();
m_state = CACHE_IGNORING_RESPONSE;
@ -442,15 +442,15 @@ json_t* CacheFilterSession::diagnostics_json() const
*/
int CacheFilterSession::handle_expecting_fields()
{
ss_dassert(m_state == CACHE_EXPECTING_FIELDS);
ss_dassert(m_res.pData);
mxb_assert(m_state == CACHE_EXPECTING_FIELDS);
mxb_assert(m_res.pData);
int rv = 1;
bool insufficient = false;
size_t buflen = m_res.length;
ss_dassert(m_res.length == gwbuf_length(m_res.pData));
mxb_assert(m_res.length == gwbuf_length(m_res.pData));
while (!insufficient && (buflen - m_res.offset >= MYSQL_HEADER_LEN))
{
@ -475,7 +475,7 @@ int CacheFilterSession::handle_expecting_fields()
default: // Field information.
m_res.offset += packetlen;
++m_res.nFields;
ss_dassert(m_res.nFields <= m_res.nTotalFields);
mxb_assert(m_res.nFields <= m_res.nTotalFields);
break;
}
}
@ -494,8 +494,8 @@ int CacheFilterSession::handle_expecting_fields()
*/
int CacheFilterSession::handle_expecting_nothing()
{
ss_dassert(m_state == CACHE_EXPECTING_NOTHING);
ss_dassert(m_res.pData);
mxb_assert(m_state == CACHE_EXPECTING_NOTHING);
mxb_assert(m_res.pData);
unsigned long msg_size = gwbuf_length(m_res.pData);
if ((int)MYSQL_GET_COMMAND(GWBUF_DATA(m_res.pData)) == 0xff)
@ -516,7 +516,7 @@ int CacheFilterSession::handle_expecting_nothing()
"filter is expecting nothing. "
"Packet size is %lu bytes long.",
msg_size);
ss_dassert(!true);
mxb_assert(!true);
}
return send_upstream();
@ -527,13 +527,13 @@ int CacheFilterSession::handle_expecting_nothing()
*/
int CacheFilterSession::handle_expecting_response()
{
ss_dassert(m_state == CACHE_EXPECTING_RESPONSE);
ss_dassert(m_res.pData);
mxb_assert(m_state == CACHE_EXPECTING_RESPONSE);
mxb_assert(m_res.pData);
int rv = 1;
size_t buflen = m_res.length;
ss_dassert(m_res.length == gwbuf_length(m_res.pData));
mxb_assert(m_res.length == gwbuf_length(m_res.pData));
if (buflen >= MYSQL_HEADER_LEN + 1) // We need the command byte.
{
@ -598,15 +598,15 @@ int CacheFilterSession::handle_expecting_response()
*/
int CacheFilterSession::handle_expecting_rows()
{
ss_dassert(m_state == CACHE_EXPECTING_ROWS);
ss_dassert(m_res.pData);
mxb_assert(m_state == CACHE_EXPECTING_ROWS);
mxb_assert(m_res.pData);
int rv = 1;
bool insufficient = false;
size_t buflen = m_res.length;
ss_dassert(m_res.length == gwbuf_length(m_res.pData));
mxb_assert(m_res.length == gwbuf_length(m_res.pData));
while (!insufficient && (buflen - m_res.offset >= MYSQL_HEADER_LEN))
{
@ -621,7 +621,7 @@ int CacheFilterSession::handle_expecting_rows()
{
// The last EOF packet
m_res.offset += packetlen;
ss_dassert(m_res.offset == buflen);
mxb_assert(m_res.offset == buflen);
store_result();
@ -661,13 +661,13 @@ int CacheFilterSession::handle_expecting_rows()
*/
int CacheFilterSession::handle_expecting_use_response()
{
ss_dassert(m_state == CACHE_EXPECTING_USE_RESPONSE);
ss_dassert(m_res.pData);
mxb_assert(m_state == CACHE_EXPECTING_USE_RESPONSE);
mxb_assert(m_res.pData);
int rv = 1;
size_t buflen = m_res.length;
ss_dassert(m_res.length == gwbuf_length(m_res.pData));
mxb_assert(m_res.length == gwbuf_length(m_res.pData));
if (buflen >= MYSQL_HEADER_LEN + 1) // We need the command byte.
{
@ -711,8 +711,8 @@ int CacheFilterSession::handle_expecting_use_response()
*/
int CacheFilterSession::handle_ignoring_response()
{
ss_dassert(m_state == CACHE_IGNORING_RESPONSE);
ss_dassert(m_res.pData);
mxb_assert(m_state == CACHE_IGNORING_RESPONSE);
mxb_assert(m_res.pData);
return send_upstream();
}
@ -724,7 +724,7 @@ int CacheFilterSession::handle_ignoring_response()
*/
int CacheFilterSession::send_upstream()
{
ss_dassert(m_res.pData != NULL);
mxb_assert(m_res.pData != NULL);
int rv = m_up.clientReply(m_res.pData);
m_res.pData = NULL;
@ -754,7 +754,7 @@ void CacheFilterSession::reset_response_state()
*/
void CacheFilterSession::store_result()
{
ss_dassert(m_res.pData);
mxb_assert(m_res.pData);
GWBUF *pData = gwbuf_make_contiguous(m_res.pData);
@ -833,7 +833,7 @@ CacheFilterSession::cache_action_t CacheFilterSession::get_cache_action(GWBUF* p
}
else
{
ss_dassert(config.cache_in_trxs == CACHE_IN_TRXS_NEVER);
mxb_assert(config.cache_in_trxs == CACHE_IN_TRXS_NEVER);
if (log_decisions())
{
@ -857,7 +857,7 @@ CacheFilterSession::cache_action_t CacheFilterSession::get_cache_action(GWBUF* p
}
else
{
ss_dassert((config.cache_in_trxs == CACHE_IN_TRXS_NEVER) ||
mxb_assert((config.cache_in_trxs == CACHE_IN_TRXS_NEVER) ||
(config.cache_in_trxs == CACHE_IN_TRXS_READ_ONLY));
if (log_decisions())
@ -975,7 +975,7 @@ CacheFilterSession::cache_action_t CacheFilterSession::get_cache_action(GWBUF* p
const char* zDecision = (action == CACHE_IGNORE) ? "IGNORE" : "CONSULT";
ss_dassert(zPrimary_reason);
mxb_assert(zPrimary_reason);
MXS_NOTICE(zFormat, zDecision, length, pSql, zPrimary_reason, zSecondary_reason);
}
}
@ -1002,7 +1002,7 @@ CacheFilterSession::cache_action_t CacheFilterSession::get_cache_action(GWBUF* p
CacheFilterSession::routing_action_t CacheFilterSession::route_COM_QUERY(GWBUF* pPacket)
{
MXB_AT_DEBUG(uint8_t* pData = static_cast<uint8_t*>(GWBUF_DATA(pPacket)));
ss_dassert((int)MYSQL_GET_COMMAND(pData) == MXS_COM_QUERY);
mxb_assert((int)MYSQL_GET_COMMAND(pData) == MXS_COM_QUERY);
routing_action_t routing_action = ROUTING_CONTINUE;
cache_action_t cache_action = get_cache_action(pPacket);
@ -1270,7 +1270,7 @@ char* CacheFilterSession::set_cache_populate(const char* zName,
const char* pValue_begin,
const char* pValue_end)
{
ss_dassert(strcmp(SV_MAXSCALE_CACHE_POPULATE, zName) == 0);
mxb_assert(strcmp(SV_MAXSCALE_CACHE_POPULATE, zName) == 0);
char* zMessage = NULL;
@ -1292,7 +1292,7 @@ char* CacheFilterSession::set_cache_use(const char* zName,
const char* pValue_begin,
const char* pValue_end)
{
ss_dassert(strcmp(SV_MAXSCALE_CACHE_USE, zName) == 0);
mxb_assert(strcmp(SV_MAXSCALE_CACHE_USE, zName) == 0);
char* zMessage = NULL;
@ -1314,7 +1314,7 @@ char* CacheFilterSession::set_cache_soft_ttl(const char* zName,
const char* pValue_begin,
const char* pValue_end)
{
ss_dassert(strcmp(SV_MAXSCALE_CACHE_SOFT_TTL, zName) == 0);
mxb_assert(strcmp(SV_MAXSCALE_CACHE_SOFT_TTL, zName) == 0);
char* zMessage = NULL;
@ -1336,7 +1336,7 @@ char* CacheFilterSession::set_cache_hard_ttl(const char* zName,
const char* pValue_begin,
const char* pValue_end)
{
ss_dassert(strcmp(SV_MAXSCALE_CACHE_HARD_TTL, zName) == 0);
mxb_assert(strcmp(SV_MAXSCALE_CACHE_HARD_TTL, zName) == 0);
char* zMessage = NULL;
@ -1408,7 +1408,7 @@ void CacheFilterSession::copy_data(size_t offset, size_t nBytes, uint8_t* pTo) c
else
{
// We do not expect this to happen.
ss_dassert(!true);
mxb_assert(!true);
gwbuf_copy_data(m_res.pData, offset, nBytes, pTo);
}
}

2
server/modules/filter/cache/cachemt.cc vendored
View File

@ -37,7 +37,7 @@ CacheMT::~CacheMT()
CacheMT* CacheMT::Create(const std::string& name, const CACHE_CONFIG* pConfig)
{
ss_dassert(pConfig);
mxb_assert(pConfig);
CacheMT* pCache = NULL;

4
server/modules/filter/cache/cachept.cc vendored
View File

@ -65,7 +65,7 @@ CachePT::~CachePT()
// static
CachePT* CachePT::Create(const std::string& name, const CACHE_CONFIG* pConfig)
{
ss_dassert(pConfig);
mxb_assert(pConfig);
CachePT* pCache = NULL;
@ -202,6 +202,6 @@ CachePT* CachePT::Create(const std::string& name,
Cache& CachePT::thread_cache()
{
int i = thread_index();
ss_dassert(i < (int)m_caches.size());
mxb_assert(i < (int)m_caches.size());
return *m_caches[i].get();
}

4
server/modules/filter/cache/cachesimple.cc vendored
View File

@ -124,7 +124,7 @@ bool CacheSimple::do_must_refresh(const CACHE_KEY& key, const CacheFilterSession
void CacheSimple::do_refreshed(const CACHE_KEY& key, const CacheFilterSession* pSession)
{
Pending::iterator i = m_pending.find(key);
ss_dassert(i != m_pending.end());
ss_dassert(i->second == pSession);
mxb_assert(i != m_pending.end());
mxb_assert(i->second == pSession);
m_pending.erase(i);
}

6
server/modules/filter/cache/cachest.cc vendored
View File

@ -34,7 +34,7 @@ CacheST::~CacheST()
CacheST* CacheST::Create(const std::string& name, const CACHE_CONFIG* pConfig)
{
ss_dassert(pConfig);
mxb_assert(pConfig);
CacheST* pCache = NULL;
@ -57,8 +57,8 @@ CacheST* CacheST::Create(const std::string& name,
SStorageFactory sFactory,
const CACHE_CONFIG* pConfig)
{
ss_dassert(sFactory.get());
ss_dassert(pConfig);
mxb_assert(sFactory.get());
mxb_assert(pConfig);
return Create(name, pConfig, rules, sFactory);
}

66
server/modules/filter/cache/lrustorage.cc vendored
View File

@ -103,7 +103,7 @@ cache_result_t LRUStorage::do_put_value(const CACHE_KEY& key, const GWBUF* pvalu
if (CACHE_RESULT_IS_OK(result))
{
ss_dassert(pNode);
mxb_assert(pNode);
result = m_pStorage->put_value(key, pvalue);
@ -112,7 +112,7 @@ cache_result_t LRUStorage::do_put_value(const CACHE_KEY& key, const GWBUF* pvalu
if (existed)
{
++m_stats.updates;
ss_dassert(m_stats.size >= pNode->size());
mxb_assert(m_stats.size >= pNode->size());
m_stats.size -= pNode->size();
}
else
@ -151,8 +151,8 @@ cache_result_t LRUStorage::do_del_value(const CACHE_KEY& key)
// If it wasn't found, we'll assume it was because ttl has hit in.
++m_stats.deletes;
ss_dassert(m_stats.size >= i->second->size());
ss_dassert(m_stats.items > 0);
mxb_assert(m_stats.size >= i->second->size());
mxb_assert(m_stats.items > 0);
m_stats.size -= i->second->size();
--m_stats.items;
@ -172,7 +172,7 @@ cache_result_t LRUStorage::do_get_head(CACHE_KEY* pKey, GWBUF** ppValue) const
// cater for the case that ttl has hit in.
while (m_pHead && (CACHE_RESULT_IS_NOT_FOUND(result)))
{
ss_dassert(m_pHead->key());
mxb_assert(m_pHead->key());
result = do_get_value(*m_pHead->key(),
CACHE_FLAGS_INCLUDE_STALE, CACHE_USE_CONFIG_TTL, CACHE_USE_CONFIG_TTL,
ppValue);
@ -193,7 +193,7 @@ cache_result_t LRUStorage::do_get_tail(CACHE_KEY* pKey, GWBUF** ppValue) const
// We need to loop to cater for the case that ttl has hit in.
while (m_pTail && CACHE_RESULT_IS_NOT_FOUND(result))
{
ss_dassert(m_pTail->key());
mxb_assert(m_pTail->key());
result = peek_value(*m_pTail->key(), CACHE_FLAGS_INCLUDE_STALE, ppValue);
}
@ -269,7 +269,7 @@ cache_result_t LRUStorage::access_value(access_approach_t approach,
*/
LRUStorage::Node* LRUStorage::vacate_lru()
{
ss_dassert(m_pTail);
mxb_assert(m_pTail);
Node* pNode = NULL;
@ -339,13 +339,13 @@ bool LRUStorage::free_node_data(Node* pNode)
bool success = true;
const CACHE_KEY* pkey = pNode->key();
ss_dassert(pkey);
mxb_assert(pkey);
NodesByKey::iterator i = m_nodes_by_key.find(*pkey);
if (i == m_nodes_by_key.end())
{
ss_dassert(!true);
mxb_assert(!true);
MXS_ERROR("Item in LRU list was not found in key mapping.");
}
@ -355,7 +355,7 @@ bool LRUStorage::free_node_data(Node* pNode)
{
if (CACHE_RESULT_IS_NOT_FOUND(result))
{
ss_dassert(!true);
mxb_assert(!true);
MXS_ERROR("Item in LRU list was not found in storage.");
}
@ -364,8 +364,8 @@ bool LRUStorage::free_node_data(Node* pNode)
m_nodes_by_key.erase(i);
}
ss_dassert(m_stats.size >= pNode->size());
ss_dassert(m_stats.items > 0);
mxb_assert(m_stats.size >= pNode->size());
mxb_assert(m_stats.items > 0);
m_stats.size -= pNode->size();
m_stats.items -= 1;
@ -373,7 +373,7 @@ bool LRUStorage::free_node_data(Node* pNode)
}
else
{
ss_dassert(!true);
mxb_assert(!true);
MXS_ERROR("Could not remove value from storage, cannot "
"remove from LRU list or key mapping either.");
success = false;
@ -392,8 +392,8 @@ void LRUStorage::free_node(Node* pNode) const
remove_node(pNode);
delete pNode;
ss_dassert(!m_pHead || (m_pHead->prev() == NULL));
ss_dassert(!m_pTail || (m_pTail->next() == NULL));
mxb_assert(!m_pHead || (m_pHead->prev() == NULL));
mxb_assert(!m_pTail || (m_pTail->next() == NULL));
}
/**
@ -414,8 +414,8 @@ void LRUStorage::free_node(NodesByKey::iterator& i) const
*/
void LRUStorage::remove_node(Node* pNode) const
{
ss_dassert(m_pHead->prev() == NULL);
ss_dassert(m_pTail->next() == NULL);
mxb_assert(m_pHead->prev() == NULL);
mxb_assert(m_pTail->next() == NULL);
if (m_pHead == pNode)
{
@ -429,8 +429,8 @@ void LRUStorage::remove_node(Node* pNode) const
pNode->remove();
ss_dassert(!m_pHead || (m_pHead->prev() == NULL));
ss_dassert(!m_pTail || (m_pTail->next() == NULL));
mxb_assert(!m_pHead || (m_pHead->prev() == NULL));
mxb_assert(!m_pTail || (m_pTail->next() == NULL));
}
/**
@ -440,8 +440,8 @@ void LRUStorage::remove_node(Node* pNode) const
*/
void LRUStorage::move_to_head(Node* pNode) const
{
ss_dassert(!m_pHead || (m_pHead->prev() == NULL));
ss_dassert(!m_pTail || (m_pTail->next() == NULL));
mxb_assert(!m_pHead || (m_pHead->prev() == NULL));
mxb_assert(!m_pTail || (m_pTail->next() == NULL));
if (m_pTail == pNode)
{
@ -455,11 +455,11 @@ void LRUStorage::move_to_head(Node* pNode) const
m_pTail = m_pHead;
}
ss_dassert(m_pHead);
ss_dassert(m_pTail);
ss_dassert((m_pHead != m_pTail) || (m_pHead == pNode));
ss_dassert(m_pHead->prev() == NULL);
ss_dassert(m_pTail->next() == NULL);
mxb_assert(m_pHead);
mxb_assert(m_pTail);
mxb_assert((m_pHead != m_pTail) || (m_pHead == pNode));
mxb_assert(m_pHead->prev() == NULL);
mxb_assert(m_pTail->next() == NULL);
}
cache_result_t LRUStorage::get_existing_node(NodesByKey::iterator& i, const GWBUF* pValue, Node** ppNode)
@ -473,7 +473,7 @@ cache_result_t LRUStorage::get_existing_node(NodesByKey::iterator& i, const GWBU
// If the size of the new item is more than what is allowed in total,
// we must remove the value.
const CACHE_KEY* pkey = i->second->key();
ss_dassert(pkey);
mxb_assert(pkey);
result = do_del_value(*pkey);
@ -491,7 +491,7 @@ cache_result_t LRUStorage::get_existing_node(NodesByKey::iterator& i, const GWBU
if (new_size > m_max_size)
{
ss_dassert(value_size > pNode->size());
mxb_assert(value_size > pNode->size());
// We move it to the front, so that we do not have to deal with the case
// that 'pNode' is subject to removal.
@ -510,14 +510,14 @@ cache_result_t LRUStorage::get_existing_node(NodesByKey::iterator& i, const GWBU
}
else
{
ss_dassert(!true);
mxb_assert(!true);
// If we could not vacant nodes, we are hosed.
result = CACHE_RESULT_ERROR;
}
}
else
{
ss_dassert(m_stats.items <= m_max_count);
mxb_assert(m_stats.items <= m_max_count);
*ppNode = pNode;
}
}
@ -545,7 +545,7 @@ cache_result_t LRUStorage::get_new_node(const CACHE_KEY& key,
}
else if (m_stats.items == m_max_count)
{
ss_dassert(m_stats.items == m_max_count);
mxb_assert(m_stats.items == m_max_count);
pNode = vacate_lru();
}
@ -565,7 +565,7 @@ cache_result_t LRUStorage::get_new_node(const CACHE_KEY& key,
{
std::pair<NodesByKey::iterator, bool> rv;
rv = m_nodes_by_key.insert(std::make_pair(key, pNode));
ss_dassert(rv.second); // If true, the item was inserted as new (and not updated).
mxb_assert(rv.second); // If true, the item was inserted as new (and not updated).
*pI = rv.first;
}
catch (const std::exception& x)
@ -578,7 +578,7 @@ cache_result_t LRUStorage::get_new_node(const CACHE_KEY& key,
if (CACHE_RESULT_IS_OK(result))
{
ss_dassert(pNode);
mxb_assert(pNode);
*ppNode = pNode;
}

80
server/modules/filter/cache/rules.cc vendored
View File

@ -191,7 +191,7 @@ const char *cache_rule_attribute_to_string(cache_rule_attribute_t attribute)
return "user";
default:
ss_dassert(!true);
mxb_assert(!true);
return "<invalid>";
}
}
@ -213,7 +213,7 @@ const char *cache_rule_op_to_string(cache_rule_op_t op)
return "unlike";
default:
ss_dassert(!true);
mxb_assert(!true);
return "<invalid>";
}
}
@ -535,7 +535,7 @@ static bool cache_rule_attribute_get(struct cache_attribute_mapping *mapping,
const char *s,
cache_rule_attribute_t *attribute)
{
ss_dassert(attribute);
mxb_assert(attribute);
while (mapping->name)
{
@ -602,7 +602,7 @@ static CACHE_RULE *cache_rule_create_regexp(cache_rule_attribute_t attribute,
const char *cvalue,
uint32_t debug)
{
ss_dassert((op == CACHE_OP_LIKE) || (op == CACHE_OP_UNLIKE));
mxb_assert((op == CACHE_OP_LIKE) || (op == CACHE_OP_UNLIKE));
CACHE_RULE *rule = NULL;
@ -618,7 +618,7 @@ static CACHE_RULE *cache_rule_create_regexp(cache_rule_attribute_t attribute,
pcre2_jit_compile(code, PCRE2_JIT_COMPLETE);
int n_threads = config_threadcount();
ss_dassert(n_threads > 0);
mxb_assert(n_threads > 0);
pcre2_match_data **datas = alloc_match_datas(n_threads, code);
@ -679,8 +679,8 @@ static CACHE_RULE *cache_rule_create_simple_user(cache_rule_attribute_t attribut
{
CACHE_RULE *rule = NULL;
ss_dassert(attribute == CACHE_ATTRIBUTE_USER);
ss_dassert((op == CACHE_OP_EQ) || (op == CACHE_OP_NEQ));
mxb_assert(attribute == CACHE_ATTRIBUTE_USER);
mxb_assert((op == CACHE_OP_EQ) || (op == CACHE_OP_NEQ));
bool error = false;
size_t len = strlen(cvalue);
@ -785,10 +785,10 @@ static CACHE_RULE *cache_rule_create_simple_ctd(cache_rule_attribute_t attribute
const char *cvalue,
uint32_t debug)
{
ss_dassert((attribute == CACHE_ATTRIBUTE_COLUMN) ||
mxb_assert((attribute == CACHE_ATTRIBUTE_COLUMN) ||
(attribute == CACHE_ATTRIBUTE_TABLE) ||
(attribute == CACHE_ATTRIBUTE_DATABASE));
ss_dassert((op == CACHE_OP_EQ) || (op == CACHE_OP_NEQ));
mxb_assert((op == CACHE_OP_EQ) || (op == CACHE_OP_NEQ));
CACHE_RULE *rule = (CACHE_RULE*)MXS_CALLOC(1, sizeof(CACHE_RULE));
char *value = MXS_STRDUP(cvalue);
@ -914,7 +914,7 @@ static CACHE_RULE *cache_rule_create_simple_ctd(cache_rule_attribute_t attribute
break;
default:
ss_dassert(!true);
mxb_assert(!true);
}
if (allocation_failed)
@ -952,8 +952,8 @@ static CACHE_RULE *cache_rule_create_simple_query(cache_rule_attribute_t attribu
const char *cvalue,
uint32_t debug)
{
ss_dassert(attribute == CACHE_ATTRIBUTE_QUERY);
ss_dassert((op == CACHE_OP_EQ) || (op == CACHE_OP_NEQ));
mxb_assert(attribute == CACHE_ATTRIBUTE_QUERY);
mxb_assert((op == CACHE_OP_EQ) || (op == CACHE_OP_NEQ));
CACHE_RULE *rule = (CACHE_RULE*)MXS_CALLOC(1, sizeof(CACHE_RULE));
char *value = MXS_STRDUP(cvalue);
@ -990,7 +990,7 @@ static CACHE_RULE *cache_rule_create_simple(cache_rule_attribute_t attribute,
const char *cvalue,
uint32_t debug)
{
ss_dassert((op == CACHE_OP_EQ) || (op == CACHE_OP_NEQ));
mxb_assert((op == CACHE_OP_EQ) || (op == CACHE_OP_NEQ));
CACHE_RULE *rule = NULL;
@ -1012,7 +1012,7 @@ static CACHE_RULE *cache_rule_create_simple(cache_rule_attribute_t attribute,
default:
MXS_ERROR("Unknown attribute type: %d", (int)attribute);
ss_dassert(!true);
mxb_assert(!true);
}
return rule;
@ -1048,7 +1048,7 @@ static CACHE_RULE *cache_rule_create(cache_rule_attribute_t attribute,
break;
default:
ss_dassert(!true);
mxb_assert(!true);
MXS_ERROR("Internal error.");
break;
}
@ -1143,14 +1143,14 @@ static bool cache_rule_compare_n(CACHE_RULE *self, int thread_id, const char *va
case CACHE_OP_LIKE:
case CACHE_OP_UNLIKE:
ss_dassert((thread_id >= 0) && (thread_id < config_threadcount()));
mxb_assert((thread_id >= 0) && (thread_id < config_threadcount()));
compares = (pcre2_match(self->regexp.code,
(PCRE2_SPTR)value, length,
0, 0, self->regexp.datas[thread_id], NULL) >= 0);
break;
default:
ss_dassert(!true);
mxb_assert(!true);
}
if ((self->op == CACHE_OP_NEQ) || (self->op == CACHE_OP_UNLIKE))
@ -1176,8 +1176,8 @@ static bool cache_rule_matches_column_regexp(CACHE_RULE *self,
const char *default_db,
const GWBUF *query)
{
ss_dassert(self->attribute == CACHE_ATTRIBUTE_COLUMN);
ss_dassert((self->op == CACHE_OP_LIKE) || (self->op == CACHE_OP_UNLIKE));
mxb_assert(self->attribute == CACHE_ATTRIBUTE_COLUMN);
mxb_assert((self->op == CACHE_OP_LIKE) || (self->op == CACHE_OP_UNLIKE));
const char* default_database = NULL;
@ -1309,8 +1309,8 @@ static bool cache_rule_matches_column_regexp(CACHE_RULE *self,
*/
static bool cache_rule_matches_column_simple(CACHE_RULE *self, const char *default_db, const GWBUF *query)
{
ss_dassert(self->attribute == CACHE_ATTRIBUTE_COLUMN);
ss_dassert((self->op == CACHE_OP_EQ) || (self->op == CACHE_OP_NEQ));
mxb_assert(self->attribute == CACHE_ATTRIBUTE_COLUMN);
mxb_assert((self->op == CACHE_OP_EQ) || (self->op == CACHE_OP_NEQ));
const char* rule_column = self->simple.column;
const char* rule_table = self->simple.table;
@ -1471,7 +1471,7 @@ static bool cache_rule_matches_column(CACHE_RULE *self,
const char *default_db,
const GWBUF *query)
{
ss_dassert(self->attribute == CACHE_ATTRIBUTE_COLUMN);
mxb_assert(self->attribute == CACHE_ATTRIBUTE_COLUMN);
bool matches = false;
@ -1488,7 +1488,7 @@ static bool cache_rule_matches_column(CACHE_RULE *self,
break;
default:
ss_dassert(!true);
mxb_assert(!true);
}
return matches;
@ -1509,7 +1509,7 @@ static bool cache_rule_matches_database(CACHE_RULE *self,
const char *default_db,
const GWBUF *query)
{
ss_dassert(self->attribute == CACHE_ATTRIBUTE_DATABASE);
mxb_assert(self->attribute == CACHE_ATTRIBUTE_DATABASE);
bool matches = false;
@ -1569,7 +1569,7 @@ static bool cache_rule_matches_query(CACHE_RULE *self,
const char *default_db,
const GWBUF *query)
{
ss_dassert(self->attribute == CACHE_ATTRIBUTE_QUERY);
mxb_assert(self->attribute == CACHE_ATTRIBUTE_QUERY);
char* sql;
int len;
@ -1595,8 +1595,8 @@ static bool cache_rule_matches_table_regexp(CACHE_RULE *self,
const char *default_db,
const GWBUF *query)
{
ss_dassert(self->attribute == CACHE_ATTRIBUTE_TABLE);
ss_dassert((self->op == CACHE_OP_LIKE) || (self->op == CACHE_OP_UNLIKE));
mxb_assert(self->attribute == CACHE_ATTRIBUTE_TABLE);
mxb_assert((self->op == CACHE_OP_LIKE) || (self->op == CACHE_OP_UNLIKE));
bool matches = false;
@ -1674,8 +1674,8 @@ static bool cache_rule_matches_table_regexp(CACHE_RULE *self,
*/
static bool cache_rule_matches_table_simple(CACHE_RULE *self, const char *default_db, const GWBUF *query)
{
ss_dassert(self->attribute == CACHE_ATTRIBUTE_TABLE);
ss_dassert((self->op == CACHE_OP_EQ) || (self->op == CACHE_OP_NEQ));
mxb_assert(self->attribute == CACHE_ATTRIBUTE_TABLE);
mxb_assert((self->op == CACHE_OP_EQ) || (self->op == CACHE_OP_NEQ));
bool matches = false;
@ -1767,7 +1767,7 @@ static bool cache_rule_matches_table(CACHE_RULE *self,
const char *default_db,
const GWBUF *query)
{
ss_dassert(self->attribute == CACHE_ATTRIBUTE_TABLE);
mxb_assert(self->attribute == CACHE_ATTRIBUTE_TABLE);
bool matches = false;
@ -1784,7 +1784,7 @@ static bool cache_rule_matches_table(CACHE_RULE *self,
break;
default:
ss_dassert(!true);
mxb_assert(!true);
}
return matches;
@ -1801,7 +1801,7 @@ static bool cache_rule_matches_table(CACHE_RULE *self,
*/
static bool cache_rule_matches_user(CACHE_RULE *self, int thread_id, const char *account)
{
ss_dassert(self->attribute == CACHE_ATTRIBUTE_USER);
mxb_assert(self->attribute == CACHE_ATTRIBUTE_USER);
bool matches = cache_rule_compare(self, thread_id, account);
@ -1862,11 +1862,11 @@ static bool cache_rule_matches(CACHE_RULE *self, int thread_id, const char *defa
break;
case CACHE_ATTRIBUTE_USER:
ss_dassert(!true);
mxb_assert(!true);
break;
default:
ss_dassert(!true);
mxb_assert(!true);
}
if ((matches && (self->debug & CACHE_DEBUG_MATCHING)) ||
@ -1907,7 +1907,7 @@ static bool cache_rule_matches(CACHE_RULE *self, int thread_id, const char *defa
*/
static CACHE_RULE* cache_rule_append(CACHE_RULE* head, CACHE_RULE* tail)
{
ss_dassert(tail);
mxb_assert(tail);
if (!head)
{
@ -1960,7 +1960,7 @@ static void cache_rules_add_use_rule(CACHE_RULES* self, CACHE_RULE* rule)
*/
static CACHE_RULES* cache_rules_create_from_json(json_t* root, uint32_t debug)
{
ss_dassert(root);
mxb_assert(root);
CACHE_RULES *rules = cache_rules_create(debug);
@ -2013,7 +2013,7 @@ static bool cache_rules_create_from_json(json_t* pRoot, uint32_t debug,
for (i = 0; i < nRules; ++i)
{
json_t* pObject = json_array_get(pRoot, i);
ss_dassert(pObject);
mxb_assert(pObject);
CACHE_RULES* pRules = cache_rules_create_from_json(pObject, debug);
@ -2146,7 +2146,7 @@ static bool cache_rules_parse_array(CACHE_RULES *self,
const char *name,
cache_rules_parse_element_t parse_element)
{
ss_dassert(json_is_array(store));
mxb_assert(json_is_array(store));
bool parsed = true;
@ -2156,7 +2156,7 @@ static bool cache_rules_parse_array(CACHE_RULES *self,
while (parsed && (i < n))
{
json_t *element = json_array_get(store, i);
ss_dassert(element);
mxb_assert(element);
if (json_is_object(element))
{
@ -2187,7 +2187,7 @@ static CACHE_RULE *cache_rules_parse_element(CACHE_RULES *self, json_t *object,
const char* array_name, size_t index,
struct cache_attribute_mapping *mapping)
{
ss_dassert(json_is_object(object));
mxb_assert(json_is_object(object));
CACHE_RULE *rule = NULL;

12
server/modules/filter/cache/storage/storage_inmemory/inmemorystorage.cc vendored
View File

@ -55,7 +55,7 @@ InMemoryStorage* InMemoryStorage::Create_instance(const char* zName,
const CACHE_STORAGE_CONFIG& config,
int argc, char* argv[])
{
ss_dassert(zName);
mxb_assert(zName);
if (config.max_count != 0)
{
@ -78,7 +78,7 @@ InMemoryStorage* InMemoryStorage::Create_instance(const char* zName,
break;
default:
ss_dassert(!true);
mxb_assert(!true);
MXS_ERROR("Unknown thread model %d, creating multi-thread aware storage.",
(int)config.thread_model);
case CACHE_THREAD_MODEL_MT:
@ -192,7 +192,7 @@ cache_result_t InMemoryStorage::do_get_value(const CACHE_KEY& key,
}
else
{
ss_dassert(is_soft_stale);
mxb_assert(is_soft_stale);
result |= CACHE_RESULT_STALE;
}
}
@ -206,7 +206,7 @@ cache_result_t InMemoryStorage::do_get_value(const CACHE_KEY& key,
cache_result_t InMemoryStorage::do_put_value(const CACHE_KEY& key, const GWBUF& value)
{
ss_dassert(GWBUF_IS_CONTIGUOUS(&value));
mxb_assert(GWBUF_IS_CONTIGUOUS(&value));
size_t size = GWBUF_LENGTH(&value);
@ -257,8 +257,8 @@ cache_result_t InMemoryStorage::do_del_value(const CACHE_KEY& key)
if (i != m_entries.end())
{
ss_dassert(m_stats.size >= i->second.value.size());
ss_dassert(m_stats.items > 0);
mxb_assert(m_stats.size >= i->second.value.size());
mxb_assert(m_stats.items > 0);
m_stats.size -= i->second.value.size();
m_stats.items -= 1;

34
server/modules/filter/cache/storage/storagemodule.hh vendored
View File

@ -27,8 +27,8 @@ public:
const CACHE_STORAGE_CONFIG* pConfig,
int argc, char* argv[])
{
ss_dassert(zName);
ss_dassert(pConfig);
mxb_assert(zName);
mxb_assert(pConfig);
StorageType* pStorage = NULL;
@ -45,8 +45,8 @@ public:
static void getConfig(CACHE_STORAGE* pCache_storage,
CACHE_STORAGE_CONFIG* pConfig)
{
ss_dassert(pCache_storage);
ss_dassert(pConfig);
mxb_assert(pCache_storage);
mxb_assert(pConfig);
StorageType* pStorage = reinterpret_cast<StorageType*>(pCache_storage);
@ -57,7 +57,7 @@ public:
uint32_t what,
json_t** ppInfo)
{
ss_dassert(pCache_storage);
mxb_assert(pCache_storage);
cache_result_t result = CACHE_RESULT_ERROR;
@ -75,9 +75,9 @@ public:
uint32_t hard_ttl,
GWBUF** ppResult)
{
ss_dassert(pCache_storage);
ss_dassert(pKey);
ss_dassert(ppResult);
mxb_assert(pCache_storage);
mxb_assert(pKey);
mxb_assert(ppResult);
cache_result_t result = CACHE_RESULT_ERROR;
@ -92,9 +92,9 @@ public:
const CACHE_KEY* pKey,
const GWBUF* pValue)
{
ss_dassert(pCache_storage);
ss_dassert(pKey);
ss_dassert(pValue);
mxb_assert(pCache_storage);
mxb_assert(pKey);
mxb_assert(pValue);
cache_result_t result = CACHE_RESULT_ERROR;
@ -107,8 +107,8 @@ public:
static cache_result_t delValue(CACHE_STORAGE* pCache_storage, const CACHE_KEY* pKey)
{
ss_dassert(pCache_storage);
ss_dassert(pKey);
mxb_assert(pCache_storage);
mxb_assert(pKey);
cache_result_t result = CACHE_RESULT_ERROR;
@ -123,7 +123,7 @@ public:
CACHE_KEY* pKey,
GWBUF** ppHead)
{
ss_dassert(pCache_storage);
mxb_assert(pCache_storage);
cache_result_t result = CACHE_RESULT_ERROR;
@ -138,7 +138,7 @@ public:
CACHE_KEY* pKey,
GWBUF** ppTail)
{
ss_dassert(pCache_storage);
mxb_assert(pCache_storage);
cache_result_t result = CACHE_RESULT_ERROR;
@ -151,7 +151,7 @@ public:
static cache_result_t getSize(CACHE_STORAGE* pCache_storage, uint64_t* pSize)
{
ss_dassert(pCache_storage);
mxb_assert(pCache_storage);
cache_result_t result = CACHE_RESULT_ERROR;
@ -164,7 +164,7 @@ public:
static cache_result_t getItems(CACHE_STORAGE* pCache_storage, uint64_t* pItems)
{
ss_dassert(pCache_storage);
mxb_assert(pCache_storage);
cache_result_t result = CACHE_RESULT_ERROR;

14
server/modules/filter/cache/storagefactory.cc vendored
View File

@ -109,8 +109,8 @@ StorageFactory::StorageFactory(void* handle,
, m_storage_caps(capabilities)
, m_caps(capabilities)
{
ss_dassert(handle);
ss_dassert(pApi);
mxb_assert(handle);
mxb_assert(pApi);
m_caps |= CACHE_STORAGE_CAP_LRU;
m_caps |= CACHE_STORAGE_CAP_MAX_COUNT;
@ -150,8 +150,8 @@ Storage* StorageFactory::createStorage(const char* zName,
const CACHE_STORAGE_CONFIG& config,
int argc, char* argv[])
{
ss_dassert(m_handle);
ss_dassert(m_pApi);
mxb_assert(m_handle);
mxb_assert(m_pApi);
CacheStorageConfig used_config(config);
@ -184,7 +184,7 @@ Storage* StorageFactory::createStorage(const char* zName,
}
else
{
ss_dassert(config.thread_model == CACHE_THREAD_MODEL_MT);
mxb_assert(config.thread_model == CACHE_THREAD_MODEL_MT);
pLruStorage = LRUStorageMT::create(config, pStorage);
}
@ -209,8 +209,8 @@ Storage* StorageFactory::createRawStorage(const char* zName,
const CACHE_STORAGE_CONFIG& config,
int argc, char* argv[])
{
ss_dassert(m_handle);
ss_dassert(m_pApi);
mxb_assert(m_handle);
mxb_assert(m_pApi);
Storage* pStorage = 0;

4
server/modules/filter/cache/storagereal.cc vendored
View File

@ -19,8 +19,8 @@ StorageReal::StorageReal(CACHE_STORAGE_API* pApi, CACHE_STORAGE* pStorage)
: m_pApi(pApi)
, m_pStorage(pStorage)
{
ss_dassert(m_pApi);
ss_dassert(m_pStorage);
mxb_assert(m_pApi);
mxb_assert(m_pStorage);
}
StorageReal::~StorageReal()

12
server/modules/filter/cache/test/test_cacheoptions.cc vendored
View File

@ -106,7 +106,7 @@ const char* to_string(cache_in_trxs_t x)
return "all_transactions";
default:
ss_dassert(!true);
mxb_assert(!true);
return NULL;
}
}
@ -147,8 +147,8 @@ int test(mock::Session& session,
mock::Client& client = session.client();
// Let's check that there's nothing pending.
ss_dassert(client.n_responses() == 0);
ss_dassert(router_session.idle());
mxb_assert(client.n_responses() == 0);
mxb_assert(router_session.idle());
session.set_trx_state(tc.trx_state);
session.set_autocommit(tc.trx_state == SESSION_TRX_INACTIVE);
@ -168,9 +168,9 @@ int test(mock::Session& session,
router_session.respond();
// And let's verify that the backend is now empty...
ss_dassert(router_session.idle());
mxb_assert(router_session.idle());
// ...and that we have received a response.
ss_dassert(client.n_responses() == 1);
mxb_assert(client.n_responses() == 1);
// Let's do the select again.
pStatement = mock::create_com_query(select);
@ -191,7 +191,7 @@ int test(mock::Session& session,
cout << ", cache was used." << endl;
// Let's check we did receive a response.
ss_dassert(client.n_responses() == 2);
mxb_assert(client.n_responses() == 2);
}
}
else

12
server/modules/filter/cache/test/tester.cc vendored
View File

@ -34,12 +34,12 @@ public:
: m_pTask(pTask)
, m_thread(0)
{
ss_dassert(pTask);
mxb_assert(pTask);
}
~Thread()
{
ss_dassert(m_thread == 0);
mxb_assert(m_thread == 0);
}
static Thread from_task(Tester::Task* pTask)
@ -54,7 +54,7 @@ public:
void start()
{
ss_dassert(m_thread == 0);
mxb_assert(m_thread == 0);
if (pthread_create(&m_thread, NULL, &Thread::thread_main, this) != 0)
{
@ -65,7 +65,7 @@ public:
void wait()
{
ss_dassert(m_thread != 0);
mxb_assert(m_thread != 0);
pthread_join(m_thread, NULL);
m_thread = 0;
@ -254,13 +254,13 @@ bool Tester::get_cache_items(const Statements& statements,
}
else
{
ss_dassert(!true);
mxb_assert(!true);
success = false;
}
}
else
{
ss_dassert(!true);
mxb_assert(!true);
success = false;
}

12
server/modules/filter/cache/test/testerlrustorage.cc vendored
View File

@ -96,7 +96,7 @@ int TesterLRUStorage::test_lru(const CacheItems& cache_items, uint64_t size)
}
else
{
ss_dassert(!true);
mxb_assert(!true);
rv = EXIT_FAILURE;
}
@ -119,7 +119,7 @@ int TesterLRUStorage::test_lru(const CacheItems& cache_items, uint64_t size)
}
else
{
ss_dassert(!true);
mxb_assert(!true);
rv = EXIT_FAILURE;
}
}
@ -166,7 +166,7 @@ int TesterLRUStorage::test_max_count(size_t n_threads, size_t n_seconds,
uint64_t items;
cache_result_t result = pStorage->get_items(&items);
ss_dassert(result == CACHE_RESULT_OK);
mxb_assert(result == CACHE_RESULT_OK);
out() << "Max count: " << max_count << ", count: " << items << "." << endl;
@ -203,7 +203,7 @@ int TesterLRUStorage::test_max_size(size_t n_threads, size_t n_seconds,
uint64_t size;
cache_result_t result = pStorage->get_size(&size);
ss_dassert(result == CACHE_RESULT_OK);
mxb_assert(result == CACHE_RESULT_OK);
out() << "Max size: " << max_size << ", size: " << size << "." << endl;
@ -244,7 +244,7 @@ int TesterLRUStorage::test_max_count_and_size(size_t n_threads, size_t n_seconds
MXB_AT_DEBUG(cache_result_t result);
uint64_t items;
MXB_AT_DEBUG(result = ) pStorage->get_items(&items);
ss_dassert(result == CACHE_RESULT_OK);
mxb_assert(result == CACHE_RESULT_OK);
out() << "Max count: " << max_count << ", count: " << items << "." << endl;
@ -255,7 +255,7 @@ int TesterLRUStorage::test_max_count_and_size(size_t n_threads, size_t n_seconds
uint64_t size;
MXB_AT_DEBUG(result = ) pStorage->get_size(&size);
ss_dassert(result == CACHE_RESULT_OK);
mxb_assert(result == CACHE_RESULT_OK);
out() << "Max size: " << max_size << ", size: " << size << "." << endl;

20
server/modules/filter/cache/test/testerstorage.cc vendored
View File

@ -33,7 +33,7 @@ TesterStorage::HitTask::HitTask(ostream* pOut,
, m_dels(0)
, m_misses(0)
{
ss_dassert(m_cache_items.size() > 0);
mxb_assert(m_cache_items.size() > 0);
}
int TesterStorage::HitTask::run()
@ -65,7 +65,7 @@ int TesterStorage::HitTask::run()
}
else
{
ss_dassert(!true);
mxb_assert(!true);
rv = EXIT_FAILURE;
}
}
@ -78,8 +78,8 @@ int TesterStorage::HitTask::run()
if (CACHE_RESULT_IS_OK(result))
{
ss_dassert(GWBUF_LENGTH(pQuery) == GWBUF_LENGTH(cache_item.second));
ss_dassert(memcmp(GWBUF_DATA(pQuery), GWBUF_DATA(cache_item.second),
mxb_assert(GWBUF_LENGTH(pQuery) == GWBUF_LENGTH(cache_item.second));
mxb_assert(memcmp(GWBUF_DATA(pQuery), GWBUF_DATA(cache_item.second),
GWBUF_LENGTH(pQuery)) == 0);
gwbuf_free(pQuery);
@ -91,7 +91,7 @@ int TesterStorage::HitTask::run()
}
else
{
ss_dassert(!true);
mxb_assert(!true);
rv = EXIT_FAILURE;
}
}
@ -111,14 +111,14 @@ int TesterStorage::HitTask::run()
}
else
{
ss_dassert(!true);
mxb_assert(!true);
rv = EXIT_FAILURE;
}
}
break;
default:
ss_dassert(!true);
mxb_assert(!true);
}
++i;
@ -173,8 +173,8 @@ int TesterStorage::run(size_t n_threads,
{
size_t size = n_min_size + static_cast<size_t>((static_cast<double>(random()) / RAND_MAX) *
(n_max_size - n_min_size));
ss_dassert(size >= n_min_size);
ss_dassert(size <= n_max_size);
mxb_assert(size >= n_min_size);
mxb_assert(size <= n_max_size);
CacheKey key;
@ -322,7 +322,7 @@ int TesterStorage::test_ttl(const CacheItems& cache_items, Storage& storage)
if (diff != 0)
{
ss_dassert(cache_items.size() > 0);
mxb_assert(cache_items.size() > 0);
out() << "Hard TTL: " << hard_ttl << endl;
out() << "Soft TTL: " << soft_ttl << endl;

2
server/modules/filter/cache/test/testkeygeneration.cc vendored
View File

@ -57,7 +57,7 @@ int test(StorageFactory& factory, istream& in)
{
string statement = *i;
GWBUF* pQuery = Tester::gwbuf_from_string(statement);
ss_dassert(pQuery);
mxb_assert(pQuery);
if (pQuery)
{

10
server/modules/filter/cache/test/testrules.cc vendored
View File

@ -35,7 +35,7 @@ GWBUF* create_gwbuf(const char* s)
size_t gwbuf_len = MYSQL_HEADER_LEN + payload_len;
GWBUF* gwbuf = gwbuf_alloc(gwbuf_len);
ss_dassert(gwbuf);
mxb_assert(gwbuf);
*((unsigned char*)((char*)GWBUF_DATA(gwbuf))) = payload_len;
*((unsigned char*)((char*)GWBUF_DATA(gwbuf) + 1)) = (payload_len >> 8);
@ -92,14 +92,14 @@ int test_user()
CACHE_RULES** ppRules;
int32_t nRules;
bool rv = cache_rules_parse(test_case.json, 0, &ppRules, &nRules);
ss_dassert(rv);
mxb_assert(rv);
for (int i = 0; i < nRules; ++i)
{
CACHE_RULES* pRules = ppRules[i];
CACHE_RULE* pRule = pRules->use_rules;
ss_dassert(pRule);
mxb_assert(pRule);
if (pRule->op != test_case.expect.op)
{
@ -206,14 +206,14 @@ int test_store()
int32_t nRules;
bool rv = cache_rules_parse(test_case.rule, 0, &ppRules, &nRules);
ss_dassert(rv);
mxb_assert(rv);
for (int i = 0; i < nRules; ++i)
{
CACHE_RULES* pRules = ppRules[i];
CACHE_RULE* pRule = pRules->store_rules;
ss_dassert(pRule);
mxb_assert(pRule);
GWBUF* pPacket = create_gwbuf(test_case.query);

2
server/modules/filter/cache/test/teststorage.cc vendored
View File

@ -66,7 +66,7 @@ int TestStorage::run(int argc, char** argv)
switch (argc)
{
default:
ss_dassert(!true);
mxb_assert(!true);
case 7:
max_size = atoi(argv[6]);
case 6:

56
server/modules/filter/dbfwfilter/dbfwfilter.cc
View File

@ -328,7 +328,7 @@ bool check_time(const char* str)
#ifdef SS_DEBUG
#define CHK_TIMES(t) ss_dassert(t->tm_sec > -1 && t->tm_sec < 62 \
#define CHK_TIMES(t) mxb_assert(t->tm_sec > -1 && t->tm_sec < 62 \
&& t->tm_min > -1 && t->tm_min < 60 \
&& t->tm_hour > -1 && t->tm_hour < 24)
#else
@ -481,7 +481,7 @@ bool dbfw_show_rules_json(const MODULECMD_ARG *argv, json_t** output)
static int dbfw_thr_init()
{
ss_dassert(this_thread == NULL);
mxb_assert(this_thread == NULL);
int rval = 0;
if ((this_thread = new (std::nothrow) DbfwThread) == NULL)
@ -720,7 +720,7 @@ bool set_rule_name(void* scanner, char* name)
{
bool rval = true;
struct parser_stack* rstack = (struct parser_stack*)dbfw_yyget_extra((yyscan_t)scanner);
ss_dassert(rstack);
mxb_assert(rstack);
if (find_rule_by_name(rstack->rule, name))
{
@ -756,14 +756,14 @@ static std::string strip_backticks(std::string str)
void push_value(void* scanner, char* value)
{
struct parser_stack* rstack = (struct parser_stack*)dbfw_yyget_extra((yyscan_t)scanner);
ss_dassert(rstack);
mxb_assert(rstack);
rstack->values.push_back(strip_backticks(value));
}
void push_auxiliary_value(void* scanner, char* value)
{
struct parser_stack* rstack = (struct parser_stack*)dbfw_yyget_extra((yyscan_t)scanner);
ss_dassert(rstack);
mxb_assert(rstack);
rstack->auxiliary_values.push_back(strip_backticks(value));
}
@ -775,7 +775,7 @@ void push_auxiliary_value(void* scanner, char* value)
void add_active_user(void* scanner, const char* name)
{
struct parser_stack* rstack = (struct parser_stack*)dbfw_yyget_extra((yyscan_t) scanner);
ss_dassert(rstack);
mxb_assert(rstack);
rstack->user.push_back(name);
}
@ -787,7 +787,7 @@ void add_active_user(void* scanner, const char* name)
void add_active_rule(void* scanner, const char* name)
{
struct parser_stack* rstack = (struct parser_stack*)dbfw_yyget_extra((yyscan_t) scanner);
ss_dassert(rstack);
mxb_assert(rstack);
rstack->active_rules.push_back(name);
}
@ -799,10 +799,10 @@ void add_active_rule(void* scanner, const char* name)
bool add_at_times_rule(void* scanner, const char* range)
{
struct parser_stack* rstack = (struct parser_stack*)dbfw_yyget_extra((yyscan_t) scanner);
ss_dassert(rstack);
ss_dassert(!rstack->rule.empty());
mxb_assert(rstack);
mxb_assert(!rstack->rule.empty());
TIMERANGE* timerange = parse_time(range);
ss_dassert(timerange);
mxb_assert(timerange);
if (timerange)
{
@ -821,8 +821,8 @@ bool add_at_times_rule(void* scanner, const char* range)
void add_on_queries_rule(void* scanner, const char* sql)
{
struct parser_stack* rstack = (struct parser_stack*)dbfw_yyget_extra((yyscan_t) scanner);
ss_dassert(rstack);
ss_dassert(!rstack->rule.empty());
mxb_assert(rstack);
mxb_assert(!rstack->rule.empty());
parse_querytypes(sql, rstack->rule.front());
}
@ -833,7 +833,7 @@ void add_on_queries_rule(void* scanner, const char* sql)
bool create_user_templates(void* scanner)
{
struct parser_stack* rstack = (struct parser_stack*)dbfw_yyget_extra((yyscan_t) scanner);
ss_dassert(rstack);
mxb_assert(rstack);
for (ValueList::const_iterator it = rstack->user.begin(); it != rstack->user.end(); it++)
{
@ -850,7 +850,7 @@ bool create_user_templates(void* scanner)
void set_matching_mode(void* scanner, enum match_type mode)
{
struct parser_stack* rstack = (struct parser_stack*)dbfw_yyget_extra((yyscan_t) scanner);
ss_dassert(rstack);
mxb_assert(rstack);
rstack->active_mode = mode;
}
@ -862,7 +862,7 @@ void set_matching_mode(void* scanner, enum match_type mode)
void define_basic_rule(void* scanner)
{
struct parser_stack* rstack = (struct parser_stack*)dbfw_yyget_extra((yyscan_t) scanner);
ss_dassert(rstack);
mxb_assert(rstack);
rstack->add(new Rule(rstack->name));
}
@ -874,7 +874,7 @@ void define_basic_rule(void* scanner)
void define_wildcard_rule(void* scanner)
{
struct parser_stack* rstack = (struct parser_stack*)dbfw_yyget_extra((yyscan_t) scanner);
ss_dassert(rstack);
mxb_assert(rstack);
rstack->add(new WildCardRule(rstack->name));
}
@ -886,7 +886,7 @@ void define_wildcard_rule(void* scanner)
void define_columns_rule(void* scanner)
{
struct parser_stack* rstack = (struct parser_stack*)dbfw_yyget_extra((yyscan_t) scanner);
ss_dassert(rstack);
mxb_assert(rstack);
rstack->add(new ColumnsRule(rstack->name, rstack->values));
}
@ -898,7 +898,7 @@ void define_columns_rule(void* scanner)
void define_function_rule(void* scanner, bool inverted)
{
struct parser_stack* rstack = (struct parser_stack*)dbfw_yyget_extra((yyscan_t) scanner);
ss_dassert(rstack);
mxb_assert(rstack);
rstack->add(new FunctionRule(rstack->name, rstack->values, inverted));
}
@ -910,7 +910,7 @@ void define_function_rule(void* scanner, bool inverted)
void define_function_usage_rule(void* scanner)
{
struct parser_stack* rstack = (struct parser_stack*)dbfw_yyget_extra((yyscan_t) scanner);
ss_dassert(rstack);
mxb_assert(rstack);
rstack->add(new FunctionUsageRule(rstack->name, rstack->values));
}
@ -922,7 +922,7 @@ void define_function_usage_rule(void* scanner)
void define_column_function_rule(void* scanner, bool inverted)
{
struct parser_stack* rstack = (struct parser_stack*)dbfw_yyget_extra((yyscan_t) scanner);
ss_dassert(rstack);
mxb_assert(rstack);
rstack->add(new ColumnFunctionRule(rstack->name, rstack->values, rstack->auxiliary_values, inverted));
}
@ -934,7 +934,7 @@ void define_column_function_rule(void* scanner, bool inverted)
void define_where_clause_rule(void* scanner)
{
struct parser_stack* rstack = (struct parser_stack*)dbfw_yyget_extra((yyscan_t) scanner);
ss_dassert(rstack);
mxb_assert(rstack);
rstack->add(new NoWhereClauseRule(rstack->name));
}
@ -953,7 +953,7 @@ void define_limit_queries_rule(void* scanner, int max, int timeperiod, int holdo
"Please use the Throttle Filter instead");
struct parser_stack* rstack = (struct parser_stack*)dbfw_yyget_extra((yyscan_t) scanner);
ss_dassert(rstack);
mxb_assert(rstack);
rstack->add(new LimitQueriesRule(rstack->name, max, timeperiod, holdoff));
}
@ -969,7 +969,7 @@ bool define_regex_rule(void* scanner, char* pattern)
{
/** This should never fail as long as the rule syntax is correct */
PCRE2_SPTR start = (PCRE2_SPTR) get_regex_string(&pattern);
ss_dassert(start);
mxb_assert(start);
pcre2_code *re;
int err;
size_t offset;
@ -977,7 +977,7 @@ bool define_regex_rule(void* scanner, char* pattern)
0, &err, &offset, NULL)))
{
struct parser_stack* rstack = (struct parser_stack*)dbfw_yyget_extra((yyscan_t) scanner);
ss_dassert(rstack);
mxb_assert(rstack);
rstack->add(new RegexRule(rstack->name, re));
}
else
@ -1400,7 +1400,7 @@ fw_actions DbfwSession::get_action() const
int DbfwSession::send_error()
{
ss_dassert(m_session && m_session->client_dcb);
mxb_assert(m_session && m_session->client_dcb);
const char* db = mxs_mysql_get_current_db(m_session);
std::stringstream ss;
ss << "Access denied for user '" << user() << "'@'" << remote() << "'";
@ -1455,7 +1455,7 @@ int DbfwSession::routeQuery(GWBUF* buffer)
if (qc_query_is_type(type, QUERY_TYPE_PREPARE_NAMED_STMT))
{
analyzed_queue = qc_get_preparable_stmt(buffer);
ss_dassert(analyzed_queue);
mxb_assert(analyzed_queue);
}
SUser suser = find_user_data(this_thread->users(m_instance), user(), remote());
@ -1486,7 +1486,7 @@ int DbfwSession::routeQuery(GWBUF* buffer)
default:
MXS_ERROR("Unknown dbfwfilter action: %d", m_instance->get_action());
ss_dassert(false);
mxb_assert(false);
break;
}
@ -1674,7 +1674,7 @@ bool rule_matches(Dbfw* my_instance,
SRule rule,
char* query)
{
ss_dassert(GWBUF_IS_CONTIGUOUS(queue));
mxb_assert(GWBUF_IS_CONTIGUOUS(queue));
char *msg = NULL;
bool matches = false;
bool is_sql = modutil_is_SQL(queue) || modutil_is_SQL_prepare(queue);

8
server/modules/filter/dbfwfilter/test/tempfile.cc
View File

@ -28,21 +28,21 @@ TempFile::TempFile()
, m_name(NAME_TEMPLATE)
{
m_fd = mkstemp((char*)m_name.c_str());
ss_dassert(m_fd != -1);
mxb_assert(m_fd != -1);
}
TempFile::~TempFile()
{
int rc = unlink(m_name.c_str());
ss_dassert(rc != -1);
mxb_assert(rc != -1);
close(m_fd);
}
void TempFile::write(const void* pData, size_t count)
{
int rc = ::write(m_fd, pData, count);
ss_dassert(rc != -1);
ss_dassert((size_t)rc == count);
mxb_assert(rc != -1);
mxb_assert((size_t)rc == count);
}
void TempFile::write(const char* zData)

Some files were not shown because too many files have changed in this diff Show More