Struct TaskExecutionKey 

pub struct TaskExecutionKey {
    pub host: NatString,
    pub task_name: String,
}

A unique identifier for tracking task execution state for a specific host and task combination.

This structure serves as a composite key used by the State structure to track the execution state of tasks on individual hosts. Each TaskExecutionKey uniquely identifies a task execution by combining the hostname with the task name, allowing the state tracking system to maintain separate execution histories for different task/host pairs.

The key is used internally by methods like State::set_task_state, State::task_state, and their _key variants to store and retrieve TaskAttemptState information.

Fields

• host - A NatString representing the hostname on which the task is being executed. Using NatString provides efficient string handling with natural sorting capabilities, which can be useful when displaying or organizing task execution results by hostname.

• task_name - The name of the task being executed. This is a standard String that identifies the specific task or operation being performed on the host. Task names should be unique within a playbook or execution context to ensure proper state tracking.

Examples

// Create a task execution key for a specific host and task
let key = TaskExecutionKey::new("router1", "show_version");
assert_eq!(key.host, NatString::from("router1"));
assert_eq!(key.task_name, "show_version");

// Keys can be used to track task state
let state = State::new();
let task_state = TaskAttemptState::new(TaskStatus::Running).with_attempts(1);
state.set_task_state_key(key.clone(), task_state.clone());
assert_eq!(state.task_state_key(&key), Some(task_state));

// Keys with the same host and task name are equal
let key1 = TaskExecutionKey::new("router1", "show_version");
let key2 = TaskExecutionKey::new("router1", "show_version");
assert_eq!(key1, key2);

// Keys with different hosts or task names are not equal
let key3 = TaskExecutionKey::new("router2", "show_version");
assert_ne!(key1, key3);

Fields

host: NatString

task_name: String

Implementations

impl TaskExecutionKey

pub fn new(host: impl Into<String>, task_name: impl Into<String>) -> Self

Creates a new TaskExecutionKey from a host and task name.

This constructor method creates a unique identifier for tracking task execution state by combining a hostname with a task name. The resulting key can be used with methods like State::set_task_state_key and State::task_state_key to store and retrieve task execution information.

The host parameter is converted into a NatString for efficient string handling with natural sorting capabilities, while the task name is stored as a standard String.

Parameters

• host - The hostname for which the task is being executed. Can be any type that converts into a String, such as &str, String, or other string-like types. This will be stored as a NatString in the resulting key.

• task_name - The name of the task being executed. Can be any type that converts into a String, such as &str, String, or other string-like types. Task names should be unique within a playbook or execution context to ensure proper state tracking.

Returns

Returns a new TaskExecutionKey instance with the specified host and task name, ready to be used for tracking task execution state.

Examples

// Create a key using string slices
let key = TaskExecutionKey::new("router1", "show_version");
assert_eq!(key.host, NatString::from("router1"));
assert_eq!(key.task_name, "show_version");

// Create a key using owned Strings
let host = String::from("router2");
let task = String::from("configure_interface");
let key = TaskExecutionKey::new(host, task);
assert_eq!(key.task_name, "configure_interface");

Trait Implementations

impl Clone for TaskExecutionKey

fn clone(&self) -> TaskExecutionKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TaskExecutionKey

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

Formats the value using the given formatter.

impl Eq for TaskExecutionKey

impl Hash for TaskExecutionKey

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for TaskExecutionKey

fn eq(&self, other: &TaskExecutionKey) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for TaskExecutionKey