Struct sc_cli::RunCmd

pub struct RunCmd {

    pub validator: bool,
    pub no_grandpa: bool,
    pub light: bool,
    pub rpc_external: bool,
    pub unsafe_rpc_external: bool,
    pub rpc_methods: RpcMethods,
    pub ws_external: bool,
    pub unsafe_ws_external: bool,
    pub rpc_max_payload: Option<usize>,
    pub prometheus_external: bool,
    pub ipc_path: Option<String>,
    pub rpc_port: Option<u16>,
    pub ws_port: Option<u16>,
    pub ws_max_connections: Option<usize>,
    pub rpc_http_threads: Option<usize>,
    pub rpc_cors: Option<Cors>,
    pub prometheus_port: Option<u16>,
    pub no_prometheus: bool,
    pub name: Option<String>,
    pub no_telemetry: bool,
    pub telemetry_endpoints: Vec<(String, u8)>,
    pub offchain_worker_params: OffchainWorkerParams,
    pub shared_params: SharedParams,
    pub import_params: ImportParams,
    pub network_params: NetworkParams,
    pub pool_config: TransactionPoolParams,
    pub alice: bool,
    pub bob: bool,
    pub charlie: bool,
    pub dave: bool,
    pub eve: bool,
    pub ferdie: bool,
    pub one: bool,
    pub two: bool,
    pub force_authoring: bool,
    pub keystore_params: KeystoreParams,
    pub max_runtime_instances: Option<usize>,
    pub tmp: bool,
}

The run command used to run a node.

Fields

validator: bool

Enable validator mode.

The node will be started with the authority role and actively participate in any consensus task that it can (e.g. depending on availability of local keys).

no_grandpa: bool

Disable GRANDPA voter when running in validator mode, otherwise disable the GRANDPA observer.

light: bool

Experimental: Run in light client mode.

rpc_external: bool

Listen to all RPC interfaces.

Default is local. Note: not all RPC methods are safe to be exposed publicly. Use an RPC proxy server to filter out dangerous methods. More details: https://github.com/paritytech/substrate/wiki/Public-RPC. Use --unsafe-rpc-external to suppress the warning if you understand the risks.

unsafe_rpc_external: bool

Listen to all RPC interfaces.

Same as --rpc-external.

rpc_methods: RpcMethods

RPC methods to expose.

• Unsafe: Exposes every RPC method.
• Safe: Exposes only a safe subset of RPC methods, denying unsafe RPC methods.
• Auto: Acts as Safe if RPC is served externally, e.g. when --{rpc,ws}-external is passed, otherwise acts as Unsafe.

ws_external: bool

Listen to all Websocket interfaces.

Default is local. Note: not all RPC methods are safe to be exposed publicly. Use an RPC proxy server to filter out dangerous methods. More details: https://github.com/paritytech/substrate/wiki/Public-RPC. Use --unsafe-ws-external to suppress the warning if you understand the risks.

unsafe_ws_external: bool

Listen to all Websocket interfaces.

Same as --ws-external but doesn’t warn you about it.

rpc_max_payload: Option<usize>

Set the the maximum RPC payload size for both requests and responses (both http and ws), in megabytes. Default is 15MiB.

prometheus_external: bool

Expose Prometheus exporter on all interfaces.

Default is local.

ipc_path: Option<String>

Specify IPC RPC server path

rpc_port: Option<u16>

Specify HTTP RPC server TCP port.

ws_port: Option<u16>

Specify WebSockets RPC server TCP port.

ws_max_connections: Option<usize>

Maximum number of WS RPC server connections.

rpc_http_threads: Option<usize>

Size of the RPC HTTP server thread pool.

rpc_cors: Option<Cors>

Specify browser Origins allowed to access the HTTP & WS RPC servers.

