Enum NetCommand

pub enum NetCommand {
    Up {

        other_initial_chains: u32,
        initial_amount: u128,
        validators: usize,
        proxies: usize,
        shards: usize,
        policy_config: ResourceControlPolicyConfig,
        cross_chain_config: CrossChainConfig,
        testing_prng_seed: Option<u64>,
        kubernetes: bool,
        binaries: Option<Option<PathBuf>>,
        no_build: bool,
        docker_image_name: String,
        build_mode: BuildMode,
        path: Option<String>,
        external_protocol: String,
        with_faucet: bool,
        faucet_chain: Option<u32>,
        faucet_port: NonZeroU16,
        faucet_amount: Amount,
        with_block_exporter: bool,
        num_block_exporters: usize,
        exporter_address: String,
        exporter_port: NonZeroU16,
        indexer_image_name: String,
        explorer_image_name: String,
        dual_store: bool,
    
},
    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.

proxies: usize

The number of proxies in the local test network.

shards: usize

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

policy_config: ResourceControlPolicyConfig

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

cross_chain_config: CrossChainConfig

The configuration for cross-chain messages.

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.

build_mode: BuildMode

The build mode 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.

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 the first non-admin chain if not provided.

faucet_chain: Option<u32>

When using –with-faucet, this specifies the chain on which the faucet will be started. If this is n, the n-th non-admin chain (lexicographically) in the wallet is selected.

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.

with_block_exporter: bool

Whether to start a block exporter for each validator.

num_block_exporters: usize

The number of block exporters to start.

exporter_address: String

The address of the block exporter.

exporter_port: NonZeroU16

The port on which to run the block exporter.

indexer_image_name: String

The name of the indexer docker image to use.

explorer_image_name: String

The name of the explorer docker image to use.

dual_store: bool

Use dual store (rocksdb and scylladb) instead of just scylladb. This is exclusive for kubernetes deployments.

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