END_TEST
START_TEST(test_zookeeper)
{
assert_ret(init_event(4096), 0);
#ifdef BUILD_ZOOKEEPER
zoo_set_debug_level(0);
#endif
do_test("zookeeper:localhost:2181,timeout=1000");
}
// perform sql statement
db_query_basic::list_rec_set_t db_query_basic::perform(std::string query)
{
if (query.empty())
return list_rec_set_t();
// replace "%table_name%" to table_name
//query = std::regex_replace(query, std::regex("\\%table_name%"), _table);
int ret = mysql_real_query(_db.conn(), query.c_str(), static_cast<unsigned long>(query.length()));
assert_ret(ret);
list_rec_set_t list_rec_set;
int status = 0;
do
{
size_t num_col = mysql_field_count(_db.conn());
MYSQL_RES* res = mysql_store_result(_db.conn());
size_t affected = static_cast<size_t>(mysql_affected_rows(_db.conn()));
if (res == nullptr)
{
// raise exception if result is supposed to be returned
if (num_col > 0)
throw ex_db_mariadb(_db.conn());
db_record_meta::list_column_t list_col_empty;
db_record_meta meta_empty(list_col_empty);
db_record_set rec_set_empty(meta_empty);
rec_set_empty._affected = affected;
list_rec_set.push_back(rec_set_empty);
}
else // when MYSQL_RES* available
{
MYSQL_FIELD* p_col = mysql_fetch_fields(res);
db_record_set rec_set(db_record_meta(p_col, num_col));
for (size_t idx_row = 0; idx_row < res->row_count; idx_row++)
{
assert_res(res);
const MYSQL_ROW row = mysql_fetch_row(res);
assert_row(row);
record_t rec_d = rec_set.record_new();
for (size_t idx_col = 0; idx_col < num_col; idx_col++)
rec_d[idx_col] = (row[idx_col] == nullptr ? "" : row[idx_col]);
rec_set.list_record().push_back(rec_d);
}
rec_set._affected = res->row_count;
list_rec_set.push_back(rec_set);
mysql_free_result(res);
}
// check whether there are more result sets:
// status > 0 error occurred;
// status = 0 more result sets returned;
// status < 0 no next result set;
if ((status = mysql_next_result(_db.conn())) > 0)
throw ex_db_mariadb(_db.conn());
} while (status == 0);
return list_rec_set;
}
static void test_check_numbers_up (sd_journal *j, int count) {
for (int i = count; i >= 1; i--) {
int r;
test_check_number(j, i);
assert_ret(r = sd_journal_previous(j));
if (i == 1)
assert_se(r == 0);
else
assert_se(r == 1);
}
}
static void test_check_numbers_down (sd_journal *j, int count)
{
for (int i = 1; i <= count; i++) {
int r;
test_check_number(j, i);
assert_ret(r = sd_journal_next(j));
if (i == count)
assert_se(r == 0);
else
assert_se(r == 1);
}
}
static void test_check_number (sd_journal *j, int n) {
const void *d;
_cleanup_free_ char *k;
size_t l;
int x;
assert_ret(sd_journal_get_data(j, "NUMBER", &d, &l));
assert_se(k = strndup(d, l));
printf("%s\n", k);
assert_se(safe_atoi(k + 7, &x) >= 0);
assert_se(n == x);
}
static void append_number(JournalFile *f, int n, uint64_t *seqnum) {
char *p;
dual_timestamp ts;
struct iovec iovec[1];
dual_timestamp_get(&ts);
assert_se(asprintf(&p, "NUMBER=%d", n) >= 0);
iovec[0].iov_base = p;
iovec[0].iov_len = strlen(p);
assert_ret(journal_file_append_entry(f, &ts, iovec, 1, seqnum, NULL, NULL));
free(p);
}
static void append_number(JournalFile *f, int n, uint64_t *seqnum) {
char *p;
dual_timestamp ts;
static dual_timestamp previous_ts = {};
struct iovec iovec[1];
dual_timestamp_get(&ts);
if (ts.monotonic <= previous_ts.monotonic)
ts.monotonic = previous_ts.monotonic + 1;
if (ts.realtime <= previous_ts.realtime)
ts.realtime = previous_ts.realtime + 1;
previous_ts = ts;
assert_se(asprintf(&p, "NUMBER=%d", n) >= 0);
iovec[0].iov_base = p;
iovec[0].iov_len = strlen(p);
assert_ret(journal_file_append_entry(f, &ts, iovec, 1, seqnum, NULL, NULL));
free(p);
}
static void do_test(const char *arg)
{
struct cluster_driver *driver;
struct sd_node node;
const char *option;
size_t len = 4;
void *msg;
driver = find_cdrv(arg);
if (!driver)
return;
option = get_cdrv_option(driver, arg);
msg = xmalloc(len);
assert_ret(driver->init(option), 0);
assert_ret(driver->join(&node, msg, len), 0);
LOOP_WHEN(method_nr_call(sd_join_handler) == 0);
LOOP_WHEN(method_nr_call(sd_accept_handler) == 0);
ck_assert_int_eq(method_nr_call(sd_join_handler), 1);
ck_assert_int_eq(method_nr_call(sd_accept_handler), 1);
assert_ret(driver->block(), 0);
assert_ret(driver->block(), 0);
LOOP_WHEN(method_nr_call(sd_block_handler) == 0);
ck_assert_int_eq(method_nr_call(sd_block_handler), 1);
assert_ret(driver->unblock(msg, len), 0);
LOOP_WHEN(method_nr_call(sd_block_handler) == 1);
ck_assert_int_eq(method_nr_call(sd_block_handler), 2);
ck_assert_int_eq(method_nr_call(sd_notify_handler), 1);
assert_ret(driver->unblock(msg, len), 0);
LOOP_WHEN(method_nr_call(sd_notify_handler) == 1);
ck_assert_int_eq(method_nr_call(sd_notify_handler), 2);
free(msg);
}
static JournalFile *test_open (const char *name)
{
JournalFile *f;
assert_ret(journal_file_open(name, O_RDWR|O_CREAT, 0644, true, false, NULL, NULL, NULL, &f));
return f;
}
static void test_skip(void (*setup)(void))
{
char t[] = "/tmp/journal-skip-XXXXXX";
sd_journal *j;
int r;
assert_se(mkdtemp(t));
assert_se(chdir(t) >= 0);
setup();
/* Seek to head, iterate down.
*/
assert_ret(sd_journal_open_directory(&j, t, 0));
assert_ret(sd_journal_seek_head(j));
assert_ret(sd_journal_next(j));
test_check_numbers_down(j, 4);
sd_journal_close(j);
/* Seek to tail, iterate up.
*/
assert_ret(sd_journal_open_directory(&j, t, 0));
assert_ret(sd_journal_seek_tail(j));
assert_ret(sd_journal_previous(j));
test_check_numbers_up(j, 4);
sd_journal_close(j);
/* Seek to tail, skip to head, iterate down.
*/
assert_ret(sd_journal_open_directory(&j, t, 0));
assert_ret(sd_journal_seek_tail(j));
assert_ret(r = sd_journal_previous_skip(j, 4));
assert_se(r == 4);
test_check_numbers_down(j, 4);
sd_journal_close(j);
/* Seek to head, skip to tail, iterate up.
*/
assert_ret(sd_journal_open_directory(&j, t, 0));
assert_ret(sd_journal_seek_head(j));
assert_ret(r = sd_journal_next_skip(j, 4));
assert_se(r == 4);
test_check_numbers_up(j, 4);
sd_journal_close(j);
log_info("Done...");
if (arg_keep)
log_info("Not removing %s", t);
else {
journal_directory_vacuum(".", 3000000, 0, 0, NULL);
assert_se(rm_rf_dangerous(t, false, true, false) >= 0);
}
puts("------------------------------------------------------------");
}
