Struct test_raftstore::Cluster

pub struct Cluster<T: Simulator> {
    pub cfg: TiKvConfig,
    leaders: HashMap<u64, Peer>,
    count: usize,
    pub paths: Vec<TempDir>,
    pub dbs: Vec<Engines<RocksEngine, RocksEngine>>,
    pub store_metas: HashMap<u64, Arc<Mutex<StoreMeta>>>,
    key_managers: Vec<Option<Arc<DataKeyManager>>>,
    pub io_rate_limiter: Option<Arc<IORateLimiter>>,
    pub engines: HashMap<u64, Engines<RocksEngine, RocksEngine>>,
    key_managers_map: HashMap<u64, Option<Arc<DataKeyManager>>>,
    pub labels: HashMap<u64, HashMap<String, String>>,
    pub sim: Arc<RwLock<T>>,
    pub pd_client: Arc<TestPdClient>,
}

Fields

cfg: TiKvConfig

leaders: HashMap<u64, Peer>

count: usize

paths: Vec<TempDir>

dbs: Vec<Engines<RocksEngine, RocksEngine>>

store_metas: HashMap<u64, Arc<Mutex<StoreMeta>>>

key_managers: Vec<Option<Arc<DataKeyManager>>>

io_rate_limiter: Option<Arc<IORateLimiter>>

engines: HashMap<u64, Engines<RocksEngine, RocksEngine>>

key_managers_map: HashMap<u64, Option<Arc<DataKeyManager>>>

labels: HashMap<u64, HashMap<String, String>>

sim: Arc<RwLock<T>>

pd_client: Arc<TestPdClient>

Implementations

impl<T: Simulator> Cluster<T>

pub fn new(
    id: u64,
    count: usize,
    sim: Arc<RwLock<T>>,
    pd_client: Arc<TestPdClient>
) -> Cluster<T>

pub fn take_path(&mut self) -> Vec<TempDir>

pub fn id(&self) -> u64

pub fn pre_start_check(&mut self) -> Result<(), Box<dyn StdError>>

pub fn set_bootstrapped(&mut self, node_id: u64, offset: usize)

Engines in a just created cluster are not bootstraped, which means they are not associated with a node_id. Call Cluster::start can bootstrap all nodes in the cluster.

However sometimes a node can be bootstrapped externally. This function can be called to mark them as bootstrapped in Cluster.

fn create_engine(
    &mut self,
    router: Option<RaftRouter<RocksEngine, RocksEngine>>
)

pub fn create_engines(&mut self)

pub fn start(&mut self) -> ServerResult<()>

pub fn compact_data(&self)

pub fn flush_data(&self)

pub fn run(&mut self)

pub fn run_conf_change(&mut self) -> u64

pub fn get_node_ids(&self) -> HashSet<u64>

pub fn run_node(&mut self, node_id: u64) -> ServerResult<()>

pub fn stop_node(&mut self, node_id: u64)

pub fn get_engine(&self, node_id: u64) -> Arc<DB>

pub fn get_raft_engine(&self, node_id: u64) -> Arc<DB>

pub fn get_all_engines(&self, node_id: u64) -> Engines<RocksEngine, RocksEngine>

pub fn send_raft_msg(&mut self, msg: RaftMessage) -> Result<()>

pub fn call_command_on_node(
    &self,
    node_id: u64,
    request: RaftCmdRequest,
    timeout: Duration
) -> Result<RaftCmdResponse>

pub fn read(
    &self,
    batch_id: Option<ThreadReadId>,
    request: RaftCmdRequest,
    timeout: Duration
) -> Result<RaftCmdResponse>

pub fn call_command(
    &self,
    request: RaftCmdRequest,
    timeout: Duration
) -> Result<RaftCmdResponse>

pub fn call_command_on_leader(
    &mut self,
    request: RaftCmdRequest,
    timeout: Duration
) -> Result<RaftCmdResponse>

fn valid_leader_id(&self, region_id: u64, leader_id: u64) -> bool

fn store_ids_of_region(&self, region_id: u64) -> Option<Vec<u64>>

pub fn query_leader(
    &self,
    store_id: u64,
    region_id: u64,
    timeout: Duration
) -> Option<Peer>

pub fn leader_of_region(&mut self, region_id: u64) -> Option<Peer>

pub fn check_regions_number(&self, len: u32)

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

pub fn bootstrap_region(&mut self) -> Result<()>

Multiple nodes with fixed node id, like node 1, 2, .. 5, First region 1 is in all stores with peer 1, 2, .. 5. Peer 1 is in node 1, store 1, etc.

Must be called after create_engines.

pub fn bootstrap_conf_change(&mut self) -> u64

fn bootstrap_cluster(&mut self, region: Region)

pub fn add_label(&mut self, node_id: u64, key: &str, value: &str)

pub fn add_new_engine(&mut self) -> u64

pub fn reset_leader_of_region(&mut self, region_id: u64)

pub fn assert_quorum<F: FnMut(&Arc<DB>) -> bool>(&self, condition: F)

pub fn shutdown(&mut self)

fn refresh_leader_if_needed(
    &mut self,
    resp: &RaftCmdResponse,
    region_id: u64
) -> bool

