Struct Cli

pub struct Cli<C: ChainSpecParser = EthereumChainSpecParser, Ext: Args + Debug = NoArgs> {
    pub command: Commands<C, Ext>,
    pub chain: Arc<C::ChainSpec>,
    pub instance: u16,
    pub logs: LogArgs,
}

The main reth cli interface.

This is the entrypoint to the executable.

Fields

command: Commands<C, Ext>

The command to run

chain: Arc<C::ChainSpec>

The chain this node is running.

Possible values are either a built-in chain or the path to a chain specification file.

instance: u16

Add a new instance of a node.

Configures the ports of the node to avoid conflicts with the defaults. This is useful for running multiple nodes on the same machine.

Max number of instances is 200. It is chosen in a way so that it’s not possible to have port numbers that conflict with each other.

Changes to the following port numbers:

• DISCOVERY_PORT: default + instance - 1
• AUTH_PORT: default + instance * 100 - 100
• HTTP_RPC_PORT: default - instance + 1
• WS_RPC_PORT: default + instance * 2 - 2

logs: LogArgs

The logging configuration for the CLI.

Implementations

impl Cli

pub fn parse_args() -> Self

Parsers only the default CLI arguments

pub fn try_parse_args_from<I, T>(itr: I) -> Result<Self, Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parsers only the default CLI arguments from the given iterator

impl<C: ChainSpecParser<ChainSpec = ChainSpec>, Ext: Args + Debug> Cli<C, Ext>

pub fn run<L, Fut>(self, launcher: L) -> Result<()>

where L: FnOnce(WithLaunchContext<NodeBuilder<Arc<DatabaseEnv>, C::ChainSpec>>, Ext) -> Fut, Fut: Future<Output = Result<()>>,

Execute the configured cli command.

This accepts a closure that is used to launch the node via the NodeCommand.

Example

use reth::cli::Cli;
use reth_node_ethereum::EthereumNode;

Cli::parse_args()
    .run(|builder, _| async move {
        let handle = builder.launch_node(EthereumNode::default()).await?;

        handle.wait_for_node_exit().await
    })
    .unwrap();

Example

Parse additional CLI arguments for the node command and use it to configure the node.

use clap::Parser;
use reth::cli::Cli;
use reth_ethereum_cli::chainspec::EthereumChainSpecParser;

#[derive(Debug, Parser)]
pub struct MyArgs {
    pub enable: bool,
}

Cli::<EthereumChainSpecParser, MyArgs>::parse()
    .run(|builder, my_args: MyArgs| async move {
        // launch the node

        Ok(())
    })
    .unwrap();

pub fn init_tracing(&self) -> Result<Option<FileWorkerGuard>>

Initializes tracing with the configured options.

If file logging is enabled, this function returns a guard that must be kept alive to ensure that all logs are flushed to disk.

Trait Implementations

impl<C: ChainSpecParser, Ext: Args + Debug> Args for Cli<C, Ext>

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<C: ChainSpecParser, Ext: Args + Debug> CommandFactory for Cli<C, Ext>

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<C: Debug + ChainSpecParser, Ext: Debug + Args + Debug> Debug for Cli<C, Ext>

where C::ChainSpec: Debug,

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

Formats the value using the given formatter.

impl<C: ChainSpecParser, Ext: Args + Debug> FromArgMatches for Cli<C, Ext>

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<C: ChainSpecParser, Ext: Args + Debug> Parser for Cli<C, Ext>

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.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 720 bytes