Revoke when disable vote.

src/logservice/palf/election/algorithm/election_impl.cpp

@@ -398,13 +398,13 @@ int ElectionImpl::send_(const ElectionChangeLeaderMsg &msg) const
   #undef PRINT_WRAPPER
 }
 
-int ElectionImpl::revoke()
+int ElectionImpl::revoke(const RoleChangeReason &reason)
 {
   ELECT_TIME_GUARD(500_ms);
   int ret = OB_SUCCESS;
   LockGuard lock_guard(lock_);
   CHECK_ELECTION_INIT();
-  ret = proposer_.revoke();
+  ret = proposer_.revoke(reason);
   return ret;
 }
 

src/logservice/palf/election/algorithm/election_impl.h

@@ -64,7 +64,7 @@ public:
                      const int64_t restart_counter,
                      const ObFunction<int(const int64_t, const ObAddr &)> &prepare_change_leader_cb,
                      const ObFunction<void(ElectionImpl *, common::ObRole, common::ObRole, RoleChangeReason)> &role_change_cb = DefaultRoleChangeCallBack());
-  int revoke();
+  int revoke(const RoleChangeReason &reason) override;
   virtual void stop() override final;
   virtual int set_memberlist(const MemberList &new_memberlist) override final;
   virtual int change_leader_to(const common::ObAddr &dest_addr) override final;

src/logservice/palf/election/algorithm/election_proposer.cpp

@@ -688,7 +688,7 @@ int64_t ElectionProposer::to_string(char *buf, const int64_t buf_len) const
   return pos;
 }
 
-int ElectionProposer::revoke()
+int ElectionProposer::revoke(const RoleChangeReason &reason)
 {
   ELECT_TIME_GUARD(500_ms);
   #define PRINT_WRAPPER K(*this)
@@ -698,7 +698,7 @@ int ElectionProposer::revoke()
     LOG_NONE(WARN, "i am not leader, but someone ask me to revoke", K(lbt()));
   }
   leader_lease_and_epoch_.reset();
-  if (!leader_revoke_if_lease_expired_(RoleChangeReason::AskToRevoke)) {
+  if (!leader_revoke_if_lease_expired_(reason)) {
     LOG_NONE(WARN, "somethig wrong when revoke", K(lbt()));
   }
   return ret;

src/logservice/palf/election/algorithm/election_proposer.h

@@ -81,7 +81,7 @@ public:
     }
     return ret;
   }
-  int revoke();
+  int revoke(const RoleChangeReason &reason);
 public:
   // 发prepare请求
   void prepare(const common::ObRole role);

src/logservice/palf/election/interface/election.h

@@ -42,6 +42,7 @@ enum class RoleChangeReason
   ChangeLeaderToRevoke = 4, // 切主流程旧主从Leader变为Follower
   StopToRevoke = 5,// 选举leader调用stop接口后leader卸任
   AskToRevoke = 6,// 有人要求选举卸任(???)
+  PalfDisableVoteToRevoke = 7,// palf disable vote触发卸任
 };
 
 class ElectionProposer;
@@ -72,6 +73,7 @@ public:
                                         int64_t &cur_leader_epoch) const = 0;
   // 供role change service使用
   virtual int change_leader_to(const common::ObAddr &dest_addr) = 0;
+  virtual int revoke(const RoleChangeReason &reason) = 0;
   // 拿本机地址
   virtual const common::ObAddr &get_self_addr() const = 0;
   // 打印日志

src/logservice/palf/log_state_mgr.cpp

@@ -217,9 +217,9 @@ bool LogStateMgr::is_state_changed()
       state_changed = follower_need_update_role_(new_leader, new_leader_epoch);
     }
   } else if (is_leader_reconfirm_()) {
-    state_changed = leader_reconfirm_need_switch_();
+    state_changed = (leader_reconfirm_need_switch_() || false == is_allow_vote());
   } else if (is_leader_active_()) {
-    state_changed = leader_active_need_switch_(is_error);
+    state_changed = (leader_active_need_switch_(is_error) || false == is_allow_vote());
   } else {}
   return state_changed;
 }
