Struct ChunkedCommand 

pub struct ChunkedCommand {

    pub target: Option<String>,
    pub targets_file: Option<PathBuf>,
    pub max_concurrency: u32,
    pub spec: Option<PathBuf>,
    pub base_path: Option<String>,
    pub operation_id: Option<String>,
    pub method: String,
    pub concurrency: u32,
    pub duration: Duration,
    pub chunk_size_bytes: usize,
    pub total_size_bytes: usize,
    pub raw_body: bool,
    pub chunk_interval_ms: u64,
    pub headers: HashMap<String, String>,
    pub insecure: bool,
    pub validate_requests: bool,
    pub export_requests: bool,
    pub output: PathBuf,
    pub rps: Option<u32>,
    pub cps: bool,
    pub rounds: Option<u32>,
    pub repeat_until: Option<Duration>,
    pub keep_rounds: Option<u32>,
    pub request_timeout: Option<Duration>,
    pub overlap_operations: bool,
}

Options shared by every bench-chunked mode.

Fields

target: Option<String>

Single target URL. Mutually exclusive with targets_file.

targets_file: Option<PathBuf>

File with multiple targets (same format as bench --targets-file).

max_concurrency: u32

Max targets running at once in multi-target mode.

spec: Option<PathBuf>

base_path: Option<String>

operation_id: Option<String>

method: String

concurrency: u32

duration: Duration

chunk_size_bytes: usize

total_size_bytes: usize

raw_body: bool

Send raw X filler regardless of the declared Content-Type.

chunk_interval_ms: u64

headers: HashMap<String, String>

insecure: bool

validate_requests: bool

export_requests: bool

output: PathBuf

rps: Option<u32>

Per-target cap on request starts per second (shared by its workers).

cps: bool

New TCP/TLS connection per request, so connections/s = requests/s.

rounds: Option<u32>

Campaign: run the whole plan this many times.

repeat_until: Option<Duration>

Campaign: keep starting new rounds until this much wall clock elapsed.

keep_rounds: Option<u32>

Campaign: keep only the newest N round_* dirs.

request_timeout: Option<Duration>

Per-request timeout. None derives one from the body size and chunk pacing (ChunkedBenchConfig::auto_request_timeout); zero disables it.

overlap_operations: bool

Spec mode: start each operation as soon as the previous one’s load window closes, instead of after its in-flight uploads finish, so the start rate stays continuous across operations.

Implementations

impl ChunkedCommand

pub async fn execute(&self) -> Result<bool>

Run the bench. Returns Ok(true) when every run completed, Ok(false) when at least one operation or target failed to run.

Trait Implementations

impl Clone for ChunkedCommand

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ChunkedCommand

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

Formats the value using the given formatter.