Struct NetworkConfigBuilder

pub struct NetworkConfigBuilder<State> { /* private fields */ }

A network configuration builder, used to build a NetworkConfig declaratively with fields validation.

Example:

use zombienet_configuration::NetworkConfigBuilder;

let network_config = NetworkConfigBuilder::new()
    .with_relaychain(|relaychain| {
        relaychain
            .with_chain("polkadot")
            .with_random_nominators_count(10)
            .with_default_resources(|resources| {
                resources
                    .with_limit_cpu("1000m")
                    .with_request_memory("1Gi")
                    .with_request_cpu(100_000)
            })
            .with_node(|node| {
                node.with_name("node")
                    .with_command("command")
                    .validator(true)
            })
    })
    .with_parachain(|parachain| {
        parachain
            .with_id(1000)
            .with_chain("myparachain1")
            .with_initial_balance(100_000)
            .with_default_image("myimage:version")
            .with_collator(|collator| {
                collator
                    .with_name("collator1")
                    .with_command("command1")
                    .validator(true)
            })
    })
    .with_parachain(|parachain| {
        parachain
            .with_id(2000)
            .with_chain("myparachain2")
            .with_initial_balance(50_0000)
            .with_collator(|collator| {
                collator
                    .with_name("collator2")
                    .with_command("command2")
                    .validator(true)
            })
    })
    .with_hrmp_channel(|hrmp_channel1| {
        hrmp_channel1
            .with_sender(1)
            .with_recipient(2)
            .with_max_capacity(200)
            .with_max_message_size(500)
    })
    .with_hrmp_channel(|hrmp_channel2| {
        hrmp_channel2
            .with_sender(2)
            .with_recipient(1)
            .with_max_capacity(100)
            .with_max_message_size(250)
    })
    .with_global_settings(|global_settings| {
        global_settings
            .with_network_spawn_timeout(1200)
            .with_node_spawn_timeout(240)
    })
    .build();

assert!(network_config.is_ok())

Implementations

impl NetworkConfigBuilder<Initial>

pub fn new() -> NetworkConfigBuilder<Initial>

pub fn with_chain_and_nodes( relay_name: &str, node_names: Vec<String>, ) -> NetworkConfigBuilder<WithRelaychain>

uses the default options for both the relay chain and the nodes the only required fields are the name of the nodes, and the name of the relay chain (“rococo-local”, “polkadot”, etc.)

pub fn with_relaychain( self, f: impl FnOnce(RelaychainConfigBuilder<Initial>) -> RelaychainConfigBuilder<WithAtLeastOneNode>, ) -> NetworkConfigBuilder<WithRelaychain>

Set the relay chain using a nested RelaychainConfigBuilder.

impl NetworkConfigBuilder<WithRelaychain>

pub fn with_global_settings( self, f: impl FnOnce(GlobalSettingsBuilder) -> GlobalSettingsBuilder, ) -> Self

Set the global settings using a nested GlobalSettingsBuilder.

pub fn with_parachain( self, f: impl FnOnce(ParachainConfigBuilder<Initial, Bootstrap>) -> ParachainConfigBuilder<WithAtLeastOneCollator, Bootstrap>, ) -> Self

Add a parachain using a nested ParachainConfigBuilder.

pub fn with_parachain_id_and_collators( self, id: u32, collator_names: Vec<String>, ) -> Self

uses default settings for setting for:

• the parachain,
• the global settings
• the hrmp channels

the only required parameters are the names of the collators as a vector, and the id of the parachain

pub fn with_hrmp_channel( self, f: impl FnOnce(HrmpChannelConfigBuilder<Initial>) -> HrmpChannelConfigBuilder<WithRecipient>, ) -> Self

Add an HRMP channel using a nested HrmpChannelConfigBuilder.

pub fn build(self) -> Result<NetworkConfig, Vec<Error>>

Seals the builder and returns a NetworkConfig if there are no validation errors, else returns errors.

Trait Implementations

impl Default for NetworkConfigBuilder<Initial>

fn default() -> Self

Returns the “default value” for a type.