pub fn request(
    &mut self,
    key: &[u8],
    reqs: Vec<Request>,
    read_quorum: bool,
    timeout: Duration
) -> RaftCmdResponse

pub fn get_region_with<F>(&self, key: &[u8], filter: F) -> Region where
    F: Fn(&Region) -> bool, 

pub fn get_region(&self, key: &[u8]) -> Region

pub fn get_region_id(&self, key: &[u8]) -> u64

pub fn get_down_peers(&self) -> HashMap<u64, PeerStats>

pub fn get(&mut self, key: &[u8]) -> Option<Vec<u8>>

pub fn get_cf(&mut self, cf: &str, key: &[u8]) -> Option<Vec<u8>>

pub fn must_get(&mut self, key: &[u8]) -> Option<Vec<u8>>

fn get_impl(
    &mut self,
    cf: &str,
    key: &[u8],
    read_quorum: bool
) -> Option<Vec<u8>>

pub fn async_request(
    &mut self,
    req: RaftCmdRequest
) -> Result<Receiver<RaftCmdResponse>>

pub fn async_exit_joint(
    &mut self,
    region_id: u64
) -> Result<Receiver<RaftCmdResponse>>

pub fn async_put(
    &mut self,
    key: &[u8],
    value: &[u8]
) -> Result<Receiver<RaftCmdResponse>>

pub fn async_remove_peer(
    &mut self,
    region_id: u64,
    peer: Peer
) -> Result<Receiver<RaftCmdResponse>>

pub fn async_add_peer(
    &mut self,
    region_id: u64,
    peer: Peer
) -> Result<Receiver<RaftCmdResponse>>

pub fn must_put(&mut self, key: &[u8], value: &[u8])

pub fn must_put_cf(&mut self, cf: &str, key: &[u8], value: &[u8])

pub fn put(&mut self, key: &[u8], value: &[u8]) -> Result<(), PbError>

pub fn must_delete(&mut self, key: &[u8])

pub fn must_delete_cf(&mut self, cf: &str, key: &[u8])

pub fn must_delete_range_cf(&mut self, cf: &str, start: &[u8], end: &[u8])

pub fn must_notify_delete_range_cf(
    &mut self,
    cf: &str,
    start: &[u8],
    end: &[u8]
)

pub fn must_flush_cf(&mut self, cf: &str, sync: bool)

pub fn get_region_epoch(&self, region_id: u64) -> RegionEpoch

pub fn region_detail(
    &self,
    region_id: u64,
    store_id: u64
) -> RegionDetailResponse

pub fn truncated_state(
    &self,
    region_id: u64,
    store_id: u64
) -> RaftTruncatedState

pub fn wait_log_truncated(&self, region_id: u64, store_id: u64, index: u64)

pub fn apply_state(&self, region_id: u64, store_id: u64) -> RaftApplyState

pub fn raft_local_state(&self, region_id: u64, store_id: u64) -> RaftLocalState

pub fn region_local_state(
    &self,
    region_id: u64,
    store_id: u64
) -> RegionLocalState

pub fn wait_last_index(
    &mut self,
    region_id: u64,
    store_id: u64,
    expected: u64,
    timeout: Duration
)

pub fn restore_kv_meta(
    &self,
    region_id: u64,
    store_id: u64,
    snap: &RocksSnapshot
)

pub fn restore_raft(&self, region_id: u64, store_id: u64, snap: &RocksSnapshot)

pub fn add_send_filter<F: FilterFactory>(&self, factory: F)

pub fn transfer_leader(&mut self, region_id: u64, leader: Peer)

pub fn must_transfer_leader(&mut self, region_id: u64, leader: Peer)

pub fn get_snap_dir(&self, node_id: u64) -> String

pub fn get_snap_mgr(&self, node_id: u64) -> SnapManager

pub fn clear_send_filters(&mut self)

pub fn split_region(
    &mut self,
    region: &Region,
    split_key: &[u8],
    cb: Callback<RocksSnapshot>
)

pub fn must_split(&mut self, region: &Region, split_key: &[u8])

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

pub fn wait_region_split_max_cnt(
    &mut self,
    region: &Region,
    itvl_ms: u64,
    max_try_cnt: u64,
    is_panic: bool
)

fn new_prepare_merge(&self, source: u64, target: u64) -> RaftCmdRequest

pub fn merge_region(
    &mut self,
    source: u64,
    target: u64,
    cb: Callback<RocksSnapshot>
)

pub fn try_merge(&mut self, source: u64, target: u64) -> RaftCmdResponse

pub fn must_try_merge(&mut self, source: u64, target: u64)

pub fn must_region_exist(&mut self, region_id: u64, store_id: u64)

Make sure region exists on that store.

pub fn must_region_not_exist(&mut self, region_id: u64, store_id: u64)

Make sure region not exists on that store.

pub fn must_remove_region(&mut self, store_id: u64, region_id: u64)

pub fn partition(&self, s1: Vec<u64>, s2: Vec<u64>)

pub fn must_request_snapshot(&self, store_id: u64, region_id: u64) -> u64

Trait Implementations

impl<T: Simulator> Drop for Cluster<T>

fn drop(&mut self)

Executes the destructor for this type.