Struct tikv::server::node::Node

pub struct Node<C: PdClient + 'static, ER: RaftEngine> {
    cluster_id: u64,
    store: Store,
    store_cfg: Arc<VersionTrack<StoreConfig>>,
    system: RaftBatchSystem<RocksEngine, ER>,
    has_started: bool,
    pd_client: Arc<C>,
    state: Arc<Mutex<GlobalReplicationState>>,
    bg_worker: Worker,
}

A wrapper for the raftstore which runs Multi-Raft.

Fields

cluster_id: u64

store: Store

store_cfg: Arc<VersionTrack<StoreConfig>>

system: RaftBatchSystem<RocksEngine, ER>

has_started: bool

pd_client: Arc<C>

state: Arc<Mutex<GlobalReplicationState>>

bg_worker: Worker

Implementations

impl<C, ER> Node<C, ER> where
    C: PdClient,
    ER: RaftEngine, 

pub fn new(
    system: RaftBatchSystem<RocksEngine, ER>,
    cfg: &ServerConfig,
    store_cfg: Arc<VersionTrack<StoreConfig>>,
    pd_client: Arc<C>,
    state: Arc<Mutex<GlobalReplicationState>>,
    bg_worker: Worker
) -> Node<C, ER>

Creates a new Node.

pub fn try_bootstrap_store(
    &mut self,
    engines: Engines<RocksEngine, ER>
) -> Result<()>

pub fn start<T>(
    &mut self,
    engines: Engines<RocksEngine, ER>,
    trans: T,
    snap_mgr: SnapManager,
    pd_worker: FutureWorker<PdTask<RocksEngine>>,
    store_meta: Arc<Mutex<StoreMeta>>,
    coprocessor_host: CoprocessorHost<RocksEngine>,
    importer: Arc<SSTImporter>,
    split_check_scheduler: Scheduler<SplitCheckTask>,
    auto_split_controller: AutoSplitController,
    concurrency_manager: ConcurrencyManager
) -> Result<()> where
    T: Transport + 'static, 

Starts the Node. It tries to bootstrap cluster if the cluster is not bootstrapped yet. Then it spawns a thread to run the raftstore in background.

pub fn id(&self) -> u64

Gets the store id.

pub fn get_router(&self) -> RaftRouter<RocksEngine, ER>

Gets a transmission end of a channel which is used to send Msg to the raftstore.

pub fn get_apply_router(&self) -> ApplyRouter<RocksEngine>

Gets a transmission end of a channel which is used send messages to apply worker.

fn check_store(&self, engines: &Engines<RocksEngine, ER>) -> Result<u64>

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

fn load_all_stores(&mut self, status: Option<ReplicationStatus>)

fn check_or_prepare_bootstrap_cluster(
    &self,
    engines: &Engines<RocksEngine, ER>,
    store_id: u64
) -> Result<Option<Region>>

fn bootstrap_cluster(
    &mut self,
    engines: &Engines<RocksEngine, ER>,
    first_region: Region
) -> Result<()>

fn check_cluster_bootstrapped(&self) -> Result<bool>

fn start_store<T>(
    &mut self,
    store_id: u64,
    engines: Engines<RocksEngine, ER>,
    trans: T,
    snap_mgr: SnapManager,
    pd_worker: FutureWorker<PdTask<RocksEngine>>,
    store_meta: Arc<Mutex<StoreMeta>>,
    coprocessor_host: CoprocessorHost<RocksEngine>,
    importer: Arc<SSTImporter>,
    split_check_scheduler: Scheduler<SplitCheckTask>,
    auto_split_controller: AutoSplitController,
    concurrency_manager: ConcurrencyManager
) -> Result<()> where
    T: Transport + 'static, 

fn stop_store(&mut self, store_id: u64)

pub fn stop(&mut self)

Stops the Node.