Struct ClusterRunner 

pub struct ClusterRunner<'a> {
    cluster: &'a mut Cluster,
    add_step: Box<dyn Send + FnMut(&ScenarioStep) + 'a>,
    rng: StdRng,
    latest_advance_time: Option<Timestamp>,
}

Fields

cluster: &'a mut Cluster

add_step: Box<dyn Send + FnMut(&ScenarioStep) + 'a>

rng: StdRng

latest_advance_time: Option<Timestamp>

Implementations

impl ClusterRunner<'_>

pub async fn run<EH, AH>(&mut self, __arg1: RunCfg<EH, AH>) -> Result<()>

where EH: FnMut(ClusterNodeId, &State, &Event) -> RunDecision, AH: 'static + Send + FnMut(ClusterNodeId, &State, &NodeTestingService, &ActionWithMeta) -> bool,

Execute cluster in the infinite loop, based on conditions specified in the RunCfg.

impl<'a> ClusterRunner<'a>

pub fn new<F>(cluster: &'a mut Cluster, add_step: F) -> Self

where F: 'a + Send + FnMut(&ScenarioStep),

pub fn node(&self, node_id: ClusterNodeId) -> Option<&Node>

fn node_mut(&mut self, node_id: ClusterNodeId) -> Option<&mut Node>

pub fn ocaml_node(&self, node_id: ClusterOcamlNodeId) -> Option<&OcamlNode>

pub fn nodes_iter(&self) -> impl Iterator<Item = (ClusterNodeId, &Node)>

pub fn ocaml_nodes_iter( &self, ) -> impl Iterator<Item = (ClusterOcamlNodeId, &OcamlNode)>

pub fn daemon_json_gen( &mut self, genesis_timestamp: &str, config: DaemonJsonGenConfig, ) -> DaemonJson

pub fn daemon_json_gen_with_counts( &mut self, genesis_timestamp: &str, whales_n: usize, fish_n: usize, ) -> DaemonJson

pub fn daemon_json_load( &mut self, path: PathBuf, genesis_timestamp: &str, ) -> DaemonJson

pub fn get_initial_time(&self) -> Option<Timestamp>

pub fn set_initial_time(&mut self, initial_time: Timestamp)

pub fn get_account_sec_key( &self, pub_key: &AccountPublicKey, ) -> Option<&AccountSecretKey>

pub fn add_rust_node( &mut self, testing_config: RustNodeTestingConfig, ) -> ClusterNodeId

pub fn add_ocaml_node( &mut self, testing_config: OcamlNodeTestingConfig, ) -> ClusterOcamlNodeId

pub async fn exec_step(&mut self, step: ScenarioStep) -> Result<bool>

async fn exec_step_with_dyn_effects( &mut self, dyn_effects: DynEffects, node_id: ClusterNodeId, step: ScenarioStep, ) -> DynEffects

pub async fn run_until_nodes_synced( &mut self, timeout: Duration, nodes: &[ClusterNodeId], ) -> Result<()>

pub fn pending_events( &mut self, poll: bool, ) -> impl Iterator<Item = (ClusterNodeId, &State, impl Iterator<Item = (PendingEventId, &Event)>)>

pub fn node_pending_events( &mut self, node_id: ClusterNodeId, poll: bool, ) -> Result<(&State, impl Iterator<Item = (PendingEventId, &Event)>)>

pub async fn wait_for_pending_events(&mut self)

pub async fn wait_for_pending_events_with_timeout( &mut self, timeout: Duration, ) -> bool

pub fn debugger(&self) -> Option<&Debugger>

pub fn block_producer_sec_keys( &self, node_id: ClusterNodeId, ) -> Vec<(AccountSecretKey, u64)>

Block producer accounts, ordered by total stake, largest first.

Warning: caller must ensure we are using custom daemon json if this method is called, so that we have secret keys for all block producers.

pub fn accounts_with_sec_keys<'b>( &'b self, node_id: ClusterNodeId, ) -> Box<dyn Iterator<Item = (AccountSecretKey, Box<Account>)> + 'b>

pub async fn produce_blocks_until<F>( &mut self, producer_node: ClusterNodeId, log_tag: &str, timeout: Duration, step_duration: Duration, keep_synced: bool, predicate: F, ) -> u32

where F: Fn(&State, u32, u32) -> bool,

Produces blocks in 5 second run intervals advancing time to the next won slot each time until predicate is true Assumes there is a block producer running in the cluster

pub async fn advance_to_epoch_bounds( &mut self, producer_node: ClusterNodeId, timeout: Duration, step_duration: Duration, ) -> u32

Skip to 3 blocks before the epoch end by advancing time Assumes there is a block producer running in the cluster

pub async fn wait_for_ocaml(&mut self, node_id: ClusterOcamlNodeId)