Enum linera_client::client_options::NetCommand

pub enum NetCommand {
    Up {

        other_initial_chains: u32,
        initial_amount: u128,
        validators: usize,
        shards: usize,
        policy_config: ResourceControlPolicyConfig,
        testing_prng_seed: Option<u64>,
        kubernetes: bool,
        binaries: Option<Option<PathBuf>>,
        no_build: bool,
        docker_image_name: String,
        path: Option<String>,
        storage: Option<String>,
        external_protocol: String,
        with_faucet: bool,
        faucet_chain: Option<u32>,
        faucet_port: NonZeroU16,
        faucet_amount: Amount,
    
},
    Helper,
}

Variants

Up

Start a Local Linera Network

Fields

other_initial_chains: u32

The number of initial “root” chains created in the genesis config on top of the default “admin” chain. All initial chains belong to the first “admin” wallet. It is recommended to use at least one other initial chain for the faucet.

initial_amount: u128

The initial amount of native tokens credited in the initial “root” chains, including the default “admin” chain.

validators: usize

The number of validators in the local test network. Default is 1.

shards: usize

The number of shards per validator in the local test network. Default is 1.

policy_config: ResourceControlPolicyConfig

Configure the resource control policy (notably fees) according to pre-defined settings.

testing_prng_seed: Option<u64>

Force this wallet to generate keys using a PRNG and a given seed. USE FOR TESTING ONLY.

kubernetes: bool

Start the local network on a local Kubernetes deployment.

binaries: Option<Option<PathBuf>>

If this is not set, we’ll build the binaries from within the Docker container If it’s set, but with no directory path arg, we’ll look for the binaries based on current_binary_parent If it’s set, but with a directory path arg, we’ll get the binaries from that path directory

no_build: bool

Don’t build docker image. This assumes that the image is already built.

docker_image_name: String

The name of the docker image to use.

path: Option<String>

Run with a specific path where the wallet and validator input files are. If none, then a temporary directory is created.

storage: Option<String>

Run with a specific storage. If none, then a linera-storage-service is started on a random free port.

external_protocol: String

External protocol used, either grpc or grpcs.

with_faucet: bool

If present, a faucet is started using the chain provided by –faucet-chain, or ChainId::root(1) if not provided, as root 0 is usually the admin chain.

faucet_chain: Option<u32>

When using –with-faucet, this specifies the chain on which the faucet will be started. The chain is specified by its root number (0 for the admin chain, 1 for the first non-admin initial chain, etc).

faucet_port: NonZeroU16

The port on which to run the faucet server

faucet_amount: Amount

The number of tokens to send to each new chain created by the faucet.

Helper

Print a bash helper script to make linera net up easier to use. The script is meant to be installed in ~/.bash_profile or sourced when needed.

Trait Implementations

impl Clone for NetCommand

fn clone(&self) -> NetCommand

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CommandFactory for NetCommand

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 NetCommand

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 Parser for NetCommand

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 Subcommand for NetCommand

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