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

[FEAT MERGE] 4.x Dup Table

Browse Source 
Co-authored-by: Minionyh <minions.yh@gmail.com>
Co-authored-by: BinChenn <binchenn.bc@gmail.com>
Co-authored-by: ChangerR <dingjinchengyx@163.com>
This commit is contained in:
KyrielightWei
2023-05-11 10:07:20 +00:00
committed by ob-robot
parent 0509c5f9fe
commit aaab6560a1
278 changed files with 20924 additions and 2857 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
unittest/logservice/mock_logservice_container/mock_log_sliding_window.h
View File

@ -16,6 +16,7 @@
#define private public
#include "logservice/palf/log_sliding_window.h"
#include "share/scn.h"
#include "mock_log_state_mgr.h"
#undef private
namespace oceanbase
@ -344,7 +345,13 @@ public:
ack_info.lsn_ = LSN(PALF_INITIAL_LSN_VAL);
return OB_SUCCESS;
}
int get_leader_from_cache(common::ObAddr &leader) const
{
leader = state_mgr_->get_leader();
return OB_SUCCESS;
}
public:
palf::MockLogStateMgr *state_mgr_;
LSN pending_end_lsn_;
int64_t mock_start_id_;
int64_t mock_last_submit_log_id_;

107
unittest/logservice/test_log_config_mgr.cpp
View File

