int replay(ObUpsMutator& mutator)
{
data_len_ = 0;
mutator.serialize(log_data_, BUFSIZ, data_len_);
cond_.wait(lock_);
if (is_error_)
{
return OB_ERROR;
}
else
{
return OB_SUCCESS;
}
}
void fill_memtable(MemTable &memtable)
{
ObUpsMutator mutator;
ObMutatorCellInfo cellinfo;
MemTableTransHandle handle;
cellinfo.op_type.set_ext(ObActionFlag::OP_INSERT);
cellinfo.cell_info.table_id_ = 1001;
cellinfo.cell_info.row_key_.assign("rk0001_00000000000", 17);
cellinfo.cell_info.column_id_ = 5;
cellinfo.cell_info.value_.set_int(1023);
int ret = mutator.get_mutator().add_cell(cellinfo);
assert(OB_SUCCESS == ret);
cellinfo.cell_info.value_.set_int(1, true);
ret = mutator.get_mutator().add_cell(cellinfo);
assert(OB_SUCCESS == ret);
cellinfo.cell_info.row_key_.assign("rk0002_00000000000", 17);
ret = mutator.get_mutator().add_cell(cellinfo);
assert(OB_SUCCESS == ret);
cellinfo.cell_info.row_key_.assign("rk0003_00000000000", 17);
ret = mutator.get_mutator().add_cell(cellinfo);
assert(OB_SUCCESS == ret);
cellinfo.cell_info.table_id_ = 1002;
cellinfo.cell_info.value_.set_int(1024);
ret = mutator.get_mutator().add_cell(cellinfo);
assert(OB_SUCCESS == ret);
ret = memtable.start_transaction(WRITE_TRANSACTION, handle);
assert(OB_SUCCESS == ret);
ret = memtable.set(handle, mutator);
assert(OB_SUCCESS == ret);
ret = memtable.end_transaction(handle);
assert(OB_SUCCESS == ret);
}
int test_main(int argc, char **argv)
{
UNUSED(argc);
UNUSED(argv);
ObUpdateServerMain *main = ObUpdateServerMain::get_instance();
ObUpsTableMgr &tm = main->get_update_server().get_table_mgr();
CommonSchemaManagerWrapper schema_mgr;
tbsys::CConfig config;
schema_mgr.parse_from_file("test_schema.ini", config);
tm.set_schemas(schema_mgr);
MemTable memtable;
MemTableRowIterator row_iter;
ObUpsMutator mutator;
ObMutatorCellInfo cellinfo;
uint64_t trans_descriptor = 0;
int ret = memtable.init();
assert(OB_SUCCESS == ret);
cellinfo.op_type.set_ext(ObActionFlag::OP_INSERT);
cellinfo.cell_info.table_id_ = 1001;
cellinfo.cell_info.row_key_ = make_rowkey("rk0001_00000000000", &allocator_);
cellinfo.cell_info.column_id_ = 5;
cellinfo.cell_info.value_.set_int(1023);
ret = mutator.get_mutator().add_cell(cellinfo);
assert(OB_SUCCESS == ret);
cellinfo.cell_info.value_.set_int(1, true);
ret = mutator.get_mutator().add_cell(cellinfo);
assert(OB_SUCCESS == ret);
cellinfo.cell_info.table_id_ = 1002;
cellinfo.cell_info.value_.set_int(1024);
ret = mutator.get_mutator().add_cell(cellinfo);
assert(OB_SUCCESS == ret);
prepare_mutator(mutator.get_mutator());
ret = memtable.start_transaction(WRITE_TRANSACTION, trans_descriptor);
assert(OB_SUCCESS == ret);
ret = memtable.start_mutation(trans_descriptor);
assert(OB_SUCCESS == ret);
ret = memtable.set(trans_descriptor, mutator);
assert(OB_SUCCESS == ret);
ret = memtable.end_mutation(trans_descriptor, false);
assert(OB_SUCCESS == ret);
ret = memtable.end_transaction(trans_descriptor, false);
assert(OB_SUCCESS == ret);
ret = row_iter.init(&memtable);
assert(OB_SUCCESS == ret);
uint64_t check_id = 1001;
sstable::ObSSTableRow sstable_row;
ObRowkey rowkey(NULL, 1);
while (OB_SUCCESS == row_iter.next_row())
{
ret = row_iter.get_row(sstable_row);
assert(OB_SUCCESS == ret);
assert(check_id++ == sstable_row.get_table_id());
sstable_row.get_rowkey(rowkey);
assert(cellinfo.cell_info.row_key_ == rowkey);
for (int32_t i = 0; i < sstable_row.get_obj_count();)
{
int64_t intv = 0;
sstable_row.get_obj(i++)->get_int(intv);
fprintf(stderr, "table_id=%lu column_id=%lu ", sstable_row.get_table_id(), intv);
fprintf(stderr, "value=[%s]\n", common::print_obj(*sstable_row.get_obj(i++)));
}
}
row_iter.reset_iter();
check_id = 1001;
while (OB_SUCCESS == row_iter.next_row())
{
ret = row_iter.get_row(sstable_row);
assert(OB_SUCCESS == ret);
assert(check_id++ == sstable_row.get_table_id());
sstable_row.get_rowkey(rowkey);
assert(cellinfo.cell_info.row_key_ == rowkey);
for (int32_t i = 0; i < sstable_row.get_obj_count();)
{
int64_t intv = 0;
sstable_row.get_obj(i++)->get_int(intv);
fprintf(stderr, "table_id=%lu column_id=%lu ", sstable_row.get_table_id(), intv);
fprintf(stderr, "value=[%s]\n", common::print_obj(*sstable_row.get_obj(i++)));
}
}
return 0;
}
TEST_F(TestObUpsLogMgr, test_init)
{
int64_t log_file_max_size = 1L << 28;
ObRoleMgr role_mgr;
SlaveMgr4Test sm4t;
ObUpsLogMgr log_mgr1;
ASSERT_EQ(OB_SUCCESS, log_mgr1.init(log_dir, log_file_max_size, sm4t.get_slave_mgr(), &role_mgr, 0));
ASSERT_EQ(1U, log_mgr1.get_replay_point());
erase_file(1);
uint64_t log_file_max_id = 1100;
uint64_t log_max_seq = 22000;
char lf[BUFSIZ];
int64_t lf_pos = 0;
ObUpsMutator mutator;
ASSERT_EQ(OB_SUCCESS, mutator.serialize(lf, BUFSIZ, lf_pos));
uint64_t new_log_file_id;
ObLogWriter log_writer;
ASSERT_EQ(OB_SUCCESS, log_writer.init(log_dir, log_file_max_size, sm4t.get_slave_mgr(), 0));
ASSERT_EQ(OB_SUCCESS, log_writer.start_log(log_file_max_id, log_max_seq));
ASSERT_EQ(OB_SUCCESS, log_writer.switch_log_file(new_log_file_id));
ASSERT_EQ(OB_SUCCESS, log_writer.switch_log_file(new_log_file_id));
ASSERT_EQ(OB_SUCCESS, log_writer.write_log(OB_LOG_UPS_MUTATOR, lf, lf_pos));
ASSERT_EQ(OB_SUCCESS, log_writer.flush_log());
ASSERT_EQ(OB_SUCCESS, log_writer.switch_log_file(new_log_file_id));
ASSERT_EQ(OB_SUCCESS, log_writer.write_log(OB_LOG_UPS_MUTATOR, lf, lf_pos));
ASSERT_EQ(OB_SUCCESS, log_writer.flush_log());
ASSERT_EQ(OB_SUCCESS, log_writer.switch_log_file(new_log_file_id));
ASSERT_EQ(false, exists(ObUpsLogMgr::UPS_LOG_REPLAY_POINT_FILE));
ObUpsLogMgr log_mgr2;
ASSERT_EQ(OB_SUCCESS, log_mgr2.init(log_dir, log_file_max_size, sm4t.get_slave_mgr(), &role_mgr, 0));
ASSERT_EQ(log_file_max_id, log_mgr2.get_replay_point());
log_mgr2.set_replay_point(100);
ASSERT_EQ(100U, log_mgr2.get_replay_point());
log_mgr2.set_replay_point(log_file_max_id + 1);
ASSERT_EQ(log_file_max_id + 1, log_mgr2.get_replay_point());
ObUpsTableMgr table_mgr;
ASSERT_EQ(OB_SUCCESS, table_mgr.init());
ASSERT_EQ(0U, log_mgr2.get_cur_log_seq());
ASSERT_EQ(OB_SUCCESS, log_mgr2.replay_log(table_mgr));
ASSERT_NE(0U, log_mgr2.get_cur_log_seq());
ASSERT_EQ(OB_SUCCESS, log_mgr2.write_log(OB_LOG_UPS_MUTATOR, lf, lf_pos));
ASSERT_EQ(OB_SUCCESS, log_mgr2.flush_log());
ASSERT_EQ(OB_SUCCESS, log_mgr2.switch_log_file(new_log_file_id));
log_mgr2.set_replay_point(new_log_file_id);
}
TEST_F(TestObUpsReplayRunnable, test_init)
{
int64_t log_file_max_size = 1L << 24;
uint64_t log_file_max_id = 1100;
uint64_t log_max_seq = 22000;
char lf[BUFSIZ];
int64_t lf_pos = 0;
ObUpsMutator mutator;
ASSERT_EQ(OB_SUCCESS, mutator.serialize(lf, BUFSIZ, lf_pos));
SlaveMgr4Test sm4t;
TestUpdateServerMain test_main;
TestTableMgr &table_mgr = test_main.get_update_server().get_table_mgr();
uint64_t new_log_file_id;
ObLogWriter log_writer;
ASSERT_EQ(OB_SUCCESS, log_writer.init(log_dir, log_file_max_size, sm4t.get_slave_mgr(), 0));
ASSERT_EQ(OB_SUCCESS, log_writer.start_log(log_file_max_id, log_max_seq));
ASSERT_EQ(OB_SUCCESS, log_writer.switch_log_file(new_log_file_id));
ASSERT_EQ(log_file_max_id + 1, new_log_file_id);
ASSERT_EQ(OB_SUCCESS, log_writer.switch_log_file(new_log_file_id));
ASSERT_EQ(OB_SUCCESS, log_writer.write_log(OB_LOG_UPS_MUTATOR, lf, lf_pos));
ASSERT_EQ(OB_SUCCESS, log_writer.flush_log());
ASSERT_EQ(OB_SUCCESS, log_writer.switch_log_file(new_log_file_id));
ASSERT_EQ(OB_SUCCESS, log_writer.write_log(OB_LOG_UPS_MUTATOR, lf, lf_pos));
ASSERT_EQ(OB_SUCCESS, log_writer.flush_log());
ASSERT_EQ(OB_SUCCESS, log_writer.switch_log_file(new_log_file_id));
ObRoleMgr role_mgr;
role_mgr.set_role(ObRoleMgr::SLAVE);
ObUpsReplayRunnable replay_thread0;
ASSERT_EQ(OB_SUCCESS, replay_thread0.init(log_dir, log_file_max_id, &role_mgr, true));
replay_thread0.start();
usleep(1000);
ASSERT_EQ(lf_pos, table_mgr.data_len_);
ASSERT_EQ(0, memcmp(table_mgr.log_data_, lf, lf_pos));
table_mgr.cond_.signal();
usleep(1000);
ASSERT_EQ(lf_pos, table_mgr.data_len_);
ASSERT_EQ(0, memcmp(table_mgr.log_data_, lf, lf_pos));
table_mgr.cond_.signal();
usleep(1000);
replay_thread0.stop();
replay_thread0.wait();
// test replay error
ObUpsReplayRunnable replay_thread1;
//replay_thread1.ups_main_ = &test_main;
ASSERT_EQ(OB_SUCCESS, replay_thread1.init(log_dir, log_file_max_id, &role_mgr, true));
replay_thread1.start();
usleep(1000);
ASSERT_EQ(lf_pos, table_mgr.data_len_);
ASSERT_EQ(0, memcmp(table_mgr.log_data_, lf, lf_pos));
table_mgr.is_error_ = true;
table_mgr.cond_.signal();
usleep(1000);
ASSERT_EQ(lf_pos, table_mgr.data_len_);
ASSERT_EQ(0, memcmp(table_mgr.log_data_, lf, lf_pos));
table_mgr.cond_.signal();
replay_thread1.wait();
table_mgr.is_error_ = false;
// test open log file error
ObLogWriter *log_writer2 = new ObLogWriter();
ASSERT_EQ(OB_SUCCESS, log_writer2->init(log_dir, log_file_max_size, sm4t.get_slave_mgr(), 0));
ASSERT_EQ(OB_SUCCESS, log_writer2->start_log(log_file_max_id - 10, log_max_seq));
ASSERT_EQ(OB_SUCCESS, log_writer2->write_log(OB_LOG_UPS_MUTATOR, lf, lf_pos));
ASSERT_EQ(OB_SUCCESS, log_writer2->flush_log());
ASSERT_EQ(OB_SUCCESS, log_writer2->switch_log_file(new_log_file_id));
delete log_writer2;
char cmd[100];
snprintf(cmd, 100, "rm %s/%lu", log_dir, log_file_max_id - 9);
system(cmd);
ObUpsReplayRunnable replay_thread2;
//replay_thread2.ups_main_ = &test_main;
ASSERT_EQ(OB_SUCCESS, replay_thread2.init(log_dir, log_file_max_id - 10, &role_mgr, true));
replay_thread2.start();
usleep(1000);
ASSERT_EQ(lf_pos, table_mgr.data_len_);
ASSERT_EQ(0, memcmp(table_mgr.log_data_, lf, lf_pos));
table_mgr.cond_.signal();
replay_thread2.wait();
}
