[CP] [4.3] fix create user log stream problem with 2F1A and 4F1A
This commit is contained in:
joseph12138
ob-robot
parent
117d360abf
commit
3de36acfcd
@ -349,13 +349,30 @@ int ObSimpleLogClusterTestEnv::create_paxos_group_with_arb(
|
||||
int64_t &leader_idx,
|
||||
const bool with_mock_election,
|
||||
PalfHandleImplGuard &leader)
|
||||
{
|
||||
// if member_cnt_ is 3, arb_replica_idx should be 0,1,2
|
||||
const ObMemberList member_list = get_member_list();
|
||||
const int64_t member_cnt = get_member_cnt();
|
||||
ObMember arb_member;
|
||||
return create_paxos_group_with_arb(id, loc_cb, member_list, member_cnt, arb_member, arb_replica_idx, leader_idx, with_mock_election, leader);
|
||||
}
|
||||
|
||||
// member_list and member_cnt contain arb member
|
||||
int ObSimpleLogClusterTestEnv::create_paxos_group_with_arb(
|
||||
const int64_t id,
|
||||
palf::PalfLocationCacheCb *loc_cb,
|
||||
ObMemberList member_list,
|
||||
int64_t member_cnt,
|
||||
ObMember arb_member,
|
||||
int64_t &arb_replica_idx,
|
||||
int64_t &leader_idx,
|
||||
const bool with_mock_election,
|
||||
PalfHandleImplGuard &leader)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
PalfBaseInfo palf_base_info;
|
||||
palf_base_info.generate_by_default();
|
||||
// if member_cnt_ is 3, arb_replica_idx should be 0,1,2
|
||||
ObMemberList member_list = get_member_list();
|
||||
ObMember arb_replica;
|
||||
ObMember arb_replica = arb_member;
|
||||
GlobalLearnerList learner_list;
|
||||
arb_replica_idx = 2;
|
||||
for (int i = 0; i < get_cluster().size(); i++) {
|
||||
@ -367,7 +384,8 @@ int ObSimpleLogClusterTestEnv::create_paxos_group_with_arb(
|
||||
if (-1 == arb_replica_idx) {
|
||||
ret = OB_NOT_SUPPORTED;
|
||||
PALF_LOG(ERROR, "there is not any arb server");
|
||||
} else if (OB_FAIL(member_list.get_member_by_index(arb_replica_idx, arb_replica))) {
|
||||
} else if (false == arb_replica.is_valid() &&
|
||||
OB_FAIL(member_list.get_member_by_index(arb_replica_idx, arb_replica))) {
|
||||
PALF_LOG(ERROR, "get_member_by_index failed", K(ret), K(arb_replica_idx));
|
||||
} else {
|
||||
member_list.remove_member(arb_replica);
|
||||
@ -382,7 +400,7 @@ int ObSimpleLogClusterTestEnv::create_paxos_group_with_arb(
|
||||
break;
|
||||
} else if (OB_FAIL(svr->get_palf_env()->create_palf_handle_impl(id, palf::AccessMode::APPEND, palf_base_info, handle))) {
|
||||
CLOG_LOG(WARN, "create_palf_handle_impl failed", K(ret), K(id), KPC(svr));
|
||||
} else if (!svr->is_arb_server() && OB_FAIL(handle->set_initial_member_list(member_list, arb_replica, get_member_cnt()-1, learner_list))) {
|
||||
} else if (!svr->is_arb_server() && OB_FAIL(handle->set_initial_member_list(member_list, arb_replica, member_cnt-1, learner_list))) {
|
||||
CLOG_LOG(ERROR, "set_initial_member_list failed", K(ret), K(id), KPC(svr));
|
||||
} else {
|
||||
common::ObAddr leader_addr;
|
||||
|
||||
@ -166,6 +166,15 @@ public:
|
||||
int64_t &leader_idx,
|
||||
const bool with_mock_election,
|
||||
PalfHandleImplGuard &leader);
|
||||
int create_paxos_group_with_arb(const int64_t id,
|
||||
palf::PalfLocationCacheCb *loc_cb,
|
||||
ObMemberList member_list,
|
||||
int64_t member_cnt,
|
||||
ObMember arb_member,
|
||||
int64_t &arb_replica_idx,
|
||||
int64_t &leader_idx,
|
||||
const bool with_mock_election,
|
||||
PalfHandleImplGuard &leader);
|
||||
int create_paxos_group_with_mock_election(const int64_t id,
|
||||
int64_t &leader_idx,
|
||||
PalfHandleImplGuard &leader);
|
||||
|
||||
@ -767,6 +767,38 @@ TEST_F(TestObSimpleLogClusterArbService, test_2f1a_upgrade_when_no_leader)
|
||||
PALF_LOG(INFO, "end test_2f1a_upgrade_when_no_leader", K(id));
|
||||
}
|
||||
|
||||
TEST_F(TestObSimpleLogClusterArbService, test_1f1a_create_palf_group)
|
||||
{
|
||||
oceanbase::common::ObClusterVersion::get_instance().cluster_version_ = CLUSTER_VERSION_4_1_0_0;
|
||||
SET_CASE_LOG_FILE(TEST_NAME, "test_1f1a_create_palf_group");
|
||||
PALF_LOG(INFO, "begin test_1f1a_create_palf_group");
|
||||
OB_LOGGER.set_log_level("TRACE");
|
||||
const int64_t CONFIG_CHANGE_TIMEOUT = 10 * 1000 * 1000L; // 10s
|
||||
MockLocCB loc_cb;
|
||||
int ret = OB_SUCCESS;
|
||||
int64_t leader_idx = 0;
|
||||
int64_t arb_replica_idx = -1;
|
||||
PalfHandleImplGuard leader;
|
||||
const int64_t id = ATOMIC_AAF(&palf_id_, 1);
|
||||
common::ObMemberList member_list = get_member_list();
|
||||
member_list.remove_server(get_cluster()[1]->get_addr());
|
||||
const int64_t member_cnt = 2;
|
||||
const common::ObMember &arb_member = get_arb_member();
|
||||
EXPECT_EQ(OB_SUCCESS, create_paxos_group_with_arb(id, &loc_cb, member_list, member_cnt, arb_member, arb_replica_idx, leader_idx, false, leader));
|
||||
EXPECT_EQ(OB_SUCCESS, submit_log(leader, 100, id));
|
||||
|
||||
LogConfigVersion config_version;
|
||||
EXPECT_EQ(OB_SUCCESS, leader.palf_handle_impl_->get_config_version(config_version));
|
||||
EXPECT_EQ(OB_SUCCESS, leader.palf_handle_impl_->add_member(ObMember(get_cluster()[1]->get_addr(), 1), 2, config_version, CONFIG_CHANGE_TIMEOUT));
|
||||
|
||||
EXPECT_EQ(2, leader.palf_handle_impl_->config_mgr_.log_ms_meta_.curr_.config_.log_sync_replica_num_);
|
||||
EXPECT_EQ(2, leader.palf_handle_impl_->config_mgr_.log_ms_meta_.curr_.config_.log_sync_memberlist_.get_member_number());
|
||||
|
||||
leader.reset();
|
||||
delete_paxos_group(id);
|
||||
PALF_LOG(INFO, "end test_2f1a_degrade_upgrade", K(id));
|
||||
}
|
||||
|
||||
} // end unittest
|
||||
} // end oceanbase
|
||||
|
||||
|
||||
@ -59,6 +59,7 @@ LogConfigMgr::LogConfigMgr()
|
||||
last_wait_barrier_time_us_(OB_INVALID_TIMESTAMP),
|
||||
last_wait_committed_end_lsn_(),
|
||||
last_sync_meta_for_arb_election_leader_time_us_(OB_INVALID_TIMESTAMP),
|
||||
forwarding_config_proposal_id_(INVALID_PROPOSAL_ID),
|
||||
parent_lock_(common::ObLatchIds::PALF_CM_PARENT_LOCK),
|
||||
register_time_us_(OB_INVALID_TIMESTAMP),
|
||||
parent_(),
|
||||
@ -172,6 +173,7 @@ void LogConfigMgr::destroy()
|
||||
all_learnerlist_.reset();
|
||||
paxos_member_region_map_.destroy();
|
||||
last_sync_meta_for_arb_election_leader_time_us_ = OB_INVALID_TIMESTAMP;
|
||||
forwarding_config_proposal_id_ = INVALID_PROPOSAL_ID;
|
||||
region_ = DEFAULT_REGION_NAME;
|
||||
state_ = ConfigChangeState::INIT;
|
||||
reconfig_barrier_.reset();
|
||||
@ -229,7 +231,6 @@ int LogConfigMgr::set_initial_member_list(const common::ObMemberList &member_lis
|
||||
PALF_LOG(WARN, "LogConfigMgr not init", KR(ret));
|
||||
} else if (!member_list.is_valid() ||
|
||||
!arb_member.is_valid() ||
|
||||
(replica_num & 1) != 0 ||
|
||||
replica_num <= 0 ||
|
||||
replica_num > OB_MAX_MEMBER_NUMBER ||
|
||||
INVALID_PROPOSAL_ID == proposal_id ||
|
||||
@ -245,6 +246,7 @@ int LogConfigMgr::set_initial_member_list(const common::ObMemberList &member_lis
|
||||
if (OB_FAIL(set_initial_config_info_(config_info, proposal_id, init_config_version))) {
|
||||
PALF_LOG(WARN, "set_initial_config_info failed", K(ret), K_(palf_id), K_(self), K(config_info), K(proposal_id));
|
||||
} else {
|
||||
forwarding_config_proposal_id_ = proposal_id;
|
||||
PALF_LOG(INFO, "set_initial_member_list success", K(ret), K_(palf_id), K_(self), K_(log_ms_meta), K(member_list), K(arb_member), K(replica_num), K(proposal_id));
|
||||
}
|
||||
}
|
||||
@ -2459,6 +2461,38 @@ int LogConfigMgr::sync_get_committed_end_lsn_(const LogConfigChangeArgs &args,
|
||||
return ret;
|
||||
}
|
||||
|
||||
// need rlock of PalfHandleImpl
|
||||
// The arb server don't support set_initial_member_list,
|
||||
// so we need to forward LogConfigMeta to arb member. otherwise,
|
||||
// if only 1F1A are created successfully when creating PALF group,
|
||||
// A will not vote for the F because of empty config meta.
|
||||
int LogConfigMgr::forward_initial_config_meta_to_arb()
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
const common::ObMember &arb_member = log_ms_meta_.curr_.config_.arbitration_member_;
|
||||
if (IS_NOT_INIT) {
|
||||
ret = OB_NOT_INIT;
|
||||
} else if (INVALID_PROPOSAL_ID == forwarding_config_proposal_id_ ||
|
||||
false == arb_member.is_valid()) {
|
||||
// skip
|
||||
} else {
|
||||
common::ObMemberList forward_list;
|
||||
if (forwarding_config_proposal_id_ != state_mgr_->get_proposal_id() ||
|
||||
forwarding_config_proposal_id_ != log_ms_meta_.proposal_id_) {
|
||||
forwarding_config_proposal_id_ = INVALID_PROPOSAL_ID;
|
||||
PALF_LOG(INFO, "stop forward_initial_config_meta_to_arb", KR(ret), K_(palf_id), K_(self));
|
||||
} else if (OB_FAIL(forward_list.add_member(arb_member))) {
|
||||
PALF_LOG(WARN, "add_member failed", KR(ret), K_(palf_id), K_(self), K(forward_list), K(arb_member));
|
||||
} else if (OB_FAIL(log_engine_->submit_change_config_meta_req(forward_list,
|
||||
log_ms_meta_.proposal_id_, log_ms_meta_.prev_log_proposal_id_,
|
||||
log_ms_meta_.prev_lsn_, log_ms_meta_.prev_mode_pid_, log_ms_meta_))) {
|
||||
PALF_LOG(WARN, "submit_change_config_meta_req failed", KR(ret), K_(palf_id), K_(self),
|
||||
K(arb_member), K_(log_ms_meta));
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
//================================ Config Change ================================
|
||||
|
||||
//================================ Child ================================
|
||||
|
||||
@ -477,6 +477,7 @@ public:
|
||||
int sync_meta_for_arb_election_leader();
|
||||
void set_sync_to_degraded_learners();
|
||||
bool is_sync_to_degraded_learners() const;
|
||||
int forward_initial_config_meta_to_arb();
|
||||
// ================ Config Change ==================
|
||||
// ==================== Child ========================
|
||||
virtual int register_parent();
|
||||
@ -680,6 +681,7 @@ private:
|
||||
mutable int64_t last_wait_barrier_time_us_;
|
||||
mutable LSN last_wait_committed_end_lsn_;
|
||||
int64_t last_sync_meta_for_arb_election_leader_time_us_;
|
||||
int64_t forwarding_config_proposal_id_;
|
||||
// ================= Config Change =================
|
||||
// ==================== Child ========================
|
||||
mutable common::ObSpinLock parent_lock_;
|
||||
|
||||
@ -2594,6 +2594,7 @@ int PalfHandleImpl::check_and_switch_state()
|
||||
} else if (OB_FAIL(mode_mgr_.leader_do_loop_work())) {
|
||||
PALF_LOG(WARN, "LogModeMgr::leader_do_loop_work failed", KR(ret), K_(self), K_(palf_id));
|
||||
}
|
||||
(void) config_mgr_.forward_initial_config_meta_to_arb();
|
||||
} while (0);
|
||||
if (OB_UNLIKELY(config_state_changed)) {
|
||||
WLockGuard guard(lock_);
|
||||
|
||||
@ -434,6 +434,8 @@ int ObLSCreator::create_ls_(const ObILSAddr &addrs,
|
||||
common::GlobalLearnerList &learner_list)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
bool need_create_arb_replica = false;
|
||||
int64_t arb_replica_count = 0;
|
||||
if (OB_UNLIKELY(!is_valid())) {
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
LOG_WARN("invalid argument", KR(ret));
|
||||
@ -472,20 +474,10 @@ int ObLSCreator::create_ls_(const ObILSAddr &addrs,
|
||||
K(arg), K(tenant_id_));
|
||||
}
|
||||
}
|
||||
//wait all
|
||||
if (OB_TMP_FAIL(create_ls_proxy_.wait_all(return_code_array))) {
|
||||
ret = OB_SUCC(ret) ? tmp_ret : ret;
|
||||
LOG_WARN("failed to wait all async rpc", KR(ret), KR(tmp_ret));
|
||||
}
|
||||
if (FAILEDx(check_create_ls_result_(paxos_replica_num, return_code_array, member_list, learner_list))) {
|
||||
LOG_WARN("failed to check ls result", KR(ret), K(paxos_replica_num), K(return_code_array), K(learner_list));
|
||||
}
|
||||
|
||||
#ifdef OB_BUILD_ARBITRATION
|
||||
// try to create A-replica if needed
|
||||
// (1) ignore any erros because majority of F-replica is successfully created,
|
||||
// (1) ignore any erros
|
||||
// arb replica task will generated by back groud process later to add A-replica
|
||||
bool need_create_arb_replica = false;
|
||||
ObAddr arbitration_service_addr;
|
||||
if (OB_FAIL(ret)) {
|
||||
} else if (OB_SUCCESS != (tmp_ret = check_need_create_arb_replica_(
|
||||
@ -502,8 +494,19 @@ int ObLSCreator::create_ls_(const ObILSAddr &addrs,
|
||||
} else {
|
||||
int64_t timestamp = 1;
|
||||
arbitration_service = ObMember(arbitration_service_addr, timestamp);
|
||||
arb_replica_count = 1;
|
||||
}
|
||||
#endif
|
||||
//wait all
|
||||
if (OB_TMP_FAIL(create_ls_proxy_.wait_all(return_code_array))) {
|
||||
ret = OB_SUCC(ret) ? tmp_ret : ret;
|
||||
LOG_WARN("failed to wait all async rpc", KR(ret), KR(tmp_ret));
|
||||
}
|
||||
if (FAILEDx(check_create_ls_result_(paxos_replica_num, return_code_array, member_list, learner_list,
|
||||
need_create_arb_replica, arb_replica_count))) {
|
||||
LOG_WARN("failed to check ls result", KR(ret), K(paxos_replica_num), K(return_code_array), K(learner_list),
|
||||
K(need_create_arb_replica), K(arb_replica_count));
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
@ -610,7 +613,9 @@ int ObLSCreator::check_create_ls_result_(
|
||||
const int64_t paxos_replica_num,
|
||||
const ObIArray<int> &return_code_array,
|
||||
common::ObMemberList &member_list,
|
||||
common::GlobalLearnerList &learner_list)
|
||||
common::GlobalLearnerList &learner_list,
|
||||
const bool with_arbitration_service,
|
||||
const int64_t arb_replica_num)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
member_list.reset();
|
||||
@ -663,10 +668,18 @@ int ObLSCreator::check_create_ls_result_(
|
||||
}
|
||||
}
|
||||
if (OB_FAIL(ret)) {
|
||||
} else if (rootserver::majority(paxos_replica_num) > member_list.get_member_number()) {
|
||||
ret = OB_REPLICA_NUM_NOT_ENOUGH;
|
||||
LOG_WARN("success count less than majority", KR(ret), K(paxos_replica_num),
|
||||
K(member_list));
|
||||
} else if (!id_.is_sys_ls() && with_arbitration_service) {
|
||||
if (rootserver::majority(paxos_replica_num/*F-replica*/ + 1/*A-replica*/) > member_list.get_member_number() + arb_replica_num) {
|
||||
ret = OB_REPLICA_NUM_NOT_ENOUGH;
|
||||
LOG_WARN("success count less than majority with arb-replica", KR(ret), K(paxos_replica_num),
|
||||
K(member_list), K(with_arbitration_service), K(arb_replica_num));
|
||||
}
|
||||
} else {
|
||||
// for sys log stream and non-arb user log stream
|
||||
if (rootserver::majority(paxos_replica_num) > member_list.get_member_number()) {
|
||||
ret = OB_REPLICA_NUM_NOT_ENOUGH;
|
||||
LOG_WARN("success count less than majority", KR(ret), K(paxos_replica_num), K(member_list));
|
||||
}
|
||||
}
|
||||
LS_EVENT_ADD(tenant_id_, id_, "create_ls", ret, paxos_replica_num, member_list);
|
||||
}
|
||||
@ -763,23 +776,89 @@ int ObLSCreator::check_member_list_and_learner_list_all_in_meta_table_(
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObLSCreator::construct_paxos_replica_number_to_persist_(
|
||||
const int64_t paxos_replica_num,
|
||||
const int64_t arb_replica_num,
|
||||
const common::ObMemberList &member_list,
|
||||
int64_t &paxos_replica_number_to_persist)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
paxos_replica_number_to_persist = 0;
|
||||
|
||||
if (OB_UNLIKELY(!is_valid())) {
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
LOG_WARN("invalid argument", KR(ret));
|
||||
} else if (OB_UNLIKELY(!member_list.is_valid())
|
||||
|| OB_UNLIKELY(0 >= paxos_replica_num)) {
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
LOG_WARN("invalid argument", KR(ret), K(member_list), K(paxos_replica_num));
|
||||
} else if (!id_.is_user_ls()) {
|
||||
// for sys log stream
|
||||
if (member_list.get_member_number() >= rootserver::majority(paxos_replica_num)) {
|
||||
// good, majority of F-replica created successfully, set paxos_replica_num equal to locality
|
||||
paxos_replica_number_to_persist = paxos_replica_num;
|
||||
} else {
|
||||
// sys log stream needs majority of F-replicas created success
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
LOG_WARN("majority is not satisfied", KR(ret), K_(tenant_id), K_(id),
|
||||
K(member_list), K(paxos_replica_num), K(arb_replica_num));
|
||||
}
|
||||
} else {
|
||||
// for user log stream
|
||||
if (member_list.get_member_number() >= rootserver::majority(paxos_replica_num)) {
|
||||
// good, majority of F-replica created successfully, set paxos_replica_num equal to locality
|
||||
paxos_replica_number_to_persist = paxos_replica_num;
|
||||
#ifdef OB_BUILD_ARBITRATION
|
||||
} else if (member_list.get_member_number() + arb_replica_num >= rootserver::majority(paxos_replica_num)) {
|
||||
// check majority with arb-replica for user log stream
|
||||
if (OB_UNLIKELY(1 != arb_replica_num)) {
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
LOG_WARN("arb replica number must equals to 1 after check of majority with arb_replica_num",
|
||||
KR(ret), K(paxos_replica_num), K(arb_replica_num), K(member_list));
|
||||
} else if (paxos_replica_num != 2 && paxos_replica_num != 4) {
|
||||
// with arb-replica, paxos_replica_number in locality should be 2F1A or 4F1A
|
||||
ret = OB_STATE_NOT_MATCH;
|
||||
LOG_WARN("tenant with arbitration service should has paxos_replica_num is 2 or 4", KR(ret), K(paxos_replica_num));
|
||||
} else {
|
||||
// when tenant's locality is 2F1A, but only 1F1A created successfully, paxos_replica_number should set 1
|
||||
// when tenant's locality is 4F1A, but only 2F1A created successfully, paxos_replica_number should set 3
|
||||
paxos_replica_number_to_persist = paxos_replica_num - 1;
|
||||
}
|
||||
#endif
|
||||
} else {
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
LOG_WARN("majority is not satisfied", KR(ret), K_(tenant_id), K_(id),
|
||||
K(member_list), K(paxos_replica_num), K(arb_replica_num));
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObLSCreator::set_member_list_(const common::ObMemberList &member_list,
|
||||
const common::ObMember &arbitration_service,
|
||||
const common::ObMember &arb_replica,
|
||||
const int64_t paxos_replica_num,
|
||||
const common::GlobalLearnerList &learner_list)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObArray<common::ObAddr> server_list;
|
||||
int tmp_ret = OB_SUCCESS;
|
||||
int64_t paxos_replica_number_to_persist = 0;
|
||||
int64_t arb_replica_count = arb_replica.is_valid() ? 1 : 0;
|
||||
if (OB_UNLIKELY(!is_valid())) {
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
LOG_WARN("invalid argument", KR(ret));
|
||||
} else if (OB_UNLIKELY(!member_list.is_valid()
|
||||
|| member_list.get_member_number() < rootserver::majority(paxos_replica_num))) {
|
||||
} else if (OB_UNLIKELY(!member_list.is_valid())) {
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
LOG_WARN("invalid argument", KR(ret), K(member_list), K(paxos_replica_num));
|
||||
LOG_WARN("invalid argument", KR(ret), K(member_list));
|
||||
} else if (!is_sys_tenant(tenant_id_) && OB_FAIL(check_member_list_and_learner_list_all_in_meta_table_(member_list, learner_list))) {
|
||||
LOG_WARN("fail to check member_list all in meta table", KR(ret), K(member_list), K(learner_list), K_(tenant_id), K_(id));
|
||||
} else if (OB_FAIL(construct_paxos_replica_number_to_persist_(
|
||||
paxos_replica_num,
|
||||
arb_replica_count,
|
||||
member_list,
|
||||
paxos_replica_number_to_persist))) {
|
||||
LOG_WARN("fail to construct paxos replica number to set", KR(ret), K_(tenant_id), K_(id),
|
||||
K(paxos_replica_num), K(arb_replica_count), K(member_list));
|
||||
} else {
|
||||
ObTimeoutCtx ctx;
|
||||
if (OB_FAIL(ObShareUtil::set_default_timeout_ctx(ctx, GCONF.rpc_timeout))) {
|
||||
@ -789,9 +868,9 @@ int ObLSCreator::set_member_list_(const common::ObMemberList &member_list,
|
||||
for (int64_t i = 0; OB_SUCC(ret) && i < member_list.get_member_number(); ++i) {
|
||||
ObAddr addr;
|
||||
ObSetMemberListArgV2 arg;
|
||||
if (OB_FAIL(arg.init(tenant_id_, id_, paxos_replica_num, member_list, arbitration_service, learner_list))) {
|
||||
if (OB_FAIL(arg.init(tenant_id_, id_, paxos_replica_number_to_persist, member_list, arb_replica, learner_list))) {
|
||||
LOG_WARN("failed to init set member list arg", KR(ret), K_(id), K_(tenant_id),
|
||||
K(paxos_replica_num), K(member_list), K(arbitration_service), K(learner_list));
|
||||
K(paxos_replica_number_to_persist), K(member_list), K(arb_replica), K(learner_list));
|
||||
} else if (OB_FAIL(member_list.get_server_by_index(i, addr))) {
|
||||
LOG_WARN("failed to get member by index", KR(ret), K(i), K(member_list));
|
||||
} else if (OB_TMP_FAIL(set_member_list_proxy_.call(addr, ctx.get_timeout(),
|
||||
@ -808,7 +887,7 @@ int ObLSCreator::set_member_list_(const common::ObMemberList &member_list,
|
||||
LOG_WARN("failed to wait all async rpc", KR(ret), KR(tmp_ret));
|
||||
|
||||
}
|
||||
if (FAILEDx(check_set_memberlist_result_(return_code_array, paxos_replica_num))) {
|
||||
if (FAILEDx(check_set_memberlist_result_(return_code_array, paxos_replica_number_to_persist))) {
|
||||
LOG_WARN("failed to check set member liset result", KR(ret),
|
||||
K(paxos_replica_num), K(return_code_array));
|
||||
}
|
||||
|
||||
@ -125,8 +125,13 @@ private:
|
||||
int check_member_list_and_learner_list_all_in_meta_table_(
|
||||
const common::ObMemberList &member_list,
|
||||
const common::GlobalLearnerList &learner_list);
|
||||
int construct_paxos_replica_number_to_persist_(
|
||||
const int64_t paxos_replica_num,
|
||||
const int64_t arb_replica_num,
|
||||
const common::ObMemberList &member_list,
|
||||
int64_t &paxos_replica_number_to_persist);
|
||||
int set_member_list_(const common::ObMemberList &member_list,
|
||||
const common::ObMember &arbitration_service,
|
||||
const common::ObMember &arb_replica,
|
||||
const int64_t paxos_replica_num,
|
||||
const common::GlobalLearnerList &learner_list);
|
||||
#ifdef OB_BUILD_ARBITRATION
|
||||
@ -172,7 +177,9 @@ private:
|
||||
int check_create_ls_result_(const int64_t paxos_replica_num,
|
||||
const ObIArray<int> &return_code_array,
|
||||
common::ObMemberList &member_list,
|
||||
common::GlobalLearnerList &learner_list);
|
||||
common::GlobalLearnerList &learner_list,
|
||||
const bool with_arbitration_service,
|
||||
const int64_t arb_replica_num);
|
||||
int check_set_memberlist_result_(const ObIArray<int> &return_code_array,
|
||||
const int64_t paxos_replica_num);
|
||||
|
||||
|
||||
@ -131,8 +131,6 @@ TEST_F(TestLogConfigMgr, test_set_initial_member_list)
|
||||
EXPECT_EQ(OB_NOT_SUPPORTED, cm.set_initial_member_list(init_member_list, ObMember(addr1, 0), 2, 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), 2, learner_list, 1, config_version));
|
||||
// invalid replica_num
|
||||
EXPECT_EQ(OB_INVALID_ARGUMENT, cm.set_initial_member_list(init_member_list, ObMember(addr3, 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), 2, learner_list, 1, config_version));
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user