maviola 0.3.0

High-level MAVLink communication library with support for essential micro-services.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use std::collections::HashMap;
use std::fmt::Debug;
use std::marker::PhantomData;

use crate::core::io::{ConnectionConf, ConnectionInfo, RetryStrategy};
use crate::core::marker::{MaybeConnConf, NodeKind, Proxy};
use crate::core::node::{IntoNodeConf, NodeConf};
use crate::core::utils::UniqueId;

use crate::prelude::*;

/// MAVLink network, a collection of nodes with different underlying transports.
///
/// Each message received by one node will be broadcast to other nodes. More specifically, the
/// broadcast operates on the level of channels. That means, that if, for example, a server node
/// receives a message from one of its clients, then this message will be forwarded to all other
/// clients of this server and all other nodes.
///
/// # Examples
///
/// Create a synchronous node with a network containing two TCP servers:
///
/// ```rust,no_run
/// # #[cfg(feature = "sync")] {
/// use std::time::Duration;
/// use maviola::core::io::RetryStrategy;
///
/// use maviola::prelude::*;
/// use maviola::sync::prelude::*;
///
/// let node = Node::sync::<V2>()
///     .id(MavLinkId::new(1, 17))
///     .connection(
///         Network::sync()
///             // We can either specify a connection
///             .add_connection(TcpServer::new("127.0.0.1:5600").unwrap())
///             // Or the entire proxy node configuration
///             .add_node(
///                 Node::sync()
///                     .connection(TcpServer::new("127.0.0.1:5601").unwrap())
///                     /* other node configuration */
///             )
///             // Attempt to repair disconnected nodes
///             .retry(RetryStrategy::Attempts(10, Duration::from_secs(2)))
///             // Stop if at least one node is down and all retry attempts have failed
///             .stop_on_node_down(true)
///     )
///     .build().unwrap();
/// # }
/// ```
///
/// Create an asynchronous node with a network containing a TCP server and a TCP client:
///
/// ```rust,no_run
/// # #[cfg(not(feature = "async"))] fn main() {}
/// # #[cfg(feature = "async")]
/// # #[tokio::main] async fn main() {
/// use std::time::Duration;
/// use maviola::core::io::RetryStrategy;
///
/// use maviola::prelude::*;
/// use maviola::asnc::prelude::*;
///
/// let node = Node::asnc::<V2>()
///     .id(MavLinkId::new(1, 17))
///     .connection(
///         Network::asnc()
///             // We can either specify a connection
///             .add_connection(TcpServer::new("127.0.0.1:5600").unwrap())
///             // Or the entire proxy node configuration
///             .add_node(
///                 Node::asnc()
///                     .connection(TcpClient::new("127.0.0.1:5601").unwrap())
///                     /* other node configuration */
///             )
///             // Attempt to repair disconnected nodes
///             .retry(RetryStrategy::Attempts(10, Duration::from_secs(2)))
///             // Stop if at least one node is down and all retry attempts have failed
///             .stop_on_node_down(true)
///     )
///     .build().await.unwrap();
/// # }
/// ```
#[derive(Debug)]
pub struct Network<V: MaybeVersioned, C: MaybeConnConf> {
    pub(crate) info: ConnectionInfo,
    pub(crate) nodes: HashMap<UniqueId, NodeConf<Proxy, V, C>>,
    pub(crate) retry: RetryStrategy,
    pub(crate) stop_on_node_down: bool,
    pub(crate) _version: PhantomData<V>,
}

impl<V: MaybeVersioned, C: MaybeConnConf> Network<V, C> {
    /// Adds node configuration to the network.
    ///
    /// Accepts anything that can be converted into a [`NodeConf`].
    ///
    /// Make sure, that node configuration was built with the protocol version, that matches target
    /// node. In particular, do not forget to set [`NodeBuilder::version`], if you are using a
    /// versioned node.
    ///
    /// [`NodeBuilder::version`]: crate::core::node::NodeBuilder::version
    pub fn add_node<K: NodeKind>(mut self, node: impl IntoNodeConf<K, V, C>) -> Self {
        let node = node.into_node_conf().into_proxy();
        self.nodes.insert(UniqueId::new(), node);
        self
    }

    /// Defines retry strategy for a network.
    ///
    /// When node goes down and it [`NodeConf::is_repairable`], then network will attempt to restore
    /// a node according to a specified strategy.
    ///
    /// When [`Self::retry`] is set to `true`, then the entire network will be disconnected, when
    /// at least one node is stopped and can't be repaired.
    pub fn retry(mut self, retry: RetryStrategy) -> Self {
        self.retry = retry;
        self
    }

    /// Defines, whether entire network should go down, when one of the nodes is disconnected.
    ///
    /// This option works in conjunction with [`Self::retry`]. The node will be considered down,
    /// if all retry attempts has failed.
    pub fn stop_on_node_down(mut self, value: bool) -> Self {
        self.stop_on_node_down = value;
        self
    }
}

impl<V: MaybeVersioned, C: MaybeConnConf> ConnectionConf for Network<V, C> {
    fn info(&self) -> &ConnectionInfo {
        &self.info
    }
}