@ -82,6 +82,7 @@ public:
mock_election_->leader_epoch_ = INIT_ELE_EPOCH;
mock_sw_->mock_last_submit_lsn_ = LSN(PALF_INITIAL_LSN_VAL);
mock_sw_->mock_last_submit_pid_ = INIT_PROPOSAL_ID;
mock_sw_->state_mgr_ = mock_state_mgr_;
EXPECT_TRUE(config_info.is_valid());
PALF_LOG(INFO, "init_test_log_config_env", K(role), K(state), K(mock_state_mgr_->leader_), K(mock_state_mgr_->role_));
mock_log_engine_->reset_register_parent_resp_ret();
@ -110,6 +111,41 @@ public:
palf::LogPlugins *mock_plugins_;
};
TEST_F(TestLogConfigMgr, test_set_initial_member_list)
{
LogConfigInfo default_config_info;
common::ObMemberList init_member_list;
GlobalLearnerList learner_list;
LogConfigVersion init_config_version;
init_config_version.generate(1, 1);
init_member_list.add_server(addr1);
init_member_list.add_server(addr2);
EXPECT_EQ(OB_SUCCESS, default_config_info.generate(init_member_list, 3, learner_list, init_config_version));
{
LogConfigMgr cm;
LogConfigVersion config_version;
init_test_log_config_env(addr1, default_config_info, cm);
// arb_member is self
EXPECT_EQ(OB_NOT_SUPPORTED, cm.set_initial_member_list(init_member_list, ObMember(addr1, 0), 3, learner_list, 1, config_version));
// arb_member overlaps with member_list
EXPECT_EQ(OB_INVALID_ARGUMENT, cm.set_initial_member_list(init_member_list, ObMember(addr2, 0), 3, learner_list, 1, config_version));
// arb_member overlaps with learners
learner_list.add_learner(ObMember(addr4, 0));
EXPECT_EQ(OB_INVALID_ARGUMENT, cm.set_initial_member_list(init_member_list, ObMember(addr4, 0), 3, learner_list, 1, config_version));
// learners overlap with member_list
init_member_list.add_server(addr4);
EXPECT_EQ(OB_INVALID_ARGUMENT, cm.set_initial_member_list(init_member_list, ObMember(addr5, 0), 3, learner_list, 1, config_version));
init_member_list.add_server(addr3);
learner_list.reset();
// do not reach majority
EXPECT_EQ(OB_INVALID_ARGUMENT, cm.set_initial_member_list(init_member_list, ObMember(addr5, 0), 3, learner_list, 1, config_version));
EXPECT_EQ(OB_SUCCESS, cm.set_initial_member_list(init_member_list, ObMember(addr5, 0), 4, learner_list, 1, config_version));
}
}
TEST_F(TestLogConfigMgr, test_remove_child_is_not_learner)
{
LogConfigMgr cm;
@ -233,7 +269,7 @@ TEST_F(TestLogConfigMgr, test_apply_config_meta)
GlobalLearnerList learner_list;
LogConfigInfo default_config_info, one_f_one_a_config_info,
two_f_one_a_config_info, four_f_one_a_config_info, five_f_config_info,
four_f_config_info, two_f_config_info;
four_f_config_info, two_f_config_info, three_f_one_learner_config_info;
EXPECT_EQ(OB_SUCCESS, default_config_info.generate(init_member_list, 3, learner_list, init_config_version));
EXPECT_EQ(OB_SUCCESS, one_f_one_a_config_info.generate(one_f_member_list, 1, learner_list, init_config_version));
@ -246,6 +282,9 @@ TEST_F(TestLogConfigMgr, test_apply_config_meta)
EXPECT_EQ(OB_SUCCESS, four_f_config_info.generate(four_f_member_list, 4, learner_list, init_config_version));
EXPECT_EQ(OB_SUCCESS, five_f_config_info.generate(five_f_member_list, 5, learner_list, init_config_version));
three_f_one_learner_config_info = default_config_info;
three_f_one_learner_config_info.learnerlist_.add_learner(ObMember(addr4, -1));
std::vector<LogConfigInfo> config_info_list;
std::vector<LogConfigChangeArgs> arg_list;
std::vector<ObMemberList> expect_member_list;
@ -338,10 +377,9 @@ TEST_F(TestLogConfigMgr, test_apply_config_meta)
// 14. acceptor -> learner
config_info_list.push_back(default_config_info);
arg_list.push_back(LogConfigChangeArgs(ObMember(addr3, -1), 0, SWITCH_ACCEPTOR_TO_LEARNER));
expect_ret_list.push_back(OB_SUCCESS);
expect_ret_list.push_back(OB_INVALID_ARGUMENT);
expect_finished_list.push_back(false);
expect_member_list.push_back(init_member_list);
expect_member_list.back().remove_server(addr3);
// 15. 3F, add_arb_member, replica_num 3
config_info_list.push_back(default_config_info);
arg_list.push_back(LogConfigChangeArgs(ObMember(addr4, -1), 3, palf::ADD_ARB_MEMBER));
@ -564,6 +602,69 @@ TEST_F(TestLogConfigMgr, test_apply_config_meta)
expect_ret_list.push_back(OB_NOT_ALLOW_REMOVING_LEADER);
expect_finished_list.push_back(false);
expect_member_list.push_back(init_member_list);
// 44. acceptor -> learner, invalid replica_num
config_info_list.push_back(default_config_info);
arg_list.push_back(LogConfigChangeArgs(ObMember(addr3, -1), 4, SWITCH_ACCEPTOR_TO_LEARNER));
expect_ret_list.push_back(OB_INVALID_ARGUMENT);
expect_finished_list.push_back(false);
expect_member_list.push_back(init_member_list);
// 45. acceptor -> learner
config_info_list.push_back(default_config_info);
arg_list.push_back(LogConfigChangeArgs(ObMember(addr3, -1), 2, SWITCH_ACCEPTOR_TO_LEARNER));
expect_ret_list.push_back(OB_SUCCESS);
expect_finished_list.push_back(false);
expect_member_list.push_back(init_member_list);
expect_member_list.back().remove_server(addr3);
// 46. acceptor -> learner, member already, but replica_num do not match
config_info_list.push_back(three_f_one_learner_config_info);
arg_list.push_back(LogConfigChangeArgs(ObMember(addr4, -1), 2, SWITCH_ACCEPTOR_TO_LEARNER));
expect_ret_list.push_back(OB_INVALID_ARGUMENT);
expect_finished_list.push_back(false);
expect_member_list.push_back(init_member_list);
// 47. acceptor -> learner, already finish
config_info_list.push_back(three_f_one_learner_config_info);
arg_list.push_back(LogConfigChangeArgs(ObMember(addr4, -1), 3, SWITCH_ACCEPTOR_TO_LEARNER));
expect_ret_list.push_back(OB_SUCCESS);
expect_finished_list.push_back(true);
expect_member_list.push_back(init_member_list);
// 48. learner -> acceptor, invalid replica_num
config_info_list.push_back(three_f_one_learner_config_info);
arg_list.push_back(LogConfigChangeArgs(ObMember(addr4, -1), 0, SWITCH_LEARNER_TO_ACCEPTOR));
expect_ret_list.push_back(OB_INVALID_ARGUMENT);
expect_finished_list.push_back(false);
expect_member_list.push_back(init_member_list);
// 49. learner -> acceptor, invalid replica_num
config_info_list.push_back(three_f_one_learner_config_info);
arg_list.push_back(LogConfigChangeArgs(ObMember(addr4, -1), 3, SWITCH_LEARNER_TO_ACCEPTOR));
expect_ret_list.push_back(OB_INVALID_ARGUMENT);
expect_finished_list.push_back(false);
expect_member_list.push_back(init_member_list);
// 50. learner -> acceptor, invalid member
config_info_list.push_back(three_f_one_learner_config_info);
arg_list.push_back(LogConfigChangeArgs(ObMember(addr5, -1), 3, SWITCH_LEARNER_TO_ACCEPTOR));
expect_ret_list.push_back(OB_INVALID_ARGUMENT);
expect_finished_list.push_back(false);
expect_member_list.push_back(init_member_list);
// 51. learner -> acceptor, already finish
config_info_list.push_back(default_config_info);
arg_list.push_back(LogConfigChangeArgs(ObMember(addr3, -1), 3, SWITCH_LEARNER_TO_ACCEPTOR));
expect_ret_list.push_back(OB_SUCCESS);
expect_finished_list.push_back(true);
expect_member_list.push_back(init_member_list);
// 52. learner -> acceptor, member already exists, but replica_num do not match
config_info_list.push_back(default_config_info);
arg_list.push_back(LogConfigChangeArgs(ObMember(addr3, -1), 4, SWITCH_LEARNER_TO_ACCEPTOR));
expect_ret_list.push_back(OB_INVALID_ARGUMENT);
expect_finished_list.push_back(false);
expect_member_list.push_back(init_member_list);
// 53. learner -> acceptor
config_info_list.push_back(three_f_one_learner_config_info);
arg_list.push_back(LogConfigChangeArgs(ObMember(addr4, -1), 4, SWITCH_LEARNER_TO_ACCEPTOR));
expect_ret_list.push_back(OB_SUCCESS);
expect_finished_list.push_back(false);
expect_member_list.push_back(init_member_list);
expect_member_list.back().add_server(addr4);
for (int i = 0; i < arg_list.size(); ++i) {
PALF_LOG(INFO, "test_check_config_change_args begin case", K(i));
LogConfigMgr cm;

9
unittest/logservice/test_log_meta_info.cpp
View File

@ -138,6 +138,15 @@ TEST(TestLogMetaInfos, test_log_config_meta)
EXPECT_EQ(OB_SUCCESS, curr_config_version.generate(curr_log_proposal_id, curr_config_seq));
EXPECT_EQ(OB_SUCCESS, prev_config_info.generate(prev_member_list, prev_replica_num, prev_learner_list, prev_config_version));
EXPECT_EQ(OB_SUCCESS, curr_config_info.generate(curr_member_list, curr_replica_num, curr_learner_list, curr_config_version));
EXPECT_TRUE(curr_config_info.is_valid());
EXPECT_TRUE(prev_config_info.is_valid());
// test lists overlap
{
LogConfigInfo invalid_info = curr_config_info;
invalid_info.learnerlist_.add_learner(member2);
EXPECT_FALSE(invalid_info.is_valid());
}
// test basic serialization
{

4
unittest/logservice/test_palf_bench.cpp
View File

@ -111,8 +111,8 @@ public:
} else if (OB_FAIL(palf_env_->create(1, handle_))) {
PALF_LOG(ERROR, "palf_env_ create failed", K(ret));
}
EXPECT_EQ(OB_SUCCESS, handle_.set_initial_member_list(member_list, 1));
GlobalLearnerList learner_list;
EXPECT_EQ(OB_SUCCESS, handle_.set_initial_member_list(member_list, 1, learner_list));
while (true) {
ObRole role;

105
unittest/rootserver/test_primary_ls_service.cpp
View File

@ -15,6 +15,7 @@
#include <gmock/gmock.h>
#define private public
#include "rootserver/ob_primary_ls_service.h"
#include "share/ls/ob_ls_operator.h"
namespace oceanbase {
using namespace common;
using namespace share;
@ -261,6 +262,110 @@ TEST_F(TestPrimaryLSService, zone_balance)
ASSERT_EQ(3, count_group_by_zone.at(2));
}
TEST_F(TestPrimaryLSService, LS_FLAG)
{
int ret = OB_SUCCESS;
ObLSFlag flag;
ObLSFlagStr str;
ObLSFlagStr empty_str;
ObLSFlagStr str0("DUPLICATE");
ObLSFlagStr str1("DUPLICATE ");
ObLSFlagStr str2(" DUPLICATE ");
ObLSFlagStr str3("BLOCK_TABLET_IN");
ObLSFlagStr str4("BLOCK_TABLET_IN ");
ObLSFlagStr str5("BLOCK_TABLET_IN|DUPLICATE");
ObLSFlagStr str6("DUPLICATE|BLOCK_TABLET_IN");
ObLSFlagStr str7("BLOCK_TABLET_IN | DUPLICATE");
ObLSFlagStr str8("BLOCK_TABLET_IN,DUPLICATE");
ObLSFlagStr str9("BLOCK_TABLET_IN DUPLICATE");
ret = flag.flag_to_str(str);
ASSERT_EQ(ret, OB_SUCCESS);
ASSERT_EQ(empty_str, str);
ASSERT_EQ(0, flag.flag_);
LOG_INFO("test", K(flag), K(str));
flag.set_block_tablet_in();
ASSERT_EQ(2, flag.flag_);
ret = flag.flag_to_str(str);
ASSERT_EQ(str3, str);
LOG_INFO("test", K(flag), K(str));
flag.clear_block_tablet_in();
ASSERT_EQ(0, flag.flag_);
ret = flag.flag_to_str(str);
ASSERT_EQ(ret, OB_SUCCESS);
ASSERT_EQ(empty_str, str);
LOG_INFO("test", K(flag), K(str));
flag.set_duplicate();
ASSERT_EQ(1, flag.flag_);
ret = flag.flag_to_str(str);
ASSERT_EQ(ret, OB_SUCCESS);
ASSERT_EQ(str0, str);
LOG_INFO("test", K(flag), K(str));
flag.set_block_tablet_in();
ASSERT_EQ(3, flag.flag_);
ret = flag.flag_to_str(str);
ASSERT_EQ(ret, OB_SUCCESS);
ASSERT_EQ(str6, str);
LOG_INFO("test", K(flag), K(str));
flag.clear_block_tablet_in();
ASSERT_EQ(1, flag.flag_);
ret = flag.flag_to_str(str);
ASSERT_EQ(ret, OB_SUCCESS);
ASSERT_EQ(str0, str);
LOG_INFO("test", K(flag), K(str));
ret = flag.str_to_flag(empty_str.str());
ASSERT_EQ(ret, OB_SUCCESS);
ASSERT_EQ(0, flag.flag_);
LOG_INFO("test", K(flag));
ret = flag.str_to_flag(str0.str());
ASSERT_EQ(ret, OB_SUCCESS);
ASSERT_EQ(1, flag.flag_);
LOG_INFO("test", K(flag));
ret = flag.str_to_flag(str1.str());
ASSERT_EQ(OB_ERR_UNEXPECTED, ret);
ret = flag.str_to_flag(str2.str());
ASSERT_EQ(OB_ERR_UNEXPECTED, ret);
ret = flag.str_to_flag(str3.str());
ASSERT_EQ(ret, OB_SUCCESS);
ASSERT_EQ(2, flag.flag_);
LOG_INFO("test", K(flag));
ret = flag.str_to_flag(str4.str());
ASSERT_EQ(OB_ERR_UNEXPECTED, ret);
ret = flag.str_to_flag(str5.str());
ASSERT_EQ(ret, OB_SUCCESS);
ASSERT_EQ(3, flag.flag_);
LOG_INFO("test", K(flag));
ret = flag.str_to_flag(str6.str());
ASSERT_EQ(ret, OB_SUCCESS);
ASSERT_EQ(3, flag.flag_);
LOG_INFO("test", K(flag));
ret = flag.str_to_flag(str7.str());
ASSERT_EQ(OB_ERR_UNEXPECTED, ret);
LOG_INFO("test", K(flag));
ret = flag.str_to_flag(str8.str());
ASSERT_EQ(OB_ERR_UNEXPECTED, ret);
ret = flag.str_to_flag(str9.str());
ASSERT_EQ(OB_ERR_UNEXPECTED, ret);
}
}
}

4
unittest/storage/backup/test_backup_extern_info_mgr.cpp
View File

@ -93,7 +93,6 @@ void TestBackupExternInfoMgr::make_ls_meta_package_(ObBackupLSMetaInfo &ls_meta_
{
ls_meta_info.ls_meta_package_.ls_meta_.tenant_id_ = tenant_id_;
ls_meta_info.ls_meta_package_.ls_meta_.ls_id_ = ls_id_;
ls_meta_info.ls_meta_package_.ls_meta_.replica_type_ = ObReplicaType::REPLICA_TYPE_FULL;
ls_meta_info.ls_meta_package_.ls_meta_.migration_status_ = ObMigrationStatus::OB_MIGRATION_STATUS_NONE;
ls_meta_info.ls_meta_package_.ls_meta_.gc_state_ = LSGCState::NORMAL;
ls_meta_info.ls_meta_package_.ls_meta_.restore_status_ = ObLSRestoreStatus(ObLSRestoreStatus::RESTORE_NONE);
@ -105,7 +104,6 @@ static bool cmp_backup_ls_meta(const ObBackupLSMetaInfo &lhs, const ObBackupLSMe
{
return lhs.ls_meta_package_.ls_meta_.tenant_id_ == rhs.ls_meta_package_.ls_meta_.tenant_id_ &&
lhs.ls_meta_package_.ls_meta_.ls_id_ == rhs.ls_meta_package_.ls_meta_.ls_id_ &&
lhs.ls_meta_package_.ls_meta_.replica_type_ == rhs.ls_meta_package_.ls_meta_.replica_type_ &&
lhs.ls_meta_package_.ls_meta_.migration_status_ == rhs.ls_meta_package_.ls_meta_.migration_status_ &&
lhs.ls_meta_package_.ls_meta_.gc_state_ == rhs.ls_meta_package_.ls_meta_.gc_state_ &&
lhs.ls_meta_package_.ls_meta_.restore_status_ == rhs.ls_meta_package_.ls_meta_.restore_status_ &&
@ -144,4 +142,4 @@ int main(int argc, char **argv)
OB_LOGGER.set_log_level("info");
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
}

38
unittest/storage/mock_ob_log_handler.h
View File

@ -133,17 +133,21 @@ public:
return OB_SUCCESS;
}
int set_initial_member_list(const common::ObMemberList &member_list,
const int64_t paxos_replica_num)
const int64_t paxos_replica_num,
const common::GlobalLearnerList &learner_list)
{
UNUSED(member_list);
UNUSED(paxos_replica_num);
UNUSED(learner_list);
return OB_SUCCESS;
}
int set_initial_member_list(const common::ObMemberList &member_list,
const common::ObMember &arb_replica,
const int64_t paxos_replica_num)
const int64_t paxos_replica_num,
const common::GlobalLearnerList &learner_list)
{
UNUSEDx(member_list, arb_replica, paxos_replica_num);
UNUSED(learner_list);
return OB_SUCCESS;
}
int get_end_scn(share::SCN &scn) const
@ -167,6 +171,13 @@ public:
UNUSED(paxos_replica_num);
return OB_SUCCESS;
}
int get_paxos_member_list_and_learner_list(common::ObMemberList &member_list,
int64_t &paxos_replica_num,
common::GlobalLearnerList &learner_list) const
{
UNUSEDx(member_list, paxos_replica_num, learner_list);
return OB_SUCCESS;
}
int get_max_lsn(palf::LSN &lsn) const
{
UNUSED(lsn);
@ -316,20 +327,29 @@ public:
return ret;
}
int switch_learner_to_acceptor(const common::ObMember &learner,
const int64_t timeout_us)
int replace_learner(const common::ObMember &added_learner,
const common::ObMember &removed_learner,
const int64_t timeout_us)
{
int ret = OB_SUCCESS;
UNUSED(learner);
UNUSED(timeout_us);
UNUSEDx(added_learner, removed_learner, timeout_us);
return ret;
}
int switch_learner_to_acceptor(const common::ObMember &learner,
const int64_t new_replica_num,
const int64_t timeout_us)
{
int ret = OB_SUCCESS;
UNUSEDx(learner, new_replica_num, timeout_us);
return ret;
}
int switch_acceptor_to_learner(const common::ObMember &member,
const int64_t timeout_us)
const int64_t new_replica_num,
const int64_t timeout_us)
{
int ret = OB_SUCCESS;
UNUSED(member);
UNUSED(timeout_us);
UNUSEDx(member, new_replica_num, timeout_us);
return ret;
}
int add_arbitration_member(const common::ObMember &added_member, const int64_t timeout_us)

