Struct Trace 

#[non_exhaustive]
pub struct Trace {
    pub endpoint_info: Option<EndpointInfo>,
    pub steps: Vec<Step>,
    pub forward_trace_id: i32,
    /* private fields */
}

Trace represents one simulated packet forwarding path.

• Each trace contains multiple ordered steps.
• Each step is in a particular state with associated configuration.
• State is categorized as final or non-final states.
• Each final state has a reason associated.
• Each trace must end with a final state (the last step).

  |---------------------Trace----------------------|
  Step1(State) Step2(State) ---  StepN(State(final))

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

endpoint_info: Option<EndpointInfo>

Derived from the source and destination endpoints definition specified by user request, and validated by the data plane model. If there are multiple traces starting from different source locations, then the endpoint_info may be different between traces.

steps: Vec<Step>

A trace of a test contains multiple steps from the initial state to the final state (delivered, dropped, forwarded, or aborted).

The steps are ordered by the processing sequence within the simulated network state machine. It is critical to preserve the order of the steps and avoid reordering or sorting them.

forward_trace_id: i32

ID of trace. For forward traces, this ID is unique for each trace. For return traces, it matches ID of associated forward trace. A single forward trace can be associated with none, one or more than one return trace.

Implementations

impl Trace

pub fn new() -> Self

Creates a new default instance.

pub fn set_endpoint_info<T>(self, v: T) -> Self

where T: Into<EndpointInfo>,

Sets the value of endpoint_info.

Example

use google_cloud_networkmanagement_v1::model::EndpointInfo;
let x = Trace::new().set_endpoint_info(EndpointInfo::default()/* use setters */);

pub fn set_or_clear_endpoint_info<T>(self, v: Option<T>) -> Self

where T: Into<EndpointInfo>,

Sets or clears the value of endpoint_info.

Example

use google_cloud_networkmanagement_v1::model::EndpointInfo;
let x = Trace::new().set_or_clear_endpoint_info(Some(EndpointInfo::default()/* use setters */));
let x = Trace::new().set_or_clear_endpoint_info(None::<EndpointInfo>);

pub fn set_steps<T, V>(self, v: T) -> Self

where T: IntoIterator<Item = V>, V: Into<Step>,

Sets the value of steps.

Example

use google_cloud_networkmanagement_v1::model::Step;
let x = Trace::new()
    .set_steps([
        Step::default()/* use setters */,
        Step::default()/* use (different) setters */,
    ]);

pub fn set_forward_trace_id<T: Into<i32>>(self, v: T) -> Self

Sets the value of forward_trace_id.

Example

let x = Trace::new().set_forward_trace_id(42);

Trait Implementations

impl Clone for Trace

fn clone(&self) -> Trace

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Trace

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

Formats the value using the given formatter.

impl Default for Trace

fn default() -> Trace

Returns the “default value” for a type.

impl Message for Trace

fn typename() -> &'static str

The typename of this message.

impl PartialEq for Trace

fn eq(&self, other: &Trace) -> 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 Trace