nt_client 0.5.1

A blazingly fast NetworkTables 4.1 client
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
136
137
138
139
140
141
142
143
144
145
146
147
148

//! `NetworkTables` client error types.

use std::error::Error;

use tokio::task::JoinError;
use tokio_tungstenite::tungstenite;

/// Error that means the `NetworkTables` connection was closed.
#[derive(thiserror::Error, Debug, Clone, PartialEq, Eq, Hash)]
#[error("the ws connection was closed")]
pub struct ConnectionClosedError;

/// Errors than can occur when connecting to a `NetworkTables` server.
#[derive(thiserror::Error, Debug)]
pub enum ConnectError {
    /// An error occurred with the websocket.
    #[error("websocket error: {0}")]
    WebsocketError(#[from] tungstenite::Error),

    /// An error occurred when joining multiple tasks together.
    #[error(transparent)]
    Join(#[from] JoinError),

    /// An error occurred when pinging the server.
    #[error(transparent)]
    Ping(#[from] PingError),

    /// An error occurred when updating client time.
    #[error(transparent)]
    UpdateTime(#[from] UpdateTimeError),

    /// An error occurred when sending messages to the server.
    #[error(transparent)]
    SendMessage(#[from] SendMessageError),

    /// An error ocurred when receiving messages from the server.
    #[error(transparent)]
    ReceiveMessage(#[from] ReceiveMessageError),
}

/// Errors that can occur when pinging the `NetworkTables` server.
#[derive(thiserror::Error, Debug, Clone, PartialEq, Eq, Hash)]
pub enum PingError {
    /// The `NetworkTables` connection was closed.
    ///
    /// Normally, this should never happen and may turn into a panic in the future.
    #[error(transparent)]
    ConnectionClosed(#[from] ConnectionClosedError),

    /// The server didn't respond with a pong within the timeout specified in
    /// [`NewClientOptions`][`crate::NewClientOptions`].
    #[error("a pong response wasn't received within the timeout")]
    PongTimeout,
}

/// Errors that can occur when updating client time.
#[derive(thiserror::Error, Debug, Clone, PartialEq, Eq, Hash)]
pub enum UpdateTimeError {
    /// The `NetworkTables` connection was closed.
    ///
    /// Normally, this should never happen and may turn into a panic in the future.
    #[error(transparent)]
    ConnectionClosed(#[from] ConnectionClosedError),

    /// Client time has overflowed as a result of the client being alive for too long.
    #[error("client time has overflowed")]
    TimeOverflow,
}

/// Errors that can occur when sending messages to the `NetworkTables` server.
#[derive(thiserror::Error, Debug)]
pub enum SendMessageError {
    /// The `NetworkTables` connection was closed.
    ///
    /// Normally, this should never happen and may turn into a panic in the future.
    #[error(transparent)]
    ConnectionClosed(#[from] ConnectionClosedError),

    /// A message failed to serialize into a JSON text message.
    ///
    /// This shouldn't normally happen and may turn into a panic in the future.
    #[error(transparent)]
    FailedSerializingJson(#[from] serde_json::Error),

    /// A message failed to serialize into a MessagePack binary message.
    ///
    /// This shouldn't normally happen and may turn into a panic in the future.
    #[error(transparent)]
    FailedSerializingMsgPack(#[from] rmp_serde::encode::Error),
}

/// Errors that can occur when receiving messages from the `NetworkTables` server.
#[derive(thiserror::Error, Debug)]
pub enum ReceiveMessageError {
    /// An error has occurred with the websocket.
    #[error(transparent)]
    WebSocket(#[from] tungstenite::Error),

    /// The `NetworkTables` connection was closed.
    ///
    /// Normally, this should never happen and may turn into a panic in the future.
    #[error(transparent)]
    ConnectionClosed(#[from] ConnectionClosedError),
}

/// Errors that can occur when converting an [`NTAddr`] to an [`Ipv4Addr`]
///
/// [`NTAddr`]: crate::NTAddr
/// [`Ipv4Addr`]: std::net::Ipv4Addr
#[derive(thiserror::Error, Debug, Clone, PartialEq, Eq)]
pub enum IntoAddrError {
    /// The team number is greater than 25599.
    #[error("team number {0} is greater than 25599")]
    InvalidTeamNumber(u16),
}

/// A potentially fatal error that occurs after reconnecting to a `NetworkTables` server.
///
/// This is used when creating a reconnect handler via [`crate::reconnect`], in which a
/// [`Fatal`] variant indicates that no attempt to reconnect should be made,
/// while a [`Nonfatal`] variant indicates that a reconnect attempt will be made.
///
/// A [`From<ConnectError>`][`From`] trait is implemented, constructing a [`Fatal`] variant if and only
/// if it is a [`ConnectError::WebsocketError`] ([`tungstenite::error::Error::Io`]), otherwise it
/// constructs a [`Nonfatal`] variant.
///
/// [`Fatal`]: ReconnectError::Fatal
/// [`Nonfatal`]: ReconnectError::Nonfatal
#[derive(thiserror::Error, Debug)]
pub enum ReconnectError {
    /// An unrecoverable error has occurred and no attempt to reconnect should be made.
    #[error(transparent)]
    Fatal(Box<dyn Error + Send + Sync>),

    /// A recoverable error has occurred and reconnection will be attempted.
    #[error(transparent)]
    Nonfatal(Box<dyn Error + Send + Sync>),
}

impl From<ConnectError> for ReconnectError {
    fn from(value: ConnectError) -> Self {
        match value {
            ConnectError::WebsocketError(tungstenite::Error::Io(error)) => Self::Fatal(error.into()),
            err => Self::Nonfatal(err.into()),
        }
    }
}