Struct Args

pub(crate) struct Args {

    pub(crate) bootstrap_server: String,
    pub(crate) schema_registry_url: Url,
    pub(crate) topic: String,
    pub(crate) num_records: usize,
    pub(crate) partitions_round_robin: usize,
    pub(crate) threads: usize,
    pub(crate) key_format: KeyFormat,
    pub(crate) key_min: Option<u64>,
    pub(crate) key_max: Option<u64>,
    pub(crate) avro_key_schema: Option<Schema>,
    pub(crate) avro_key_distribution: Option<Value>,
    pub(crate) value_format: ValueFormat,
    pub(crate) min_value_size: Option<usize>,
    pub(crate) max_value_size: Option<usize>,
    pub(crate) avro_value_schema: Option<Schema>,
    pub(crate) avro_value_distribution: Option<Value>,
    pub(crate) quiet: bool,
}

Write random data to Kafka.

Fields

bootstrap_server: String

Address of one or more Kafka nodes, comma separated, in the Kafka cluster to connect to.

schema_registry_url: Url

URL of the schema registry to connect to, if using Avro keys or values.

topic: String

Topic into which to write records.

num_records: usize

Number of records to write.

partitions_round_robin: usize

Number of partitions over which records should be distributed in a round-robin fashion, regardless of the value of the keys of these records.

The default value, 0, indicates that Kafka’s default strategy of distributing writes based upon the hash of their keys should be used instead.

threads: usize

The number of threads to use.

If zero, uses the number of physical CPUs on the machine.

key_format: KeyFormat

Format in which to generate keys.

key_min: Option<u64>

Minimum key value to generate, if using random-formatted keys.

key_max: Option<u64>

Maximum key value to generate, if using random-formatted keys.

avro_key_schema: Option<Schema>

Schema describing Avro key data to randomly generate, if using Avro-formatted keys.

avro_key_distribution: Option<Value>

JSON object describing the distribution parameters for each field of the Avro key object, if using Avro-formatted keys.

value_format: ValueFormat

Format in which to generate values.

min_value_size: Option<usize>

Minimum value size to generate, if using bytes-formatted values.

max_value_size: Option<usize>

Maximum value size to generate, if using bytes-formatted values.

avro_value_schema: Option<Schema>

Schema describing Avro value data to randomly generate, if using Avro-formatted values.

avro_value_distribution: Option<Value>

JSON object describing the distribution parameters for each field of the Avro value object, if using Avro-formatted keys.

quiet: bool

Suppress printing progress messages.

Trait Implementations

impl Args for Args

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 CommandFactory for Args

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 FromArgMatches for Args

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 Args

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.