@@ -292,6 +292,10 @@ int LogStateMgr::switch_state()
         need_next_loop = true; // 1) drive reconfirm or 2) fetch log from leader
       }
     } else if (is_leader_reconfirm_()) {
+      if (false == is_allow_vote()
+          && OB_FAIL(election_->revoke(election::RoleChangeReason::PalfDisableVoteToRevoke))) {
+        PALF_LOG(WARN, "election revoke failed", K(ret), K_(palf_id));
+      }
       if (is_reconfirm_need_start_()) {
         ret = reconfirm_->reconfirm();
         if (OB_EAGAIN == ret) {
@@ -313,12 +317,12 @@ int LogStateMgr::switch_state()
         // do nothing
       }
     } else if (is_leader_active_()) {
+      if (false == is_allow_vote()
+          && OB_FAIL(election_->revoke(election::RoleChangeReason::PalfDisableVoteToRevoke))) {
+        PALF_LOG(WARN, "election revoke failed", K(ret), K_(palf_id));
+      }
       bool is_error = false;
       if (leader_active_need_switch_(is_error)) {
-        if (is_error) {
-          // const uint32_t revoke_type = RevokeType::CLOG_SW_TIMEOUT;
-          // revoke_leader_(revoke_type);
-        }
         ret = leader_active_to_follower_pending_();
         need_next_loop = true;
       }
@@ -578,7 +582,8 @@ int LogStateMgr::follower_pending_to_reconfirm_(const int64_t new_leader_epoch)
 
 int LogStateMgr::reconfirm_to_follower_pending_()
 {
-  PALF_EVENT("reconfirm_to_follower_pending", palf_id_, K_(self), K_(leader), K(lbt()));
+  PALF_EVENT("reconfirm_to_follower_pending", palf_id_, K_(self), K_(leader), "is_allow_vote",
+      is_allow_vote(), K(lbt()));
   int ret = OB_SUCCESS;
   if (OB_FAIL(to_follower_pending_())) {
     PALF_LOG(WARN, "to_follower_pending_ failed, try again", K(ret), K_(palf_id));
@@ -900,7 +905,8 @@ bool LogStateMgr::follower_need_update_role_(common::ObAddr &new_leader,
     new_leader_epoch = OB_INVALID_TIMESTAMP;
   } else {
     bool_ret = (self_ == new_leader);
-    PALF_LOG(TRACE, "follower_need_update_role_", K(new_leader), K(new_leader_epoch));
+    PALF_LOG(TRACE, "follower_need_update_role_", K(bool_ret), K(new_leader), K(new_leader_epoch),
+        "is_allow_vote", is_allow_vote());
   }
   return bool_ret;
 }
@@ -912,14 +918,6 @@ void LogStateMgr::set_leader_and_epoch_(const common::ObAddr &new_leader, const
   PALF_LOG(INFO, "set_leader_and_epoch_", K_(palf_id), K_(self), K(leader_), K(leader_epoch_), K(new_leader));
 }
 
-int LogStateMgr::revoke_leader_(const uint32_t revoke_type)
-{
-  int ret = OB_SUCCESS;
-  UNUSED(revoke_type);
-  // election_->leader_revoke(revoke_type);
-  return ret;
-}
-
 int LogStateMgr::get_elect_leader_(common::ObAddr &leader,
                                    int64_t &leader_epoch) const
 {

src/logservice/palf/log_state_mgr.h

@@ -97,7 +97,7 @@ public:
   TO_STRING_KV(KP(this), K_(self), K_(palf_id), "role", role_to_string(role_),                         \
       "state", replica_state_to_string(state_), K_(prepare_meta), K_(leader), K_(leader_epoch),        \
       K_(is_sync_enabled), K_(pending_end_lsn), K_(scan_disk_log_finished), K_(last_check_start_id),   \
-      K_(reconfirm_start_time_ns), KP_(palf_role_change_cb));
+      K_(reconfirm_start_time_ns), KP_(palf_role_change_cb), K_(allow_vote));
 private:
   bool check_role_and_state_(const common::ObRole &role, const ObReplicaState &state) const;
   void update_role_and_state_(const common::ObRole &new_role, const ObReplicaState &new_state);
@@ -139,7 +139,6 @@ private:
   bool need_update_leader_(common::ObAddr &new_leader);
   bool follower_need_update_role_(common::ObAddr &new_leader, int64_t &new_leader_epoch);
   void set_leader_and_epoch_(const common::ObAddr &new_leader, const int64_t new_leader_epoch);
-  int revoke_leader_(const uint32_t revoke_type);
   int get_elect_leader_(common::ObAddr &leader, int64_t &leader_epoch) const;
   bool check_leader_log_sync_state_();
   bool need_fetch_log_() const;

src/logservice/palf/palf_handle_impl.cpp

@@ -1358,7 +1358,11 @@ int PalfHandleImpl::set_allow_vote_flag_(const bool allow_vote)
     flush_meta_cb_ctx.allow_vote_ = allow_vote;
     LogReplicaPropertyMeta replica_property_meta = log_engine_.get_log_meta().get_log_replica_property_meta();
     replica_property_meta.allow_vote_ = allow_vote;
-    if (OB_FAIL(log_engine_.submit_flush_replica_property_meta_task(flush_meta_cb_ctx, replica_property_meta))) {
+    if (false == allow_vote
+        && LEADER == state_mgr_.get_role()
+        && OB_FAIL(election_.revoke(RoleChangeReason::PalfDisableVoteToRevoke))) {
+      PALF_LOG(WARN, "election revoke failed", K(ret), K_(palf_id));
+    } else if (OB_FAIL(log_engine_.submit_flush_replica_property_meta_task(flush_meta_cb_ctx, replica_property_meta))) {
       PALF_LOG(WARN, "submit_flush_replica_property_meta_task failed", K(ret), K(flush_meta_cb_ctx), K(replica_property_meta));
     }
   }
@@ -2219,31 +2223,26 @@ int PalfHandleImpl::ack_mode_meta(const common::ObAddr &server,
 
 int PalfHandleImpl::handle_election_message(const election::ElectionPrepareRequestMsg &msg)
 {
-  RLockGuard guard(lock_);
   return election_.handle_message(msg);
 }
 
 int PalfHandleImpl::handle_election_message(const election::ElectionPrepareResponseMsg &msg)
 {
-  RLockGuard guard(lock_);
   return election_.handle_message(msg);
 }
 
 int PalfHandleImpl::handle_election_message(const election::ElectionAcceptRequestMsg &msg)
 {
-  RLockGuard guard(lock_);
   return election_.handle_message(msg);
 }
 
 int PalfHandleImpl::handle_election_message(const election::ElectionAcceptResponseMsg &msg)
 {
-  RLockGuard guard(lock_);
   return election_.handle_message(msg);
 }
 
 int PalfHandleImpl::handle_election_message(const election::ElectionChangeLeaderMsg &msg)
 {
-  RLockGuard guard(lock_);
   return election_.handle_message(msg);
 }
 
@@ -3454,7 +3453,7 @@ int PalfHandleImpl::revoke_leader(const int64_t proposal_id)
   } else if (false == state_mgr_.can_revoke(proposal_id)) {
     ret = OB_NOT_MASTER;
     PALF_LOG(WARN, "revoke_leader failed, not master", K(ret), K_(palf_id), K(proposal_id));
-  } else if (OB_FAIL(election_.revoke())) {
+  } else if (OB_FAIL(election_.revoke(RoleChangeReason::AskToRevoke))) {
     PALF_LOG(WARN, "PalfHandleImpl revoke leader failed", K(ret), K_(palf_id));
   } else {
     PALF_LOG(INFO, "PalfHandleImpl revoke leader success", K(ret), K_(palf_id));

unittest/logservice/mock_logservice_container/mock_election.h

@@ -43,6 +43,12 @@ public:
     UNUSED(new_member_list);
     return ret;
   }
+  int revoke(const RoleChangeReason &reason)
+  {
+    UNUSED(reason);
+    int ret = OB_SUCCESS;
+    return ret;
+  }
   int set_priority(ElectionPriority *) override final { return  OB_SUCCESS; }
   int reset_priority() override final { return  OB_SUCCESS; }
   // 获取选举当前的角色