Struct SpawnNodeOptions 

pub struct SpawnNodeOptions {

    pub name: String,
    pub image: Option<String>,
    pub resources: Option<Resources>,
    pub program: String,
    pub args: Vec<String>,
    pub env: Vec<(String, String)>,
    pub injected_files: Vec<TransferedFile>,
    pub created_paths: Vec<PathBuf>,
    pub db_snapshot: Option<PathBuf>,
    pub port_mapping: Option<HashMap<Port, Port>>,
    pub ports: Vec<(String, Port)>,
    pub readiness: Option<ReadinessProbe>,
    pub node_log_path: Option<PathBuf>,
    pub role: Option<NodeRole>,
    pub wrapper: bool,
}

Fields

name: String

Name of the node

image: Option<String>

Image of the node (IFF is supported by the provider)

resources: Option<Resources>

Resources to apply to the node (IFF is supported by the provider)

program: String

Main command to execute

args: Vec<String>

Arguments to pass to the main command

env: Vec<(String, String)>

Environment to set when running the program

injected_files: Vec<TransferedFile>

Files to inject at startup

created_paths: Vec<PathBuf>

Paths to create before start the node (e.g keystore) should be created with create_dir_all in order to create the full path even when we have missing parts

db_snapshot: Option<PathBuf>

Database snapshot to be injected (a local .tgz resolved by the orchestrator before spawn — providers extract it directly, no download). See orchestrator::generators::resolve_db_snapshots.

port_mapping: Option<HashMap<Port, Port>>

ports: Vec<(String, Port)>

Named ports the process listens on. On k8s they are the pod’s container ports and its Service ports (none gives a headless Service); the other providers ignore them.

readiness: Option<ReadinessProbe>

How the provider may check readiness itself; on k8s the pod’s probe.

node_log_path: Option<PathBuf>

Optionally specify a log path for the node

role: Option<NodeRole>

Role of the node in the network

wrapper: bool

Run program through zombienet’s wrapper script, which gives the pause/resume/restart controls nodes have. The wrapper needs bash in the image and replaces the image’s entrypoint, so a custom process that is just an off-the-shelf image runs without it.

Implementations

impl SpawnNodeOptions

pub fn new<S>(name: S, program: S) -> Self

where S: AsRef<str>,

pub fn image<S>(self, image: S) -> Self

where S: AsRef<str>,

pub fn resources(self, resources: Resources) -> Self

pub fn db_snapshot(self, db_snap: Option<PathBuf>) -> Self

pub fn args<S, I>(self, args: I) -> Self

where S: AsRef<str>, I: IntoIterator<Item = S>,

pub fn env<S, I>(self, env: I) -> Self

where S: AsRef<str>, I: IntoIterator<Item = (S, S)>,

pub fn injected_files<I>(self, injected_files: I) -> Self

where I: IntoIterator<Item = TransferedFile>,

pub fn created_paths<P, I>(self, created_paths: I) -> Self

where P: AsRef<Path>, I: IntoIterator<Item = P>,

pub fn port_mapping(self, ports: HashMap<Port, Port>) -> Self

pub fn node_log_path(self, path: Option<PathBuf>) -> Self

pub fn role(self, role: NodeRole) -> Self

pub fn ports<S, I>(self, ports: I) -> Self

where S: AsRef<str>, I: IntoIterator<Item = (S, Port)>,

pub fn readiness(self, probe: Option<ReadinessProbe>) -> Self

pub fn without_wrapper(self) -> Self

Run program directly instead of through the zombie wrapper script.

The wrapper needs bash in the image and is what pause, resume and restart talk to, so those return an error for a node spawned this way on docker and kubernetes (native signals the process and needs no wrapper). The wrapper also holds the program back until the injected files are copied in; without it the program starts at once, so it must not need any injected_files at startup.

Trait Implementations

impl Clone for SpawnNodeOptions

fn clone(&self) -> SpawnNodeOptions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SpawnNodeOptions

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

Formats the value using the given formatter.