Struct raftstore::store::peer_storage::PeerStorage

pub struct PeerStorage<EK, ER> where
    EK: KvEngine,  {
    pub engines: Engines<EK, ER>,
    peer_id: u64,
    region: Region,
    raft_state: RaftLocalState,
    apply_state: RaftApplyState,
    applied_index_term: u64,
    last_term: u64,
    snap_state: RefCell<SnapState>,
    gen_snap_task: RefCell<Option<GenSnapTask>>,
    region_sched: Scheduler<RegionTask<EK::Snapshot>>,
    snap_tried_cnt: RefCell<usize>,
    cache: Option<EntryCache>,
    pub tag: String,
}

Fields

engines: Engines<EK, ER>

peer_id: u64

region: Region

raft_state: RaftLocalState

apply_state: RaftApplyState

applied_index_term: u64

last_term: u64

snap_state: RefCell<SnapState>

gen_snap_task: RefCell<Option<GenSnapTask>>

region_sched: Scheduler<RegionTask<EK::Snapshot>>

snap_tried_cnt: RefCell<usize>

cache: Option<EntryCache>

tag: String

Implementations

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

pub fn new(
    engines: Engines<EK, ER>,
    region: &Region,
    region_sched: Scheduler<RegionTask<EK::Snapshot>>,
    peer_id: u64,
    tag: String
) -> Result<PeerStorage<EK, ER>>

pub fn is_initialized(&self) -> bool

pub fn initial_state(&self) -> Result<RaftState>

fn check_range(&self, low: u64, high: u64) -> Result<()>

pub fn entries(&self, low: u64, high: u64, max_size: u64) -> Result<Vec<Entry>>

pub fn term(&self, idx: u64) -> Result<u64>

pub fn first_index(&self) -> u64

pub fn last_index(&self) -> u64

pub fn last_term(&self) -> u64

pub fn applied_index(&self) -> u64

pub fn set_applied_state(&mut self, apply_state: RaftApplyState)

pub fn set_applied_term(&mut self, applied_index_term: u64)

pub fn apply_state(&self) -> &RaftApplyState

pub fn applied_index_term(&self) -> u64

pub fn commit_index(&self) -> u64

pub fn set_commit_index(&mut self, commit: u64)

pub fn hard_state(&self) -> &HardState

pub fn truncated_index(&self) -> u64

pub fn truncated_term(&self) -> u64

pub fn region(&self) -> &Region

pub fn set_region(&mut self, region: Region)

pub fn raw_snapshot(&self) -> EK::Snapshot

fn validate_snap(&self, snap: &Snapshot, request_index: u64) -> bool

pub fn snapshot(&self, request_index: u64) -> Result<Snapshot>

Gets a snapshot. Returns SnapshotTemporarilyUnavailable if there is no unavailable snapshot.

pub fn has_gen_snap_task(&self) -> bool

pub fn mut_gen_snap_task(&mut self) -> &mut Option<GenSnapTask>

pub fn take_gen_snap_task(&mut self) -> Option<GenSnapTask>

pub fn append<H: HandleRaftReadyContext<EK::WriteBatch, ER::LogBatch>>(
    &mut self,
    invoke_ctx: &mut InvokeContext,
    entries: Vec<Entry>,
    ready_ctx: &mut H
) -> Result<u64>

pub fn compact_to(&mut self, idx: u64)

pub fn is_cache_empty(&self) -> bool

pub fn maybe_gc_cache(&mut self, replicated_idx: u64, apply_idx: u64)

pub fn flush_cache_metrics(&mut self)

pub fn apply_snapshot(
    &mut self,
    ctx: &mut InvokeContext,
    snap: &Snapshot,
    kv_wb: &mut EK::WriteBatch,
    raft_wb: &mut ER::LogBatch,
    destroy_regions: &[Region]
) -> Result<()>

pub fn clear_meta(
    &mut self,
    kv_wb: &mut EK::WriteBatch,
    raft_wb: &mut ER::LogBatch
) -> Result<()>

Delete all meta belong to the region. Results are stored in wb.

pub fn clear_data(&self) -> Result<()>

Delete all data belong to the region. If return Err, data may get partial deleted.

fn clear_extra_data(
    &self,
    old_region: &Region,
    new_region: &Region
) -> Result<()>

Delete all data that is not covered by new_region.

pub fn clear_extra_split_data(
    &self,
    start_key: Vec<u8>,
    end_key: Vec<u8>
) -> Result<()>

Delete all extra split data from the start_key to end_key.

pub fn get_raft_engine(&self) -> ER

pub fn is_applying_snapshot(&self) -> bool

Check whether the storage has finished applying snapshot.

pub fn is_generating_snapshot(&self) -> bool

pub fn check_applying_snap(&mut self) -> CheckApplyingSnapStatus

Check if the storage is applying a snapshot.

pub fn cancel_applying_snap(&mut self) -> bool

Cancel applying snapshot, return true if the job can be considered not be run again.

pub fn cancel_generating_snap(&mut self, compact_to: Option<u64>)

Cancel generating snapshot.

pub fn set_snap_state(&mut self, state: SnapState)

pub fn is_snap_state(&self, state: SnapState) -> bool

pub fn get_region_id(&self) -> u64

pub fn schedule_applying_snapshot(&mut self)

pub fn handle_raft_ready<H: HandleRaftReadyContext<EK::WriteBatch, ER::LogBatch>>(
    &mut self,
    ready_ctx: &mut H,
    ready: &mut Ready,
    destroy_regions: Vec<Region>
) -> Result<InvokeContext>

Save memory states to disk.

This function only write data to ready_ctx’s WriteBatch. It’s caller’s duty to write it explicitly to disk. If it’s flushed to disk successfully, post_ready should be called to update the memory states properly. WARNING: If this function returns error, the caller must panic(details in append function).

pub fn post_ready(&mut self, ctx: InvokeContext) -> Option<ApplySnapResult>

Update the memory state after ready changes are flushed to disk successfully.

Trait Implementations

impl<EK, ER> Storage for PeerStorage<EK, ER> where
    EK: KvEngine,
    ER: RaftEngine, 

fn initial_state(&self) -> Result<RaftState>

initial_state is called when Raft is initialized. This interface will return a RaftState which contains HardState and ConfState.

fn entries(
    &self,
    low: u64,
    high: u64,
    max_size: impl Into<Option<u64>>
) -> Result<Vec<Entry>>

Returns a slice of log entries in the range [low, high). max_size limits the total size of the log entries returned if not None, however the slice of entries returned will always have length at least 1 if entries are found in the range.

fn term(&self, idx: u64) -> Result<u64>

Returns the term of entry idx, which must be in the range [first_index()-1, last_index()]. The term of the entry before first_index is retained for matching purpose even though the rest of that entry may not be available.

fn first_index(&self) -> Result<u64>

Returns the index of the first log entry that is possible available via entries, which will always equal to truncated index plus 1.

fn last_index(&self) -> Result<u64>

The index of the last entry replicated in the Storage.

fn snapshot(&self, request_index: u64) -> Result<Snapshot>

Returns the most recent snapshot.