Struct raftstore::store::fsm::apply::ApplyFsm

pub struct ApplyFsm<EK> where
    EK: KvEngine,  {
    delegate: ApplyDelegate<EK>,
    receiver: Receiver<Msg<EK>>,
    mailbox: Option<BasicMailbox<ApplyFsm<EK>>>,
}

Fields

delegate: ApplyDelegate<EK>

receiver: Receiver<Msg<EK>>

mailbox: Option<BasicMailbox<ApplyFsm<EK>>>

Implementations

impl<EK> ApplyFsm<EK> where
    EK: KvEngine, 

fn from_peer<ER: RaftEngine>(
    peer: &Peer<EK, ER>
) -> (LooseBoundedSender<Msg<EK>>, Box<ApplyFsm<EK>>)

fn from_registration(
    reg: Registration
) -> (LooseBoundedSender<Msg<EK>>, Box<ApplyFsm<EK>>)

fn handle_registration(&mut self, reg: Registration)

Handles peer registration. When a peer is created, it will register an apply delegate.

fn handle_apply<W: WriteBatch<EK>>(
    &mut self,
    apply_ctx: &mut ApplyContext<EK, W>,
    apply: Apply<EK::Snapshot>
)

Handles apply tasks, and uses the apply delegate to handle the committed entries.

fn append_proposal(&mut self, props_drainer: Drain<'_, Proposal<EK::Snapshot>>)

Handles proposals, and appends the commands to the apply delegate.

fn destroy<W: WriteBatch<EK>>(&mut self, ctx: &mut ApplyContext<EK, W>)

fn handle_destroy<W: WriteBatch<EK>>(
    &mut self,
    ctx: &mut ApplyContext<EK, W>,
    d: Destroy
)

Handles peer destroy. When a peer is destroyed, the corresponding apply delegate should be removed too.

fn resume_pending<W: WriteBatch<EK>>(&mut self, ctx: &mut ApplyContext<EK, W>)

fn logs_up_to_date_for_merge<W: WriteBatch<EK>>(
    &mut self,
    ctx: &mut ApplyContext<EK, W>,
    catch_up_logs: CatchUpLogs
)

fn handle_snapshot<W: WriteBatch<EK>>(
    &mut self,
    apply_ctx: &mut ApplyContext<EK, W>,
    snap_task: GenSnapTask
)

fn handle_change<W: WriteBatch<EK>>(
    &mut self,
    apply_ctx: &mut ApplyContext<EK, W>,
    cmd: ChangeObserver,
    region_epoch: RegionEpoch,
    cb: Callback<EK::Snapshot>
)

fn handle_tasks<W: WriteBatch<EK>>(
    &mut self,
    apply_ctx: &mut ApplyContext<EK, W>,
    msgs: &mut Vec<Msg<EK>>
)

Trait Implementations

impl<EK> Drop for ApplyFsm<EK> where
    EK: KvEngine, 

fn drop(&mut self)

Executes the destructor for this type.

impl<EK> Fsm for ApplyFsm<EK> where
    EK: KvEngine, 

type Message = Msg<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.

fn get_priority(&self) -> Priority

impl<EK, W> HandlerBuilder<ApplyFsm<EK>, ControlFsm> for Builder<EK, W> where
    EK: KvEngine,
    W: WriteBatch<EK>, 

type Handler = ApplyPoller<EK, W>

fn build(&mut self, priority: Priority) -> ApplyPoller<EK, W>

impl<EK, W> PollHandler<ApplyFsm<EK>, ControlFsm> for ApplyPoller<EK, W> where
    EK: KvEngine,
    W: WriteBatch<EK>, 

fn begin(&mut self, _batch_size: usize)

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

fn handle_control(&mut self, _: &mut ControlFsm) -> Option<usize>

There is no control fsm in apply poller.

fn handle_normal(&mut self, normal: &mut ApplyFsm<EK>) -> Option<usize>

This function is called when handling readiness for normal FSM.

fn end(&mut self, fsms: &mut [Box<ApplyFsm<EK>>])

This function is called at the end of every round.

fn get_priority(&self) -> Priority

This function returns the priority of this handler.

pub fn pause(&mut self)

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