TEST(ObRootServer2LogTest, do_server_down)
{
int32_t port = 1001;
ObServer server(ObServer::IPV4, "10.10.10.1", port);
int32_t status = 1;
int64_t ts = 123456;
ObRootServer2 master;
ObRootWorkerForTest master_worker;
ASSERT_TRUE(master.init("./root_server.conf", 100, &master_worker));
ObRootServer2 slave;
ObRootWorkerForTest slave_worker;
ASSERT_TRUE(slave.init("./root_server.conf", 100, &slave_worker));
ObRootServerTester wrapper(&slave);
wrapper.stop_thread();
int ret = master.regist_server(server, false, status, ts);
ASSERT_EQ(OB_SUCCESS, ret);
ObRootLogWorker log_worker = wrapper.get_log_worker();
log_worker.do_cs_regist(server, ts); // up server
ObChunkServerManager& server_manager = wrapper.get_server_manager();
ObChunkServerManager::iterator it = server_manager.find_by_ip(server);
ASSERT_TRUE(it != server_manager.end());
ASSERT_NE(ObServerStatus::STATUS_DEAD, it->status_);
log_worker.do_server_down(server, ts); // down server
it = server_manager.find_by_ip(server);
ASSERT_TRUE(it != server_manager.end());
ASSERT_EQ(ObServerStatus::STATUS_DEAD, it->status_);
}
TEST(ObRootServer2Test2, migrate_over2_1)
{
MigrateTestEnv env;
env.setup();
ObRootServer2* rs = env.worker_.get_root_server();
ObRootServerTester tester(rs);
ObChunkServerManager& csmgr = tester.get_server_manager();
ObRootTable2* roottable = tester.get_root_table_for_query();
/// case 1
// 4. target cs2 down
ObChunkServerManager::iterator it = csmgr.find_by_ip(env.cs2_);
ASSERT_TRUE(csmgr.end() != it);
csmgr.set_server_down(it);
int64_t now = tbsys::CTimeUtil::getTime();
roottable->server_off_line(it - csmgr.begin(), now);
// 5. report migrate over
rs->migrate_over(env.info1_.range_, env.cs1_, env.cs2_, true, env.tablet_version_);
// 6. verify
ObRootTable2::const_iterator it1, it2;
ASSERT_EQ(OB_SUCCESS, roottable->find_range(env.info1_.range_, it1, it2));
ASSERT_EQ(it1, it2);
ASSERT_EQ(0, it1->server_info_indexes_[0]);
ASSERT_EQ(OB_INVALID_INDEX, it1->server_info_indexes_[1]);
ASSERT_EQ(OB_INVALID_INDEX, it1->server_info_indexes_[2]);
rs->stop_threads();
}
void MigrateTestEnv::setup()
{
// 1. init
ObRootServer2* rs = worker_.get_root_server();
ASSERT_TRUE(rs->init("./root_server.conf", 100, &worker_));
rs->start_threads();
sleep(1);
// 2. cs register
int status;
ASSERT_EQ(OB_SUCCESS, rs->regist_server(cs1_, false, status));
ASSERT_EQ(OB_SUCCESS, rs->regist_server(cs2_, false, status));
// 3. cs1 report tablets replicas
ObTabletReportInfoList report_list1;
ObTabletReportInfoList report_list2;
ObTabletReportInfo report_info;
ObTabletLocation location;
location.tablet_version_ = tablet_version_;
info1_.range_.table_id_ = 10001;
info1_.range_.border_flag_.set_inclusive_end();
info1_.range_.border_flag_.unset_inclusive_start();
info1_.range_.border_flag_.set_min_value();
info1_.range_.border_flag_.unset_max_value();
info1_.range_.start_key_.assign_buffer(buf1[0], 30);
info1_.range_.end_key_.assign_buffer(buf2[0], 30);
info1_.range_.start_key_.write("aa1", 3);
info1_.range_.end_key_.write("ba1", 3);
location.chunkserver_ = cs1_;
report_info.tablet_info_ = info1_;
report_info.tablet_location_ = location;
report_list1.add_tablet(report_info);
info1_.range_.border_flag_.unset_min_value();
info1_.range_.border_flag_.set_max_value();
info1_.range_.start_key_.assign_buffer(buf1[1], 30);
info1_.range_.end_key_.assign_buffer(buf2[1], 30);
info1_.range_.start_key_.write("ba1", 3);
info1_.range_.end_key_.write("ca1", 3);
report_info.tablet_info_ = info1_;
report_info.tablet_location_ = location;
report_list1.add_tablet(report_info);
int64_t now = tbsys::CTimeUtil::getTime();
ASSERT_EQ(OB_SUCCESS, rs->report_tablets(cs1_, report_list1, now));
ASSERT_EQ(OB_SUCCESS, rs->report_tablets(cs2_, report_list2, now));
// wait init finish
sleep(5);
}
TEST(ObRootServer2LogTest, begin_balance)
{
ObRootServer2 server;
ObRootWorkerForTest worker;
ASSERT_TRUE(server.init("./root_server.conf", 100, &worker));
ObRootServerTester wrapper(&server);
wrapper.stop_thread();
ASSERT_NE(ObRootServer2::STATUS_BALANCING, wrapper.get_server_status());
wrapper.get_log_worker().do_begin_balance();
ASSERT_EQ(ObRootServer2::STATUS_BALANCING, wrapper.get_server_status());
}
TEST(ObRootServer2LogTest, us_unload_done)
{
ObRootServer2 server;
ObRootWorkerForTest worker;
ASSERT_TRUE(server.init("./root_server.conf", 100, &worker));
ObRootServerTester wrapper(&server);
wrapper.stop_thread();
ObServerStatus* us = wrapper.get_update_server();
us->status_ = ObServerStatus::STATUS_REPORTED;
wrapper.get_log_worker().do_us_unload_done(us->server_);
ASSERT_EQ(ObServerStatus::STATUS_SERVING, us->status_);
}
TEST(ObRootServer2LogTest, us_schema_changed)
{
ObRootServer2 server;
ObRootWorkerForTest worker;
ASSERT_TRUE(server.init("./root_server.conf", 100, &worker));
ObRootServerTester wrapper(&server);
wrapper.stop_thread();
ObServerStatus* us = wrapper.get_update_server();
us->status_ = ObServerStatus::STATUS_REPORTING;
wrapper.get_log_worker().do_us_mem_frozen(us->server_, 0);
ASSERT_EQ(ObServerStatus::STATUS_REPORTED, us->status_);
}
//TEST(ObRootServer2LogTest, start_report)
//{
// ObRootServer2 master;
// ObRootWorkerForTest master_worker;
// ASSERT_TRUE(master.init("./root_server.conf", 100, &master_worker));
// ObRootServerTester master_wrapper(&master);
// master_wrapper.stop_thread();
//
// ObRootServer2 slave;
// ObRootWorkerForTest slave_worker;
// ASSERT_TRUE(slave.init("./root_server.conf", 100, &slave_worker));
// ObRootServerTester slave_wrapper(&slave);
// slave_wrapper.stop_thread();
//
// master_wrapper.set_master(true);
// master_wrapper.stop_thread();
// slave_wrapper.stop_thread();
//
// TBSYS_LOG(DEBUG, "Server status: %d", master_wrapper.get_server_status());
// bool ret = master.start_report(true);
// TBSYS_LOG(DEBUG, "Server status: %d", master_wrapper.get_server_status());
// ASSERT_TRUE(ret);
// TBSYS_LOG(DEBUG, "master start switch done");
//
// int64_t ts = master.get_time_stamp_changing();
//
// ObRootLogWorker log_worker = slave_wrapper.get_log_worker();
// log_worker.do_start_report(ts, true);
// TBSYS_LOG(DEBUG, "slave start switch done");
//
// int64_t slave_ts = slave.get_time_stamp_changing();
//
// ASSERT_EQ(ts, slave_ts);
// ASSERT_EQ(master_wrapper.get_server_status(), slave_wrapper.get_server_status());
//}
//
TEST(ObRootServer2LogTest, create_table_done)
{
ObRootServer2 server;
ObRootWorkerForTest worker;
ASSERT_TRUE(server.init("./root_server.conf", 100, &worker));
ObRootServerTester wrapper(&server);
wrapper.stop_thread();
ASSERT_FALSE(wrapper.get_create_table_done());
wrapper.get_log_worker().do_create_table_done();
ASSERT_TRUE(wrapper.get_create_table_done());
}
void ObDeleteReplicasTest::heartbeat_cs(int32_t cs_num)
{
for (int i = 0; i < cs_num; ++i)
{
ASSERT_EQ(OB_SUCCESS, server_->receive_hb(get_addr(i), 0, false, OB_CHUNKSERVER));
}
}
void ObBalanceTest::heartbeat_cs(int32_t cs_num)
{
for (int i = 0; i < cs_num; ++i)
{
ASSERT_EQ(OB_SUCCESS, server_->receive_hb(get_addr(i), OB_CHUNKSERVER));
}
}
void ObDeleteReplicasTest::register_cs(int32_t cs_num)
{
for (int i = 0; i < cs_num; ++i)
{
int32_t status = 0;
ASSERT_EQ(OB_SUCCESS, server_->regist_chunk_server(get_addr(i), "0.4.1.2", status));
TBSYS_LOG(INFO, "register cs, id=%d status=%d", i, status);
}
}
void ObBalanceTest::register_cs(int32_t cs_num)
{
for (int i = 0; i < cs_num; ++i)
{
int32_t status = 0;
ASSERT_EQ(OB_SUCCESS, server_->regist_server(get_addr(i), false, status));
TBSYS_LOG(INFO, "register cs, id=%d status=%d", i, status);
}
}
TEST(ObRootServer2LogTest, do_cs_regist)
{
int32_t port = 1001;
ObServer server(ObServer::IPV4, "10.10.10.1", port);
int32_t status = 1;
int64_t ts = 123456;
ObRootServer2 master;
ObRootWorkerForTest master_worker;
ASSERT_TRUE(master.init("./root_server.conf", 100, &master_worker));
ObRootServerTester master_wrapper(&master);
master_wrapper.stop_thread();
ObRootServer2 slave;
ObRootWorkerForTest slave_worker;
ASSERT_TRUE(slave.init("./root_server.conf", 100, &slave_worker));
ObRootServerTester slave_wrapper(&slave);
slave_wrapper.stop_thread();
int ret = master.regist_server(server, false, status, ts);
ASSERT_EQ(OB_SUCCESS, ret);
ObRootLogWorker log_worker = slave_wrapper.get_log_worker();
log_worker.do_cs_regist(server, ts);
ObChunkServerManager& master_server_manager = master_wrapper.get_server_manager();
ObChunkServerManager::iterator it = master_server_manager.find_by_ip(server);
ASSERT_TRUE(it != master_server_manager.end());
int64_t master_hb = it->last_hb_time_;
int32_t master_port = it->port_cs_;
ObChunkServerManager& slave_server_manager = slave_wrapper.get_server_manager();
it = slave_server_manager.find_by_ip(server);
ASSERT_TRUE(it != slave_server_manager.end());
int64_t slave_hb = it->last_hb_time_;
int32_t slave_port = it->port_cs_;
ASSERT_EQ(ts, master_hb);
ASSERT_EQ(port, master_port);
ASSERT_EQ(master_hb, slave_hb);
ASSERT_EQ(master_port, slave_port);
}
void ObBalanceTest::TearDown()
{
sleep(1);
worker_.get_test_stub().stop();
worker_.get_test_stub().wait();
server_->stop_threads();
// test after balance thread stopped
ASSERT_EQ(0, worker_.get_test_stub().get_migrate_msg_count());
ASSERT_TRUE(server_->balancer_->nb_is_all_tables_balanced(balance_except_cs_));
}
TEST(ObRootServer2LogTest, cs_schema_changing)
{
int32_t port = 1001;
ObServer server(ObServer::IPV4, "10.10.10.1", port);
int64_t ts = 123456;
ObRootServer2 root;
ObRootWorkerForTest worker;
ASSERT_TRUE(root.init("./root_server.conf", 100, &worker));
ObRootServerTester wrapper(&root);
wrapper.stop_thread();
wrapper.get_log_worker().do_cs_regist(server, ts);
ObChunkServerManager& slave_server_manager = wrapper.get_server_manager();
ObChunkServerManager::iterator it = slave_server_manager.find_by_ip(server);
ASSERT_TRUE(it != slave_server_manager.end());
it->status_ = ObServerStatus::STATUS_SERVING;
wrapper.get_log_worker().do_cs_start_merging(it->server_);
ASSERT_EQ(ObServerStatus::STATUS_REPORTING, it->status_);
}
void ObBalanceTest::SetUp()
{
server_ = worker_.get_root_server();
worker_.set_config_file_name("ob_new_balance_test.conf");
ASSERT_EQ(OB_SUCCESS, worker_.initialize());
server_->config_.flag_migrate_wait_seconds_.set(20);
server_->config_.flag_enable_rereplication_.set(0); // disable
server_->start_threads();
sleep(1);
worker_.get_role_manager()->set_role(ObRoleMgr::STANDALONE); // for testing
worker_.get_test_stub().set_server(server_);
worker_.get_test_stub().start();
}
void ObDeleteReplicasTest::SetUp()
{
server_ = worker_.get_root_server();
common::ObSystemConfig sys_config;
sys_config.init();
//worker_.set_config_file_name("ob_delete_replicas_test.conf");
worker_.rs_config_.init(sys_config);
worker_.rs_config_.port = 1110;
worker_.rs_config_.io_thread_count = 2;
worker_.create_eio();
worker_.rs_config_.read_queue_size = 2;
worker_.rs_config_.root_server_ip.set_value("10.232.35.40");
worker_.rs_config_.schema_filename.set_value("ob_delete_replicas_test_schema.ini");
ASSERT_EQ(OB_SUCCESS, worker_.initialize());
worker_.get_role_manager()->set_role(ObRoleMgr::STANDALONE); // for testing
server_->start_threads();
sleep(5);
}
TEST(ObRootServer2LogTest, do_load_report)
{
int32_t port = 1001;
ObServer server(ObServer::IPV4, "10.10.10.1", port);
int32_t status = 1;
int64_t ts = 123456;
int64_t cap = 12345;
int64_t used = 1234;
ObRootServer2 master;
ObRootWorkerForTest master_worker;
ASSERT_TRUE(master.init("./root_server.conf", 100, &master_worker));
ObRootServerTester master_wrapper(&master);
master_wrapper.stop_thread();
ObRootServer2 slave;
ObRootWorkerForTest slave_worker;
ASSERT_TRUE(slave.init("./root_server.conf", 100, &slave_worker));
ObRootServerTester slave_wrapper(&slave);
slave_wrapper.stop_thread();
int ret = master.regist_server(server, false, status, ts);
ASSERT_EQ(OB_SUCCESS, ret);
ret = master.update_capacity_info(server, cap, used);
ASSERT_EQ(OB_SUCCESS, ret);
ObRootLogWorker log_worker = slave_wrapper.get_log_worker();
log_worker.do_cs_regist(server, ts);
log_worker.do_cs_load_report(server, cap, used);
ObChunkServerManager& master_server_manager = master_wrapper.get_server_manager();
ObChunkServerManager::iterator it = master_server_manager.find_by_ip(server);
ASSERT_TRUE(it != master_server_manager.end());
int64_t master_cap = it->disk_info_.get_capacity();
int32_t master_used = it->disk_info_.get_used();
ObChunkServerManager& slave_server_manager = slave_wrapper.get_server_manager();
it = slave_server_manager.find_by_ip(server);
ASSERT_TRUE(it != slave_server_manager.end());
int64_t slave_cap = it->disk_info_.get_capacity();
int32_t slave_used = it->disk_info_.get_used();
ASSERT_EQ(cap, master_cap);
ASSERT_EQ(used, master_used);
ASSERT_EQ(master_cap, slave_cap);
ASSERT_EQ(master_used, slave_used);
}
void BalanceTestRpc::run(tbsys::CThread *thread, void *arg)
{
UNUSED(thread);
UNUSED(arg);
TBSYS_LOG(INFO, "balance test rpc thread begin");
while(!_stop)
{
TBSYS_LOG(DEBUG, "balance test rpc thread running");
MigrateMsg *msg = NULL;
int ret = pop_migrate_msg(msg);
if (OB_SUCCESS == ret)
{
assert(server_);
if (blocked_cs_ == msg->src_cs_)
{
char addr_buf1[OB_IP_STR_BUFF];
blocked_cs_.to_string(addr_buf1, OB_IP_STR_BUFF);
TBSYS_LOG(DEBUG, "drop migrate msg, src_cs=%s", addr_buf1);
}
else if (blocked_dest_cs_ == msg->dest_cs_)
{
char addr_buf1[OB_IP_STR_BUFF];
blocked_dest_cs_.to_string(addr_buf1, OB_IP_STR_BUFF);
TBSYS_LOG(DEBUG, "drop migrate msg, dest_cs=%s", addr_buf1);
}
else
{
server_->migrate_over(msg->range_, msg->src_cs_, msg->dest_cs_, msg->keep_src_, 2);
}
delete_migrate_msg(msg);
}
else
{
usleep(500*1000);
}
}
TBSYS_LOG(INFO, "balance test rpc thread finished");
}
TEST(ObRootServer2LogTest, start_switch)
{
ObRootServer2 master;
ObRootWorkerForTest master_worker;
ASSERT_TRUE(master.init("./root_server.conf", 100, &master_worker));
ObRootServerTester master_wrapper(&master);
master_wrapper.stop_thread();
ObRootServer2 slave;
ObRootWorkerForTest slave_worker;
ASSERT_TRUE(slave.init("./root_server.conf", 100, &slave_worker));
ObRootServerTester slave_wrapper(&slave);
slave_wrapper.stop_thread();
master_wrapper.set_master(true);
master_wrapper.stop_thread();
slave_wrapper.stop_thread();
slave_wrapper.set_master(false);
TBSYS_LOG(DEBUG, "Server status: %d", master_wrapper.get_server_status());
bool ret = master.start_switch();
TBSYS_LOG(DEBUG, "Server status: %d", master_wrapper.get_server_status());
ASSERT_TRUE(ret);
TBSYS_LOG(DEBUG, "master start switch done");
int64_t ts = master.get_time_stamp_changing();
ObRootLogWorker log_worker = slave_wrapper.get_log_worker();
log_worker.do_start_report(ts, true);
log_worker.do_start_switch(ts);
TBSYS_LOG(DEBUG, "slave start switch done");
int64_t slave_ts = slave.get_time_stamp_changing();
ASSERT_EQ(ts, slave_ts);
ASSERT_EQ(master_wrapper.get_server_status(), slave_wrapper.get_server_status());
}
void ObDeleteReplicasTest::TearDown()
{
server_->stop_threads();
}
// 每个tablet两个复本，每个CS上均匀分布
void ObBalanceTest::report_tablets_2replicas(BalanceTestParams ¶ms)
{
ObTabletReportInfoList* report_lists = new (std::nothrow) ObTabletReportInfoList[params.cs_num_];
ASSERT_TRUE(NULL != report_lists);
int64_t *tablets_per_cs = new(std::nothrow) int64_t[params.cs_num_];
ASSERT_TRUE(NULL != tablets_per_cs);
ObTabletReportInfo tablet;
for (int i = 0; i < params.table_num_; ++i)
{
int32_t sstables_count = params.sstables_per_table_[i];
TBSYS_LOG(INFO, "table_id=%lu sstables=%d\n", get_table_id(i), sstables_count);
for (int j = 0; j < params.cs_num_; ++j)
{
TBSYS_LOG(INFO, "sstables dist per cs, %d", params.sstables_dist[i][j]);
reset_report_info_list(report_lists[j]);
tablets_per_cs[j] = 0;
}
int k = 0;
for (int j = 0; j < sstables_count; ++j)
{
int replicas = 0;
while (replicas < 2)
{
if (0 < params.sstables_dist[i][k])
{
get_report_tablet(tablet, sstables_count, i, j, k, params.sstable_size_);
int ret2 = report_lists[k].add_tablet(tablet);
if (OB_ARRAY_OUT_OF_RANGE == ret2)
{
// report
int ret = server_->report_tablets(get_addr(k), report_lists[k], 1);
ASSERT_EQ(OB_SUCCESS, ret);
TBSYS_LOG(INFO, "report tablets, cs=%d count=%ld", k, report_lists[k].get_tablet_size());
reset_report_info_list(report_lists[k]);
ret2 = report_lists[k].add_tablet(tablet);
}
ASSERT_EQ(OB_SUCCESS, ret2);
tablets_per_cs[k]++;
++replicas;
}
k++;
if (k >= params.cs_num_)
{
k = 0;
}
}
}
for (int k = 0; k < params.cs_num_; ++k)
{
if (0 < report_lists[k].get_tablet_size())
{
int ret = server_->report_tablets(get_addr(k), report_lists[k], 1);
ASSERT_EQ(OB_SUCCESS, ret);
TBSYS_LOG(INFO, "report tablets, cs=%d count=%ld", k, report_lists[k].get_tablet_size());
}
}
for (int k = 0; k < params.cs_num_; ++k)
{
TBSYS_LOG(INFO, "reported tablets, table=%lu cs_idx=%d tablets=%ld",
get_table_id(i), k, tablets_per_cs[k]);
}
} // end for each table
if (NULL != tablets_per_cs)
{
delete [] tablets_per_cs;
tablets_per_cs = NULL;
}
if (NULL != report_lists)
{
delete [] report_lists;
}
}
