Struct ClientArgs 

pub(crate) struct ClientArgs {
    pub(crate) headers: Vec<(String, String)>,
    pub(crate) username: Option<String>,
    pub(crate) password: Option<String>,
    pub(crate) token: Option<String>,
    pub(crate) tls: bool,
    pub(crate) key_log: bool,
    pub(crate) host: String,
    pub(crate) port: Option<u16>,
    pub(crate) accept_compression: Vec<CompressionEncoding>,
    pub(crate) send_compression: Option<CompressionEncoding>,
}

Fields

headers: Vec<(String, String)>

Additional headers.

Can be given multiple times. Headers and values are separated by ‘=’.

Example: -H foo=bar -H baz=42

username: Option<String>

Username.

Optional. If given, password must also be set.

password: Option<String>

Password.

Optional. If given, username must also be set.

token: Option<String>

Auth token.

tls: bool

Use TLS.

If not provided, use cleartext connection.

key_log: bool

Dump TLS key log.

The target file is specified by the SSLKEYLOGFILE environment variable.

Requires --tls.

host: String

Server host.

Required.

port: Option<u16>

Server port.

Defaults to 443 if tls is set, otherwise defaults to 80.

accept_compression: Vec<CompressionEncoding>

Compression accepted by the client for responses sent by the server.

The client will send this information to the server as part of the request. The server is free to pick an algorithm from that list or use no compression (called “identity” encoding).

You may define multiple algorithms by using a comma-separated list.

send_compression: Option<CompressionEncoding>

Compression of requests sent by the client to the server.

Since the client needs to decide on the compression before sending the request, there is no client<->server negotiation. If the server does NOT support the chosen compression, it will respond with an error a la:

Ipc error: Status {
    code: Unimplemented,
    message: "Content is compressed with `zstd` which isn't supported",
    metadata: MetadataMap { headers: {"grpc-accept-encoding": "identity", ...} },
    ...
}

Based on the algorithms listed in the grpc-accept-encoding header, you may make a more educated guess for your next request. Note that identity is a synonym for “no compression”.

Trait Implementations

impl Args for ClientArgs

fn group_id() -> Option<Id>

Report the [ArgGroup::id][crate::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 ClientArgs

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 ClientArgs

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

Formats the value using the given formatter.

impl FromArgMatches for ClientArgs

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 ClientArgs

fn parse() -> Self

Parse from std::env::args_os(), [exit][Error::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][Error::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][Error::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.