Struct raftstore::store::fsm::peer::PeerFsm

pub struct PeerFsm<EK, ER> where
    EK: KvEngine,
    ER: RaftEngine,  {
    pub peer: Peer<EK, ER>,
    tick_registry: PeerTicks,
    missing_ticks: usize,
    hibernate_state: HibernateState,
    stopped: bool,
    has_ready: bool,
    mailbox: Option<BasicMailbox<PeerFsm<EK, ER>>>,
    pub receiver: Receiver<PeerMsg<EK>>,
    skip_split_count: usize,
    skip_gc_raft_log_ticks: usize,
    batch_req_builder: BatchRaftCmdRequestBuilder<EK>,
}

Fields

peer: Peer<EK, ER>

tick_registry: PeerTicks

A registry for all scheduled ticks. This can avoid scheduling ticks twice accidentally.

missing_ticks: usize

Ticks for speed up campaign in chaos state.

Followers will keep ticking in Idle mode to measure how many ticks have been skipped. Once it becomes chaos, those skipped ticks will be ticked so that it can campaign quickly instead of waiting an election timeout.

This will be reset to 0 once it receives any messages from leader.

hibernate_state: HibernateState

stopped: bool

has_ready: bool

mailbox: Option<BasicMailbox<PeerFsm<EK, ER>>>

receiver: Receiver<PeerMsg<EK>>

skip_split_count: usize

when snapshot is generating or sending, skip split check at most REGION_SPLIT_SKIT_MAX_COUNT times.

skip_gc_raft_log_ticks: usize

Sometimes applied raft logs won’t be compacted in time, because less compact means less sync-log in apply threads. Stale logs will be deleted if the skip time reaches this skip_gc_raft_log_ticks.

batch_req_builder: BatchRaftCmdRequestBuilder<EK>

Implementations

impl<EK, ER> PeerFsm<EK, ER> where
    EK: KvEngine,
    ER: RaftEngine, 

pub fn create(
    store_id: u64,
    cfg: &Config,
    sched: Scheduler<RegionTask<EK::Snapshot>>,
    engines: Engines<EK, ER>,
    region: &Region
) -> Result<(LooseBoundedSender<PeerMsg<EK>>, Box<PeerFsm<EK, ER>>)>

pub fn replicate(
    store_id: u64,
    cfg: &Config,
    sched: Scheduler<RegionTask<EK::Snapshot>>,
    engines: Engines<EK, ER>,
    region_id: u64,
    peer: Peer
) -> Result<(LooseBoundedSender<PeerMsg<EK>>, Box<PeerFsm<EK, ER>>)>

pub fn region_id(&self) -> u64

pub fn get_peer(&self) -> &Peer<EK, ER>

pub fn peer_id(&self) -> u64

pub fn stop(&mut self)

pub fn set_pending_merge_state(&mut self, state: MergeState)

pub fn schedule_applying_snapshot(&mut self)

Trait Implementations

impl<EK: KvEngine, ER: RaftEngine> AbstractPeer for PeerFsm<EK, ER>

fn meta_peer(&self) -> &Peer

fn group_state(&self) -> GroupState

fn region(&self) -> &Region

fn apply_state(&self) -> &RaftApplyState

fn raft_status(&self) -> Status<'_>

fn raft_commit_index(&self) -> u64

fn raft_request_snapshot(&mut self, index: u64)

fn pending_merge_state(&self) -> Option<&MergeState>

impl<EK, ER> Drop for PeerFsm<EK, ER> where
    EK: KvEngine,
    ER: RaftEngine, 

fn drop(&mut self)

Executes the destructor for this type.

impl<EK, ER> Fsm for PeerFsm<EK, ER> where
    EK: KvEngine,
    ER: RaftEngine, 

type Message = PeerMsg<EK>

fn is_stopped(&self) -> bool

fn set_mailbox(&mut self, mailbox: Cow<'_, BasicMailbox<Self>>) where
    Self: Sized, 

Set a mailbox to Fsm, which should be used to send message to itself.

fn take_mailbox(&mut self) -> Option<BasicMailbox<Self>> where
    Self: Sized, 

Take the mailbox from Fsm. Implementation should ensure there will be no reference to mailbox after calling this method.

pub fn get_priority(&self) -> Priority

impl<EK, ER, T> HandlerBuilder<PeerFsm<EK, ER>, StoreFsm<EK>> for RaftPollerBuilder<EK, ER, T> where
    EK: KvEngine + 'static,
    ER: RaftEngine + 'static,
    T: Transport + 'static, 

type Handler = RaftPoller<EK, ER, T>

fn build(&mut self, _: Priority) -> RaftPoller<EK, ER, T>

impl<EK: KvEngine, ER: RaftEngine, T: Transport> PollHandler<PeerFsm<EK, ER>, StoreFsm<EK>> for RaftPoller<EK, ER, T>

fn begin(&mut self, _batch_size: usize)

This function is called at the very beginning of every round.

fn handle_control(&mut self, store: &mut StoreFsm<EK>) -> Option<usize>

This function is called when handling readiness for control FSM.

fn handle_normal(&mut self, peer: &mut PeerFsm<EK, ER>) -> Option<usize>

This function is called when handling readiness for normal FSM.

fn end(&mut self, peers: &mut [Box<PeerFsm<EK, ER>>])

This function is called at the end of every round.

fn pause(&mut self)

This function is called when batch system is going to sleep.

pub fn get_priority(&self) -> Priority

This function returns the priority of this handler.