3
unittest/storage/test_dml_common.h
View File

@ -173,7 +173,8 @@ int TestDmlCommon::create_ls(
ObMemberList member_list;
const int64_t paxos_replica_num = 1;
(void) member_list.add_server(MockTenantModuleEnv::get_instance().self_addr_);
if (OB_FAIL(ls->set_initial_member_list(member_list, paxos_replica_num))) {
GlobalLearnerList learner_list;
if (OB_FAIL(ls->set_initial_member_list(member_list, paxos_replica_num, learner_list))) {
STORAGE_LOG(WARN, "failed to set initial member list", K(ret),
K(member_list), K(paxos_replica_num));
}

1
unittest/storage/test_meta_pointer_map.cpp
View File

@ -102,7 +102,6 @@ void TestMetaPointerMap::FakeLs(ObLS &ls)
ls.ls_meta_.gc_state_ = logservice::LSGCState::NORMAL;
ls.ls_meta_.migration_status_ = ObMigrationStatus::OB_MIGRATION_STATUS_NONE;
ls.ls_meta_.restore_status_ = ObLSRestoreStatus::RESTORE_NONE;
ls.ls_meta_.replica_type_ = ObReplicaType::REPLICA_TYPE_FULL;
ls.ls_meta_.rebuild_seq_ = 0;
}

2
unittest/storage/tx/CMakeLists.txt
View File

@ -42,3 +42,5 @@ storage_unittest(test_ob_tx_msg)
storage_unittest(test_ob_id_meta)
storage_unittest(test_ob_standby_read)
add_subdirectory(it)
storage_unittest(test_dup_table_lease)

7
unittest/storage/tx/ob_mock_tx_ctx.cpp
View File

@ -123,6 +123,13 @@ int MockObTxCtx::submit_log(const ObTwoPhaseCommitLogType& log_type)
return OB_SUCCESS;
}
int ObPartTransCtx::search_unsubmitted_dup_table_redo_()
{
int ret = OB_SUCCESS;
return ret;
}
int MockObTxCtx::register_timeout_task_(const int64_t interval_us)
{
return OB_SUCCESS;

126
unittest/storage/tx/ob_mock_tx_log_adapter.cpp
View File

@ -13,12 +13,15 @@
#include "ob_mock_tx_log_adapter.h"
#include "logservice/ob_log_handler.h"
#include "storage/tx/ob_trans_submit_log_cb.h"
#include "logservice/ob_log_base_type.h"
namespace oceanbase {
namespace oceanbase
{
using namespace palf;
using namespace logservice;
namespace transaction {
namespace transaction
{
int MockTxLogAdapter::init(ObITxLogParam *param)
{
int ret = OB_SUCCESS;
@ -158,7 +161,7 @@ bool MockTxLogAdapter::is_cbs_finish_()
return waiting_cbs_.empty();
}
void MockTxLogAdapter::push_all_cbs_()
void MockTxLogAdapter::invoke_all_cbs()
{
ObSpinLockGuard cbs_guard(cbs_lock_);
@ -193,10 +196,127 @@ bool MockTxLogAdapter::get_log(int64_t log_ts, std::string &log_string)
return has_log;
}
int MockTxLogAdapter::get_next_log(int64_t log_ts, std::string &log_string, int64_t &next_log_ts)
{
int ret = OB_SUCCESS;
ObSpinLockGuard file_guard(log_file_lock_);
std::map<int64_t, std::string>::iterator file_iter = mock_log_file_.find(log_ts);
if (file_iter == mock_log_file_.end()) {
file_iter = mock_log_file_.begin();
}
file_iter++;
if (file_iter == mock_log_file_.end()) {
ret = OB_HASH_NOT_EXIST;
} else {
log_string = file_iter->second;
next_log_ts = file_iter->first;
}
return ret;
}
int64_t MockTxLogAdapter::get_cb_cnt()
{
return ATOMIC_LOAD(&CB_CNT_);
}
// int MockReplayMgr::init(MockTxLogAdapter * log_adapter)
// {
// int ret = OB_SUCCESS;
//
// log_adapter_ptr_ = log_adapter;
//
// return ret;
// }
//
// int MockReplayMgr::start()
// {
// int ret = OB_SUCCESS;
//
// ret = lib::ThreadPool::start();
//
// return ret;
// }
//
// void MockReplayMgr::stop()
// {
// lib::ThreadPool::stop();
// }
//
// void MockReplayMgr::wait()
// {
// lib::ThreadPool::wait();
// }
//
// void MockReplayMgr::destroy()
// {
// lib::ThreadPool::destroy();
// }
//
// void MockReplayMgr::run1()
// {
// int ret = OB_SUCCESS;
// int64_t cur_time = 0;
// int64_t time_used = 0;
// std::string tmp_log_string;
//
// palf::LSN tmp_lsn;
// while (!has_set_stop()) {
// cur_time = ObTimeUtility::current_time();
//
// for (auto iter = replay_target_list_.begin(); iter != replay_target_list_.end(); iter++) {
//
// while (OB_SUCC(log_adapter_ptr_->get_next_log(iter->replay_success_ts_, iter->replaying_log_,
// iter->replaying_ts_))) {
//
// if (OB_FAIL(iter->replay_target_->replay(tmp_log_string.c_str(), tmp_log_string.size(),
// tmp_lsn, iter->replaying_ts_))) {
// TRANS_LOG(WARN, "replay one log error", KP(iter->replay_target_), K(iter->replaying_ts_));
// } else {
// iter->replay_success_ts_ = iter->replaying_ts_;
// }
// }
//
// if (ret != OB_HASH_NOT_EXIST) {
// TRANS_LOG(WARN, "replay error", K(ret), K(iter->replay_success_ts_),
// K(iter->replaying_ts_));
// }
// }
// time_used = ObTimeUtility::current_time() - cur_time;
// if (time_used < log_adapter_ptr_->get_cb_time()) {
// usleep(log_adapter_ptr_->get_cb_time() - time_used);
// }
// }
// }
//
// void MockReplayMgr::register_replay_target(logservice::ObIReplaySubHandler *replay_target)
// {
// MockReplayInfo tmp_replay_info;
// tmp_replay_info.replay_target_ = replay_target;
//
// replay_target_list_.push_back(tmp_replay_info);
//
// }
//
// void MockReplayMgr::unregister_replay_target(logservice::ObIReplaySubHandler *replay_target)
// {
// auto iter = replay_target_list_.begin();
// for (; iter != replay_target_list_.end(); iter++) {
//
// if (iter->replay_target_ == replay_target) {
// break;
// }
// }
//
// if (iter != replay_target_list_.end()) {
// replay_target_list_.erase(iter);
// }
// }
} // namespace transaction
} // namespace oceanbase

65
unittest/storage/tx/ob_mock_tx_log_adapter.h
View File

@ -28,6 +28,11 @@
namespace oceanbase
{
namespace logservice
{
class ObIReplaySubHandler;
}
namespace transaction
{
@ -55,8 +60,9 @@ public:
void wait();
void destroy();
int push(void * task);
void handle(void * task);
int push(void *task);
void handle(void *task);
public:
int submit_log(const char *buf,
const int64_t size,
@ -70,10 +76,13 @@ public:
return OB_SUCCESS;
}
void push_all_cbs_();
void invoke_all_cbs();
public:
bool get_log(int64_t log_ts ,std::string &log_string);
bool get_log(int64_t log_ts, std::string &log_string);
int get_next_log(int64_t log_ts, std::string &log_string, int64_t &next_log_ts);
int64_t get_cb_cnt();
int64_t get_cb_time() { return submit_config_.cb_time_; }
private:
bool is_cbs_finish_();
@ -91,14 +100,15 @@ private:
// common::ObSEArray<logservice::AppendCb *, 10, TransModulePageAllocator> waiting_cbs_;
std::map<int64_t,std::string> mock_log_file_; //ts , log record
std::list<logservice::AppendCb *> waiting_cbs_;
ObTransTimer timer_;
ObITimeoutTask * task_ptr_;
ObITimeoutTask *task_ptr_;
int64_t CB_CNT_;
};
class MockCbTimeoutTask : public ObITimeoutTask {
class MockCbTimeoutTask : public ObITimeoutTask
{
public:
MockCbTimeoutTask() : adapter_(nullptr) {}
virtual ~MockCbTimeoutTask() {}
@ -111,12 +121,51 @@ public:
void reset() { adapter_ = nullptr; }
public:
void runTimerTask() { adapter_->push_all_cbs_(); }
void runTimerTask() { adapter_->invoke_all_cbs(); }
uint64_t hash() const { return 1; };
private:
MockTxLogAdapter *adapter_;
};
// struct MockReplayInfo
// {
// logservice::ObIReplaySubHandler *replay_target_;
//
// int64_t replay_success_ts_;
// int64_t replaying_ts_;
// std::string replaying_log_;
//
// void reset()
// {
// replay_target_ = nullptr;
// replay_success_ts_ = -1;
// replaying_ts_ = -1;
// replaying_log_.clear();
// }
//
// MockReplayInfo() { reset(); }
// };
//
// class MockReplayMgr : public lib::ThreadPool
// {
// public:
// int init(MockTxLogAdapter * log_adapter);
// int start();
// void stop();
// void wait();
// void destroy();
//
// virtual void run1();
//
// void register_replay_target(logservice::ObIReplaySubHandler *replay_target);
// void unregister_replay_target(logservice::ObIReplaySubHandler *replay_target);
//
// private:
// MockTxLogAdapter * log_adapter_ptr_;
// std::list<MockReplayInfo> replay_target_list_;
// };
// class TestTxLogSubmitter : public ObSimpleThreadPool
// {
// public:

49
unittest/storage/tx/test_dup_table_lease.cpp Normal file
View File

@ -0,0 +1,49 @@
// Copyright (c) 2021 OceanBase
// OceanBase is licensed under Mulan PubL v2.
// You can use this software according to the terms and conditions of the Mulan PubL v2.
// You may obtain a copy of Mulan PubL v2 at:
// http://license.coscl.org.cn/MulanPubL-2.0
// THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
// EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
// MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
// See the Mulan PubL v2 for more details.
#include <gtest/gtest.h>
// #include "ob_mock_dup_table_ls_mgr.h"
#include "storage/tx/ob_dup_table_lease.h"
namespace oceanbase
{
namespace unittest
{
class TestDupTableLease : public ::testing::Test
{
public:
virtual void SetUp() {}
virtual void TearDown() {}
public:
};
TEST_F(TestDupTableLease, test_dup_table_lease_log)
{
}
}
} // namespace oceanbase
using namespace oceanbase;
int main(int argc, char **argv)
{
int ret = 1;
ObLogger &logger = ObLogger::get_logger();
logger.set_file_name("test_dup_table_lease.log", true);
logger.set_log_level(OB_LOG_LEVEL_INFO);
testing::InitGoogleTest(&argc, argv);
ret = RUN_ALL_TESTS();
return ret;
}

6
unittest/storage/tx_table/test_tx_ctx_table.cpp
View File

@ -110,7 +110,8 @@ public:
protected:
virtual void SetUp() override
{
ObTxPalfParam palf_param((logservice::ObLogHandler *)(0x01));
ObTxPalfParam palf_param((logservice::ObLogHandler *)(0x01),
(transaction::ObDupTableLSHandler *)(0x02));
freezer_.init(&ls_);
EXPECT_EQ(OB_SUCCESS, t3m_.init());
EXPECT_EQ(OB_SUCCESS,
@ -275,7 +276,8 @@ TEST_F(TestTxCtxTable, test_tx_ctx_memtable_mgr)
attr.tenant_id_ = MTL_ID();
tx_data_table.slice_allocator_.init(sizeof(ObTxData), OB_MALLOC_NORMAL_BLOCK_SIZE, common::default_blk_alloc, attr);
ObTxPalfParam palf_param((logservice::ObLogHandler *)(0x01));
ObTxPalfParam palf_param((logservice::ObLogHandler *)(0x01),
(transaction::ObDupTableLSHandler *)(0x02));
ObTxCtxTableRecoverHelperUT recover_helper;
ObLSTxCtxMgr* ls_tx_ctx_mgr_recover = &unittest::TestTxCtxTable::ls_tx_ctx_mgr2_;