Enum try_runtime_core::commands::Action

pub enum Action {
    OnRuntimeUpgrade(Command),
    ExecuteBlock(Command),
    OffchainWorker(Command),
    FollowChain(Command),
    CreateSnapshot(Command),
    FastForward(Command),
}

Possible actions of try-runtime.

Variants

OnRuntimeUpgrade(Command)

Execute the migrations of the given runtime

This uses a custom runtime api call, namely “TryRuntime_on_runtime_upgrade”. The code path only triggers all of the on_runtime_upgrade hooks in the runtime, and optionally try_state.

See TryRuntime and on_runtime_upgrade::Command for more information.

ExecuteBlock(Command)

Executes the given block against some state.

This uses a custom runtime api call, namely “TryRuntime_execute_block”. Some checks, such as state-root and signature checks are always disabled, and additional checks like try-state can be enabled.

See TryRuntime and execute_block::Command for more information.

OffchainWorker(Command)

Executes the offchain worker hooks of a given block against some state.

This executes the same runtime api as normal block import, namely OffchainWorkerApi_offchain_worker.

See frame_try_runtime::TryRuntime and offchain_worker::Command for more information.

FollowChain(Command)

Follow the given chain’s finalized blocks and apply all of its extrinsics.

This is essentially repeated calls to Action::ExecuteBlock.

This allows the behavior of a new runtime to be inspected over a long period of time, with realistic transactions coming as input.

NOTE: this does NOT execute the offchain worker hooks of mirrored blocks. This might be added in the future.

This does not support snapshot states, and can only work with a remote chain. Upon first connections, starts listening for finalized block events. Upon first block notification, it initializes the state from the remote node, and starts applying that block, plus all the blocks that follow, to the same growing state.

This can only work if the block format between the remote chain and the new runtime being tested has remained the same, otherwise block decoding might fail.

CreateSnapshot(Command)

Create snapshot files.

The create-snapshot subcommand facilitates the creation of a snapshot from a node’s state. This snapshot can be loaded rapidly into memory from disk, providing an efficient alternative to downloading state from the node for every new command execution.

Usage:

1. Create a snapshot from a remote node:

try-runtime create-snapshot –uri ws://remote-node-uri my_state.snap

2. Utilize the snapshot with on-runtime-upgrade:

try-runtime –runtime ./path/to/runtime.wasm on-runtime-upgrade snap –path my_state.snap

FastForward(Command)

Executes a runtime upgrade (optional), then mines a number of blocks while performing try-state checks.

The try-state checks are performed using the TryRuntime_execute_block runtime api.

See TryRuntime and fast_forward::Command for more information.

Implementations

impl Action

pub async fn run<Block, HostFns>(&self, shared: &SharedParams) -> Result<()>

where Block: BlockT<Hash = H256> + DeserializeOwned, Block::Header: DeserializeOwned, Block::Hash: FromStr, <Block::Hash as FromStr>::Err: Debug, <NumberFor<Block> as FromStr>::Err: Debug, <NumberFor<Block> as TryInto<u64>>::Error: Debug, NumberFor<Block>: FromStr, HostFns: HostFunctions,

Trait Implementations

impl Clone for Action

fn clone(&self) -> Action

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Action

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

Formats the value using the given formatter.

impl FromArgMatches for Action

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

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