Struct raftstore::store::fsm::store::PollContext

pub struct PollContext<EK, ER, T> where
    EK: KvEngine,
    ER: RaftEngine,  {
    pub processed_fsm_count: usize,
    pub cfg: Config,
    pub store: Store,
    pub pd_scheduler: FutureScheduler<PdTask<EK>>,
    pub consistency_check_scheduler: Scheduler<ConsistencyCheckTask<EK::Snapshot>>,
    pub split_check_scheduler: Scheduler<SplitCheckTask>,
    pub cleanup_scheduler: Scheduler<CleanupTask>,
    pub raftlog_gc_scheduler: Scheduler<RaftlogGcTask>,
    pub region_scheduler: Scheduler<RegionTask<EK::Snapshot>>,
    pub apply_router: ApplyRouter<EK>,
    pub router: RaftRouter<EK, ER>,
    pub importer: Arc<SSTImporter>,
    pub store_meta: Arc<Mutex<StoreMeta>>,
    pub feature_gate: FeatureGate,
    pub pending_create_peers: Arc<Mutex<HashMap<u64, (u64, bool)>>>,
    pub raft_metrics: RaftMetrics,
    pub snap_mgr: SnapManager,
    pub coprocessor_host: CoprocessorHost<EK>,
    pub timer: SteadyTimer,
    pub trans: T,
    pub global_replication_state: Arc<Mutex<GlobalReplicationState>>,
    pub global_stat: GlobalStoreStat,
    pub store_stat: LocalStoreStat,
    pub engines: Engines<EK, ER>,
    pub kv_wb: EK::WriteBatch,
    pub raft_wb: ER::LogBatch,
    pub pending_count: usize,
    pub sync_log: bool,
    pub has_ready: bool,
    pub ready_res: Vec<CollectedReady>,
    pub current_time: Option<Timespec>,
    pub perf_context: EK::PerfContext,
    pub tick_batch: Vec<PeerTickBatch>,
    pub node_start_time: Option<TiInstant>,
}

Fields

processed_fsm_count: usize

The count of processed normal Fsm.

cfg: Config

store: Store

pd_scheduler: FutureScheduler<PdTask<EK>>

consistency_check_scheduler: Scheduler<ConsistencyCheckTask<EK::Snapshot>>

split_check_scheduler: Scheduler<SplitCheckTask>

cleanup_scheduler: Scheduler<CleanupTask>

raftlog_gc_scheduler: Scheduler<RaftlogGcTask>

region_scheduler: Scheduler<RegionTask<EK::Snapshot>>

apply_router: ApplyRouter<EK>

router: RaftRouter<EK, ER>

importer: Arc<SSTImporter>

store_meta: Arc<Mutex<StoreMeta>>

feature_gate: FeatureGate

pending_create_peers: Arc<Mutex<HashMap<u64, (u64, bool)>>>

region_id -> (peer_id, is_splitting) Used for handling race between splitting and creating new peer. An uninitialized peer can be replaced to the one from splitting iff they are exactly the same peer.

WARNING: To avoid deadlock, if you want to use store_meta and pending_create_peers together, the lock sequence MUST BE:

1. lock the store_meta.
2. lock the pending_create_peers.

raft_metrics: RaftMetrics

snap_mgr: SnapManager

coprocessor_host: CoprocessorHost<EK>

timer: SteadyTimer

trans: T

global_replication_state: Arc<Mutex<GlobalReplicationState>>

global_stat: GlobalStoreStat

store_stat: LocalStoreStat

engines: Engines<EK, ER>

kv_wb: EK::WriteBatch

raft_wb: ER::LogBatch

pending_count: usize

sync_log: bool

has_ready: bool

ready_res: Vec<CollectedReady>

current_time: Option<Timespec>

perf_context: EK::PerfContext

tick_batch: Vec<PeerTickBatch>

node_start_time: Option<TiInstant>

Implementations

impl<EK, ER, T> PollContext<EK, ER, T> where
    EK: KvEngine,
    ER: RaftEngine, 

pub fn store_id(&self) -> u64

pub fn update_ticks_timeout(&mut self)

impl<EK, ER, T: Transport> PollContext<EK, ER, T> where
    EK: KvEngine,
    ER: RaftEngine, 

fn schedule_store_tick(&self, tick: StoreTick, timeout: Duration)

pub fn handle_stale_msg(
    &mut self,
    msg: &RaftMessage,
    cur_epoch: RegionEpoch,
    need_gc: bool,
    target_region: Option<Region>
)

Trait Implementations

impl<EK, ER, T> HandleRaftReadyContext<<EK as WriteBatchExt>::WriteBatch, <ER as RaftEngine>::LogBatch> for PollContext<EK, ER, T> where
    EK: KvEngine,
    ER: RaftEngine, 

fn wb_mut(&mut self) -> (&mut EK::WriteBatch, &mut ER::LogBatch)

Returns the mutable references of WriteBatch for both KvDB and RaftDB in one interface.

fn kv_wb_mut(&mut self) -> &mut EK::WriteBatch

fn raft_wb_mut(&mut self) -> &mut ER::LogBatch

fn sync_log(&self) -> bool

fn set_sync_log(&mut self, sync: bool)

impl<EK, ER, T> ReadExecutor<EK> for PollContext<EK, ER, T> where
    EK: KvEngine,
    ER: RaftEngine, 

fn get_engine(&self) -> &EK

fn get_snapshot(&mut self, _: Option<ThreadReadId>) -> Arc<EK::Snapshot>

fn get_value(&self, req: &Request, region: &Region) -> Result<Response>

fn execute(
    &mut self,
    msg: &RaftCmdRequest,
    region: &Arc<Region>,
    read_index: Option<u64>,
    ts: Option<ThreadReadId>
) -> ReadResponse<E::Snapshot>