Struct narwhal_test_utils::cluster::Cluster

pub struct Cluster {
    pub committee_shared: SharedCommittee,
    pub worker_cache_shared: SharedWorkerCache,
    /* private fields */
}

Fields

committee_shared: SharedCommittee

worker_cache_shared: SharedWorkerCache

Implementations

impl Cluster

pub fn new(
    parameters: Option<Parameters>,
    internal_consensus_enabled: bool
) -> Self

Initialises a new cluster by the provided parameters. The cluster will create all the authorities (primaries & workers) that are defined under the committee structure, but none of them will be started.

When the internal_consensus_enabled is true then the standard internal consensus engine will be enabled. If false, then the internal consensus will be disabled and the gRPC server will be enabled to manage the Collections & the DAG externally.

pub async fn start(
    &mut self,
    authorities_number: Option<usize>,
    workers_per_authority: Option<usize>,
    boot_wait_time: Option<Duration>
)

Starts a cluster by the defined number of authorities. The authorities will be started sequentially started from the one with id zero up to the provided number authorities_number. If none number is provided, then the maximum number of authorities will be started. If a number higher than the available ones in the committee is provided then the method will panic. The workers_per_authority dictates how many workers per authority should also be started (the same number will be started for each authority). If none is provided then the maximum number of workers will be started. If the boot_wait_time is provided then between node starts we’ll wait for this time before the next node is started. This is useful to simulate staggered node starts. If none is provided then the nodes will be started immediately the one after the other.

pub async fn start_node(
    &mut self,
    id: usize,
    preserve_store: bool,
    workers_per_authority: Option<usize>
)

Starts the authority node by the defined id - if not already running - and the details are returned. If the node is already running then a panic is thrown instead. When the preserve_store is true, then the started authority will use the same path that has been used the last time when started (both the primary and the workers). This is basically a way to use the same storage between node restarts. When the preserve_store is false, then authority will start with an empty storage. If the workers_per_authority is provided then the corresponding number of workers will be started per authority. Otherwise if not provided, then maximum number of workers will be started per authority.

pub async fn stop_node(&self, id: usize)

This method stops the authority (both the primary and the worker nodes) with the provided id.

pub async fn authorities(&self) -> Vec<AuthorityDetails>

Returns all the running authorities. Any authority that:

• has been started ever
• or has been stopped will not be returned by this method.

pub fn authority(&self, id: usize) -> AuthorityDetails

Returns the authority identified by the provided id. Will panic if the authority with the id is not found. The returned authority can be freely cloned and managed without having the need to fetch again.

pub async fn assert_progress(
    &self,
    expected_nodes: u64,
    commit_threshold: u64
) -> HashMap<usize, u64>

This method asserts the progress of the cluster. expected_nodes: Nodes expected to have made progress. Any number different than that will make the assertion fail. commit_threshold: The acceptable threshold between the minimum and maximum reported commit value from the nodes.