A comma-separated list of origins (protocol://domain or special null value). Value of all will disable origin validation. Default is to allow localhost and https://polkadot.js.org origins. When running in –dev mode the default is to allow all origins.

prometheus_port: Option<u16>

Specify Prometheus exporter TCP Port.

no_prometheus: bool

Do not expose a Prometheus exporter endpoint.

Prometheus metric endpoint is enabled by default.

name: Option<String>

The human-readable name for this node.

The node name will be reported to the telemetry server, if enabled.

no_telemetry: bool

Disable connecting to the Substrate telemetry server.

Telemetry is on by default on global chains.

telemetry_endpoints: Vec<(String, u8)>

The URL of the telemetry server to connect to.

This flag can be passed multiple times as a means to specify multiple telemetry endpoints. Verbosity levels range from 0-9, with 0 denoting the least verbosity. Expected format is ‘URL VERBOSITY’, e.g. --telemetry-url 'wss://foo/bar 0'.

offchain_worker_params: OffchainWorkerParams

shared_params: SharedParams

import_params: ImportParams

network_params: NetworkParams

pool_config: TransactionPoolParams

alice: bool

Shortcut for --name Alice --validator with session keys for Alice added to keystore.

bob: bool

Shortcut for --name Bob --validator with session keys for Bob added to keystore.

charlie: bool

Shortcut for --name Charlie --validator with session keys for Charlie added to keystore.

dave: bool

Shortcut for --name Dave --validator with session keys for Dave added to keystore.

eve: bool

Shortcut for --name Eve --validator with session keys for Eve added to keystore.

ferdie: bool

Shortcut for --name Ferdie --validator with session keys for Ferdie added to keystore.

one: bool

Shortcut for --name One --validator with session keys for One added to keystore.

two: bool

Shortcut for --name Two --validator with session keys for Two added to keystore.

force_authoring: bool

Enable authoring even when offline.

keystore_params: KeystoreParams

max_runtime_instances: Option<usize>

The size of the instances cache for each runtime.

The default value is 8 and the values higher than 256 are ignored.

tmp: bool

Run a temporary node.

A temporary directory will be created to store the configuration and will be deleted at the end of the process.

Note: the directory is random per process execution. This directory is used as base path which includes: database, node key and keystore.

Implementations

impl RunCmd

pub fn get_keyring(&self) -> Option<Sr25519Keyring>

Get the Sr25519Keyring matching one of the flag.

Trait Implementations

impl CliConfiguration<()> for RunCmd

fn shared_params(&self) -> &SharedParams

Get the SharedParams for this object

fn import_params(&self) -> Option<&ImportParams>

Get the ImportParams for this object

fn network_params(&self) -> Option<&NetworkParams>

Get the NetworkParams for this object

fn keystore_params(&self) -> Option<&KeystoreParams>

Get the KeystoreParams for this object

fn offchain_worker_params(&self) -> Option<&OffchainWorkerParams>

Get a reference to OffchainWorkerParams for this object.

fn node_name(&self) -> Result<String>

Get the name of the node.

fn dev_key_seed(&self, is_dev: bool) -> Result<Option<String>>

Get the development key seed from the current object

fn telemetry_endpoints(
    &self,
    chain_spec: &Box<dyn ChainSpec>
) -> Result<Option<TelemetryEndpoints>>

Get the telemetry endpoints (if any)

fn role(&self, is_dev: bool) -> Result<Role>

Gets the role

fn force_authoring(&self) -> Result<bool>

Returns Ok(true) if authoring should be forced

fn prometheus_config(
    &self,
    default_listen_port: u16
) -> Result<Option<PrometheusConfig>>

Get the prometheus configuration (None if disabled)

fn disable_grandpa(&self) -> Result<bool>

Returns Ok(true) if grandpa should be disabled

fn rpc_ws_max_connections(&self) -> Result<Option<usize>>

Get the RPC websockets maximum connections (None if unlimited).

fn rpc_http_threads(&self) -> Result<Option<usize>>

Get the RPC HTTP thread pool size (None for a default 4-thread pool config).

fn rpc_cors(&self, is_dev: bool) -> Result<Option<Vec<String>>>

Get the RPC cors (None if disabled)

fn rpc_http(&self, default_listen_port: u16) -> Result<Option<SocketAddr>>

Get the RPC HTTP address (None if disabled).

fn rpc_ipc(&self) -> Result<Option<String>>

Get the RPC IPC path (None if disabled).

fn rpc_ws(&self, default_listen_port: u16) -> Result<Option<SocketAddr>>

Get the RPC websocket address (None if disabled).

fn rpc_methods(&self) -> Result<RpcMethods>

Returns the RPC method set to expose.

fn rpc_max_payload(&self) -> Result<Option<usize>>

Get maximum RPC payload.

fn transaction_pool(&self) -> Result<TransactionPoolOptions>

Get the transaction pool options

fn max_runtime_instances(&self) -> Result<Option<usize>>

Get maximum runtime instances

fn base_path(&self) -> Result<Option<BasePath>>

Get the base path of the configuration (if any)

fn pruning_params(&self) -> Option<&PruningParams>

Get the PruningParams for this object

fn node_key_params(&self) -> Option<&NodeKeyParams>

Get the NodeKeyParams for this object

fn database_params(&self) -> Option<&DatabaseParams>

Get the DatabaseParams for this object

fn is_dev(&self) -> Result<bool>

Returns true if the node is for development or not

fn network_config(
    &self,
    chain_spec: &Box<dyn ChainSpec>,
    is_dev: bool,
    is_validator: bool,
    net_config_dir: PathBuf,
    client_id: &str,
    node_name: &str,
    node_key: NodeKeyConfig,
    default_listen_port: u16
) -> Result<NetworkConfiguration>

Get the network configuration

fn keystore_config(
    &self,
    config_dir: &PathBuf
) -> Result<(Option<String>, KeystoreConfig)>

Get the keystore configuration.

fn database_cache_size(&self) -> Result<Option<usize>>

Get the database cache size.

fn database_transaction_storage(&self) -> Result<TransactionStorageMode>

Get the database transaction storage scheme.

fn database(&self) -> Result<Option<Database>>

Get the database backend variant.

fn database_config(
    &self,
    base_path: &PathBuf,
    cache_size: usize,
    database: Database
) -> Result<DatabaseSource>

Get the database configuration object for the parameters provided

fn state_cache_size(&self) -> Result<usize>

Get the state cache size.

fn state_cache_child_ratio(&self) -> Result<Option<usize>>

Get the state cache child ratio (if any).

fn state_pruning(
    &self,
    unsafe_pruning: bool,
    role: &Role
) -> Result<PruningMode>

Get the state pruning mode.

fn keep_blocks(&self) -> Result<KeepBlocks>

Get the block pruning mode.

fn chain_id(&self, is_dev: bool) -> Result<String>

Get the chain ID (string).

fn wasm_method(&self) -> Result<WasmExecutionMethod>

Get the WASM execution method.

fn wasm_runtime_overrides(&self) -> Option<PathBuf>

Get the path where WASM overrides live.

fn execution_strategies(
    &self,
    is_dev: bool,
    is_validator: bool
) -> Result<ExecutionStrategies>

Get the execution strategies.

fn telemetry_external_transport(&self) -> Result<Option<ExtTransport>>

Get the telemetry external transport

fn default_heap_pages(&self) -> Result<Option<u64>>

Get the default value for heap pages

fn offchain_worker(&self, role: &Role) -> Result<OffchainWorkerConfig>

Returns an offchain worker config wrapped in Ok(_)

fn tracing_targets(&self) -> Result<Option<String>>

Get the tracing targets from the current object (if any)

fn tracing_receiver(&self) -> Result<TracingReceiver>

Get the TracingReceiver value from the current object

fn node_key(&self, net_config_dir: &PathBuf) -> Result<NodeKeyConfig>

Get the node key from the current object

fn announce_block(&self) -> Result<bool>

Activate or not the automatic announcing of blocks after import

fn create_configuration<C: SubstrateCli>(
    &self,
    cli: &C,
    task_executor: TaskExecutor
) -> Result<Configuration>

Create a Configuration object from the current object

fn log_filters(&self) -> Result<String>

Get the filters for the logging.

fn is_log_filter_reloading_disabled(&self) -> Result<bool>

Is log reloading disabled (enabled by default)

fn disable_log_color(&self) -> Result<bool>

Should the log color output be disabled?

fn init<C: SubstrateCli>(&self) -> Result<()>

Initialize substrate. This must be done only once per process.

impl Clone for RunCmd

fn clone(&self) -> RunCmd

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RunCmd

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

Formats the value using the given formatter.

impl StructOpt for RunCmd

fn clap<'a, 'b>() -> App<'a, 'b>

Returns clap::App corresponding to the struct.

fn from_clap(matches: &ArgMatches<'_>) -> Self

Builds the struct from clap::ArgMatches. It’s guaranteed to succeed if matches originates from an App generated by [StructOpt::clap] called on the same type, otherwise it must panic.

fn from_args() -> Self

Builds the struct from the command line arguments (std::env::args_os). Calls clap::Error::exit on failure, printing the error message and aborting the program.

fn from_args_safe() -> Result<Self, Error>

Builds the struct from the command line arguments (std::env::args_os). Unlike [StructOpt::from_args], returns clap::Error on failure instead of aborting the program, so calling .exit is up to you.

fn from_iter<I>(iter: I) -> Self where
    I: IntoIterator,
    <I as IntoIterator>::Item: Into<OsString>,
    <I as IntoIterator>::Item: Clone, 

Gets the struct from any iterator such as a Vec of your making. Print the error message and quit the program in case of failure.

fn from_iter_safe<I>(iter: I) -> Result<Self, Error> where
    I: IntoIterator,
    <I as IntoIterator>::Item: Into<OsString>,
    <I as IntoIterator>::Item: Clone, 

Gets the struct from any iterator such as a Vec of your making.