Struct Benchmark 

pub struct Benchmark {

    pub address: String,
    pub public_key: Option<ValidatorPublicKey>,
    pub chain: Vec<ChainId>,
    pub skip_preflight: bool,
    pub skip_read_baseline: bool,
    pub skip_read_stress: bool,
    pub skip_bulk_download: bool,
    pub skip_tip_lag: bool,
    pub deep: bool,
    pub baseline_requests: usize,
    pub stress_levels: Vec<usize>,
    pub stress_duration_secs: u64,
    pub bulk_batch_size: u32,
    pub bulk_concurrency: Vec<usize>,
    pub bulk_height_range: String,
    pub tip_lag_samples: usize,
    pub tip_lag_interval_secs: u64,
    pub deep_blocks: u32,
    pub deep_chain: Option<ChainId>,
    pub output: Vec<String>,
    pub observer_location: String,
    pub no_progress: bool,
    pub rpc_timeout_secs: u64,
    pub abort_on_preflight_fail: bool,
}

Multi-layer pre-onboarding benchmark for a single candidate validator.

Probes the candidate across read-side primitives (preflight, baseline, concurrency ramp, bulk download, tip lag) and emits a structured report. The optional --deep layer additionally exercises the write path by syncing a bounded number of blocks; it has a stateful side effect on the candidate and is therefore off by default.

PREREQUISITE: the read layers are only meaningful if the candidate already holds the --chain you pass. A not-yet-committee candidate may hold no blocks; in that case pre-sync it (linera validator sync) or pass --deep, which seeds the blocks first (and is run before the read layers). The tool warns when a chain is not held.

Fields

address: String

Network address of the candidate validator (e.g. grpcs://host:port).

public_key: Option<ValidatorPublicKey>

Expected public key of the validator (identity verification).

chain: Vec<ChainId>

Chain to exercise. Repeat for multiple chains. At least one required.

skip_preflight: bool

Skip L1 preflight (version, network description, RTT).

skip_read_baseline: bool

Skip L3 read latency baseline.

skip_read_stress: bool

Skip L4 read stress (concurrency ramp).

skip_bulk_download: bool

Skip L5 bulk certificate download.

skip_tip_lag: bool

Skip L6 tip-lag snapshot.

deep: bool

L2 partial sync (seed): sync a bounded run of blocks into the candidate, run before the read layers so they exercise real data. Stateful side effect on the candidate; off by default.

baseline_requests: usize

Number of sequential chain-info queries per chain in L3.

stress_levels: Vec<usize>

Concurrency levels for the L4 ramp.

stress_duration_secs: u64

Seconds to sustain each L4 concurrency level.

bulk_batch_size: u32

Number of heights per L5 download batch.

bulk_concurrency: Vec<usize>

Concurrency levels for L5 bulk download.

bulk_height_range: String

Either auto (last batch_size * 100 heights up to the candidate’s tip) or an explicit FROM:TO range.

tip_lag_samples: usize

Number of tip-lag samples in L6.

tip_lag_interval_secs: u64

Seconds between L6 tip-lag samples.

deep_blocks: u32

Maximum number of blocks to seed in L2 partial sync (with --deep).

deep_chain: Option<ChainId>

Chain to use for the L2 partial-sync seed (defaults to the first --chain).

output: Vec<String>

Output spec, repeatable; or comma/+-separated within a single value. SPEC: <format> (stdout) or <format>:<path> (file). Formats: json, yaml, md, brief. Default if omitted: md to stdout.

observer_location: String

Free-form tag carried in the report (e.g. OVH US-EAST).

no_progress: bool

Disable the interactive progress UI (auto-disabled when stderr is not a TTY).

rpc_timeout_secs: u64

Per-RPC timeout in seconds. A call that exceeds it is recorded as a timeout error and the run keeps going, so a hung validator never blocks.

abort_on_preflight_fail: bool

Abort the run if preflight fails (default: continue and report).

Implementations

impl Benchmark

pub async fn run( &self, context: &mut ClientContext<impl Environment<ValidatorNode = Client>>, ) -> Result<()>

Trait Implementations

impl Args for Benchmark

fn group_id() -> Option<Id>

Report the ArgGroup::id for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

impl Clone for Benchmark

fn clone(&self) -> Benchmark

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CommandFactory for Benchmark

fn command<'b>() -> Command

Build a Command that can instantiate Self.

fn command_for_update<'b>() -> Command

Build a Command that can update self.

impl Debug for Benchmark

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromArgMatches for Benchmark

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Parser for Benchmark

fn parse() -> Self

Parse from std::env::args_os(), exit on error.

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, exit on error.

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, return Err on error.

fn update_from<I, T>(&mut self, itr: I)

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, exit on error.

fn try_update_from<I, T>(&mut self, itr: I) -> Result<(), Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, return Err on error.

impl Serialize for Benchmark

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.