Enum Commands 

enum Commands {
    Client {
        host: String,
    },
    Daemon {},
    GenerateConfig {
        ssh_config_path: Option<String>,
        program: Option<String>,
        arguments: Vec<String>,
        cluster: String,
        output: Option<String>,
    },
}

The command CLI subcommand

Variants

Client

Subcommand that will launch a single client window

connecting to the given host with the given username. It will also try to read input from a daemon via the named pipe.

Fields

host: String

Host to connect to

Daemon

Subcommand that will launch the daemon window.

The daemon is responsible to launch the client windows, one for each given host. For each client a named pipe will be created and any keystrokes the daemon window receives are forwarded via the pipes to all the clients. Also handles control mode.

GenerateConfig

Write a default config file at the given output path.

Values that differ from the defaults can be set via the options.

Fields

ssh_config_path: Option<String>

Path to an SSH config file. When set, the launched program receives -F <PATH> as the first two argv entries.

program: Option<String>

Program launched to establish each SSH connection. Defaults to the client.program config default when unset.

arguments: Vec<String>

Program arguments written to client.arguments, replacing the default bare <user>@<host> placeholder; repeatable and must include it. Use the --arguments=VALUE form for values starting with -, e.g. --arguments=-XY --arguments={{USERNAME_AT_HOST}}.

cluster: String

Name of the single cluster written to the config.

output: Option<String>

Path of the config file to write. Defaults to cssh-rs-config.toml next to the running executable.

Trait Implementations

impl Debug for Commands

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

Formats the value using the given formatter.

impl FromArgMatches for Commands

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<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl PartialEq for Commands

fn eq(&self, other: &Commands) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Subcommand for Commands

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

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

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

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

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand

impl StructuralPartialEq for Commands