16123384529

Committed 07 Jul 2025 05:11PM UTC coverage: 64.327% (-7.6%) from 71.89%

Build # 16123384529

Build Type

push

github

Committed by

web-flow

Commit Message

chore: new release v4.9.0-pre.0 (#7289)

Description
---
new release esmeralda

Run Details

77151 of 119935 relevant lines covered (64.33%)

227108.34 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

43.9

/comms/core/src/protocol/rpc/error.rs

//  Copyright 2020, The Tari Project
//
//  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
//  following conditions are met:
//
//  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
//  disclaimer.
//
//  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
//  following disclaimer in the documentation and/or other materials provided with the distribution.
//
//  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
//  products derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
//  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
//  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
//  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
//  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
//  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

use std::io;

use prost::DecodeError;
use thiserror::Error;

use super::{handshake::RpcHandshakeError, server::RpcServerError, RpcStatus};
use crate::{
    connectivity::ConnectivityError,
    peer_manager::PeerManagerError,
    proto::rpc as rpc_proto,
    traits::OrOptional,
    PeerConnectionError,
};

#[derive(Debug, Error)]
pub enum RpcError {
    #[error("Failed to decode message: {0}")]
    DecodeError(#[from] DecodeError),
    #[error("IO Error: {0}")]
    Io(#[from] io::Error),
    #[error("The client connection is closed")]
    ClientClosed,
    #[error("Request failed: {0}")]
    RequestFailed(#[from] RpcStatus),
    #[error("Remote peer unexpectedly closed the RPC connection")]
    ServerClosedRequest,
    #[error("Request cancelled")]
    RequestCancelled,
    #[error("Response did not match the request ID (expected {expected} actual {actual})")]
    ResponseIdDidNotMatchRequest { expected: u16, actual: u16 },
    #[error("Client internal error: {0}")]
    ClientInternalError(String),
    #[error("Handshake error: {0}")]
    HandshakeError(#[from] RpcHandshakeError),
    #[error("Server error: {0}")]
    ServerError(#[from] RpcServerError),
    #[error("Peer connection error: {0}")]
    PeerConnectionError(#[from] PeerConnectionError),
    #[error("Peer manager error: {0}")]
    PeerManagerError(#[from] PeerManagerError),
    #[error("Connectivity error: {0}")]
    ConnectivityError(#[from] ConnectivityError),
    #[error("Reply from peer timed out")]
    ReplyTimeout,
    #[error("Received an invalid ping response")]
    InvalidPingResponse,
    #[error("Unexpected ACK response. This is likely because of a previous ACK timeout")]
    UnexpectedAckResponse,
    #[error("Remote peer attempted to send more than {expected} payload chunks")]
    RemotePeerExceededMaxChunkCount { expected: usize },
    #[error("Request body was too large. Expected <= {expected} but got {got}")]
    MaxRequestSizeExceeded { got: usize, expected: usize },
    #[error(transparent)]
    UnknownError(#[from] anyhow::Error),
}

impl RpcError {
    pub fn client_internal_error<T: ToString>(err: &T) -> Self {
        RpcError::ClientInternalError(err.to_string())
    }

    /// Returns true if the server directly caused the error, otherwise false
    pub fn is_caused_by_server(&self) -> bool {
        match self {
            RpcError::ReplyTimeout |
            RpcError::DecodeError(_) |
            RpcError::RemotePeerExceededMaxChunkCount { .. } |
            RpcError::HandshakeError(RpcHandshakeError::DecodeError(_)) |
            RpcError::HandshakeError(RpcHandshakeError::ServerClosedRequest) |
            RpcError::HandshakeError(RpcHandshakeError::Rejected(_)) |
            RpcError::HandshakeError(RpcHandshakeError::TimedOut) |
            RpcError::ServerClosedRequest |
            RpcError::UnexpectedAckResponse |
            RpcError::ResponseIdDidNotMatchRequest { .. } => true,

            // Some of these may be caused by the server, but not with 100% certainty
            RpcError::RequestFailed(_) |
            RpcError::Io(_) |
            RpcError::ClientClosed |
            RpcError::RequestCancelled |
            RpcError::ClientInternalError(_) |
            RpcError::ServerError(_) |
            RpcError::PeerConnectionError(_) |
            RpcError::PeerManagerError(_) |
            RpcError::ConnectivityError(_) |
            RpcError::InvalidPingResponse |
            RpcError::MaxRequestSizeExceeded { .. } |
            RpcError::HandshakeError(RpcHandshakeError::Io(_)) |
            RpcError::HandshakeError(RpcHandshakeError::ClientNoSupportedVersion) |
            RpcError::HandshakeError(RpcHandshakeError::ClientClosed) |
            RpcError::UnknownError(_) => false,
        }
    }
}

#[derive(Debug, Error, Clone, Copy)]
pub enum HandshakeRejectReason {
    #[error("protocol version not supported")]
    UnsupportedVersion,
    #[error("no more RPC server sessions available: {0}")]
    NoServerSessionsAvailable(&'static str),
    #[error("no more RPC client sessions available: {0}")]
    NoClientSessionsAvailable(&'static str),
    #[error("protocol not supported")]
    ProtocolNotSupported,
    #[error("unknown protocol error: {0}")]
    Unknown(&'static str),
}

impl HandshakeRejectReason {
    pub fn as_i32(&self) -> i32 {
        rpc_proto::rpc_session_reply::HandshakeRejectReason::from(*self) as i32
    }

    pub fn from_i32(v: i32) -> Option<Self> {
        rpc_proto::rpc_session_reply::HandshakeRejectReason::try_from(v)
            .map(Into::into)
            .ok()
    }
}

impl From<rpc_proto::rpc_session_reply::HandshakeRejectReason> for HandshakeRejectReason {
    fn from(reason: rpc_proto::rpc_session_reply::HandshakeRejectReason) -> Self {
        #[allow(clippy::enum_glob_use)]
        use rpc_proto::rpc_session_reply::HandshakeRejectReason::*;
        match reason {
            UnsupportedVersion => HandshakeRejectReason::UnsupportedVersion,
            NoServerSessionsAvailable => HandshakeRejectReason::NoServerSessionsAvailable("session limit reached"),
            NoClientSessionsAvailable => HandshakeRejectReason::NoClientSessionsAvailable("session limit reached"),
            ProtocolNotSupported => HandshakeRejectReason::ProtocolNotSupported,
            Unknown => HandshakeRejectReason::Unknown("reject reason is not known"),
        }
    }
}

impl From<HandshakeRejectReason> for rpc_proto::rpc_session_reply::HandshakeRejectReason {
    fn from(reason: HandshakeRejectReason) -> Self {
        #[allow(clippy::enum_glob_use)]
        use rpc_proto::rpc_session_reply::HandshakeRejectReason::*;
        match reason {
            HandshakeRejectReason::UnsupportedVersion => UnsupportedVersion,
            HandshakeRejectReason::NoServerSessionsAvailable(_) => NoServerSessionsAvailable,
            HandshakeRejectReason::NoClientSessionsAvailable(_) => NoClientSessionsAvailable,
            HandshakeRejectReason::ProtocolNotSupported => ProtocolNotSupported,
            HandshakeRejectReason::Unknown(_) => Unknown,
        }
    }
}

impl<T> OrOptional<T> for Result<T, RpcError> {
    type Error = RpcError;

    fn or_optional(self) -> Result<Option<T>, Self::Error> {
        self.map(Some).or_else(|err| {
            if let RpcError::RequestFailed(ref status) = err {
                if status.is_not_found() {
                    Ok(None)
                } else {
                    Err(err)
                }
            } else {
                Err(err)
            }
        })
    }
}

1	// Copyright 2020, The Tari Project
2	//
3	// Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
4	// following conditions are met:
5	//
6	// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
7	// disclaimer.
8	//
9	// 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
10	// following disclaimer in the documentation and/or other materials provided with the distribution.
11	//
12	// 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
13	// products derived from this software without specific prior written permission.
14	//
15	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
16	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
18	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
19	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
20	// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
21	// USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
22
23	use std::io;
24
25	use prost::DecodeError;
26	use thiserror::Error;
27
28	use super::{handshake::RpcHandshakeError, server::RpcServerError, RpcStatus};
29	use crate::{
30	connectivity::ConnectivityError,
31	peer_manager::PeerManagerError,
32	proto::rpc as rpc_proto,
33	traits::OrOptional,
34	PeerConnectionError,
35	};
36
37	#[derive(Debug, Error)]
38	pub enum RpcError {
39	#[error("Failed to decode message: {0}")]
40	DecodeError(#[from] DecodeError),
41	#[error("IO Error: {0}")]
42	Io(#[from] io::Error),
43	#[error("The client connection is closed")]
44	ClientClosed,
45	#[error("Request failed: {0}")]
46	RequestFailed(#[from] RpcStatus),
47	#[error("Remote peer unexpectedly closed the RPC connection")]
48	ServerClosedRequest,
49	#[error("Request cancelled")]
50	RequestCancelled,
51	#[error("Response did not match the request ID (expected {expected} actual {actual})")]
52	ResponseIdDidNotMatchRequest { expected: u16, actual: u16 },
53	#[error("Client internal error: {0}")]
54	ClientInternalError(String),
55	#[error("Handshake error: {0}")]
56	HandshakeError(#[from] RpcHandshakeError),
57	#[error("Server error: {0}")]
58	ServerError(#[from] RpcServerError),
59	#[error("Peer connection error: {0}")]
60	PeerConnectionError(#[from] PeerConnectionError),
61	#[error("Peer manager error: {0}")]
62	PeerManagerError(#[from] PeerManagerError),
63	#[error("Connectivity error: {0}")]
64	ConnectivityError(#[from] ConnectivityError),
65	#[error("Reply from peer timed out")]
66	ReplyTimeout,
67	#[error("Received an invalid ping response")]
68	InvalidPingResponse,
69	#[error("Unexpected ACK response. This is likely because of a previous ACK timeout")]
70	UnexpectedAckResponse,
71	#[error("Remote peer attempted to send more than {expected} payload chunks")]
72	RemotePeerExceededMaxChunkCount { expected: usize },
73	#[error("Request body was too large. Expected <= {expected} but got {got}")]
74	MaxRequestSizeExceeded { got: usize, expected: usize },
75	#[error(transparent)]
76	UnknownError(#[from] anyhow::Error),
77	}
78
79	impl RpcError {
80	pub fn client_internal_error<T: ToString>(err: &T) -> Self {	×
81	RpcError::ClientInternalError(err.to_string())	×
82	}	×
83
84	/// Returns true if the server directly caused the error, otherwise false
85	pub fn is_caused_by_server(&self) -> bool {	×
86	match self {	×
87	RpcError::ReplyTimeout \|
88	RpcError::DecodeError(_) \|
89	RpcError::RemotePeerExceededMaxChunkCount { .. } \|
90	RpcError::HandshakeError(RpcHandshakeError::DecodeError(_)) \|
91	RpcError::HandshakeError(RpcHandshakeError::ServerClosedRequest) \|
92	RpcError::HandshakeError(RpcHandshakeError::Rejected(_)) \|
93	RpcError::HandshakeError(RpcHandshakeError::TimedOut) \|
94	RpcError::ServerClosedRequest \|
95	RpcError::UnexpectedAckResponse \|
96	RpcError::ResponseIdDidNotMatchRequest { .. } => true,	×
97
98	// Some of these may be caused by the server, but not with 100% certainty
99	RpcError::RequestFailed(_) \|
100	RpcError::Io(_) \|
101	RpcError::ClientClosed \|
102	RpcError::RequestCancelled \|
103	RpcError::ClientInternalError(_) \|
104	RpcError::ServerError(_) \|
105	RpcError::PeerConnectionError(_) \|
106	RpcError::PeerManagerError(_) \|
107	RpcError::ConnectivityError(_) \|
108	RpcError::InvalidPingResponse \|
109	RpcError::MaxRequestSizeExceeded { .. } \|
110	RpcError::HandshakeError(RpcHandshakeError::Io(_)) \|
111	RpcError::HandshakeError(RpcHandshakeError::ClientNoSupportedVersion) \|
112	RpcError::HandshakeError(RpcHandshakeError::ClientClosed) \|
113	RpcError::UnknownError(_) => false,	×
114	}
115	}	×
116	}
117
118	#[derive(Debug, Error, Clone, Copy)]
119	pub enum HandshakeRejectReason {
120	#[error("protocol version not supported")]
121	UnsupportedVersion,
122	#[error("no more RPC server sessions available: {0}")]
123	NoServerSessionsAvailable(&'static str),
124	#[error("no more RPC client sessions available: {0}")]
125	NoClientSessionsAvailable(&'static str),
126	#[error("protocol not supported")]
127	ProtocolNotSupported,
128	#[error("unknown protocol error: {0}")]
129	Unknown(&'static str),
130	}
131
132	impl HandshakeRejectReason {
133	pub fn as_i32(&self) -> i32 {	7✔
134	rpc_proto::rpc_session_reply::HandshakeRejectReason::from(*self) as i32	7✔
135	}	7✔
136
137	pub fn from_i32(v: i32) -> Option<Self> {	7✔
138	rpc_proto::rpc_session_reply::HandshakeRejectReason::try_from(v)	7✔
139	.map(Into::into)	7✔
140	.ok()	7✔
141	}	7✔
142	}
143
144	impl From<rpc_proto::rpc_session_reply::HandshakeRejectReason> for HandshakeRejectReason {
145	fn from(reason: rpc_proto::rpc_session_reply::HandshakeRejectReason) -> Self {	7✔
146	#[allow(clippy::enum_glob_use)]
147	use rpc_proto::rpc_session_reply::HandshakeRejectReason::*;
148	match reason {	7✔
149	UnsupportedVersion => HandshakeRejectReason::UnsupportedVersion,	×
150	NoServerSessionsAvailable => HandshakeRejectReason::NoServerSessionsAvailable("session limit reached"),	6✔
151	NoClientSessionsAvailable => HandshakeRejectReason::NoClientSessionsAvailable("session limit reached"),	×
152	ProtocolNotSupported => HandshakeRejectReason::ProtocolNotSupported,	1✔
153	Unknown => HandshakeRejectReason::Unknown("reject reason is not known"),	×
154	}
155	}	7✔
156	}
157
158	impl From<HandshakeRejectReason> for rpc_proto::rpc_session_reply::HandshakeRejectReason {
159	fn from(reason: HandshakeRejectReason) -> Self {	7✔
160	#[allow(clippy::enum_glob_use)]
161	use rpc_proto::rpc_session_reply::HandshakeRejectReason::*;
162	match reason {	7✔
163	HandshakeRejectReason::UnsupportedVersion => UnsupportedVersion,	×
164	HandshakeRejectReason::NoServerSessionsAvailable(_) => NoServerSessionsAvailable,	6✔
165	HandshakeRejectReason::NoClientSessionsAvailable(_) => NoClientSessionsAvailable,	×
166	HandshakeRejectReason::ProtocolNotSupported => ProtocolNotSupported,	1✔
167	HandshakeRejectReason::Unknown(_) => Unknown,	×
168	}
169	}	7✔
170	}
171
172	impl<T> OrOptional<T> for Result<T, RpcError> {
173	type Error = RpcError;
174
175	fn or_optional(self) -> Result<Option<T>, Self::Error> {	×
176	self.map(Some).or_else(\|err\| {	×
177	if let RpcError::RequestFailed(ref status) = err {	×
178	if status.is_not_found() {	×
179	Ok(None)	×
180	} else {
181	Err(err)	×
182	}
183	} else {
184	Err(err)	×
185	}
186	})	×
187	}	×
188	}

tari-project / tari / 16123384529

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous