Struct rings_node::prelude::MessageRelay

pub struct MessageRelay {
    pub method: RelayMethod,
    pub path: Vec<Did, Global>,
    pub path_end_cursor: usize,
    pub next_hop: Option<Did>,
    pub destination: Did,
}

MessageRelay guide message passing on rings network by relay.

All messages should be sent with MessageRelay. By calling relay method in correct place, MessageRelay help to do things:

• Infer the next_hop of a message.
• Get the sender and origin sender of a message.
• Record the whole transport path for inspection.

Examples

Fields

method: RelayMethod

The method of message. SEND or REPORT.

path: Vec<Did, Global>

A push only stack. Record routes when handling sending messages.

path_end_cursor: usize

Move this cursor to flag the top of the stack when reporting. Notice that this cursor is not the index of current. It’s path.len() - <index of current> - 1, which means count down to head of vector. It will always be 0 while handling sending messages in this way.

next_hop: Option<Did>

The next node to handle the message. When and only when located at the end of the message propagation, the next_hop is none. A message handler will pick transport by this field.

destination: Did

The destination of the message. It may be customized when sending. It cannot be changed when reporting. It may help the handler to find out next_hop in some situations.

Implementations

impl MessageRelay

pub fn new(
    method: RelayMethod,
    path: Vec<Did, Global>,
    path_end_cursor: Option<usize>,
    next_hop: Option<Did>,
    destination: Did
) -> MessageRelay

Create a new MessageRelay. Will set path_end_cursor to 0 if pass None as parameter.

pub fn relay(&mut self, current: Did, next_hop: Option<Did>) -> Result<(), Error>

Check current did, update path and its end cursor, then infer next_hop.

When handling a SEND message, will push current to the self.path stack, and set next_hop parameter to self.next_node.

When handling a REPORT message, will move forward self.path_end_cursor to the position of current in self.path. If next_hop parameter is none, it will also pick the previous node in self.path as self.next_hop. (With this feature, one can always pass None as next_hop parameter when handling a REPORT message.)

pub fn report(&self) -> Result<MessageRelay, Error>

Construct a MessageRelay of method REPORT from a MessageRelay of method REPORT. It will return Error if method is not SEND. It will return Error if self.path.len() is less than 2.

pub fn reset_destination(&mut self, destination: Did) -> Result<(), Error>

A SEND message can change its destination. Call with REPORT method will get an error imeediately.

pub fn validate(&self) -> Result<(), Error>

Check if path and destination is valid. It will be automatically called at relay started.

pub fn origin(&self) -> Did

Get the original sender of current message. Should always be the first element of path.

pub fn sender(&self) -> Did

Get sender of current message. With SEND method, it will be the origin() of the message. With REPORT method, it will be the last element of path.

pub fn path_prev(&self) -> Option<Did>

Get the previous element of the element pointed by path_end_cursor.

Trait Implementations

impl Clone for MessageRelay

fn clone(&self) -> MessageRelay

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MessageRelay

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MessageRelay

fn deserialize<__D>(
    __deserializer: __D
) -> Result<MessageRelay, <__D as Deserializer<'de>>::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq<MessageRelay> for MessageRelay

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for MessageRelay

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for MessageRelay

impl StructuralEq for MessageRelay

impl StructuralPartialEq for MessageRelay