memberlist-quic 0.3.0

memberlist's transport layer based on QUIC
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

use crate::QuicError;

use s2n_quic::{connection::Error as ConnectionError, stream::Error as StreamError};

pub use s2n_quic_transport::connection::limits::ValidationError;

/// Error type for s2n stream layer.
#[derive(Debug, thiserror::Error)]
pub enum S2nError {
  /// Validation error.
  #[error("{0}")]
  Validation(#[from] ValidationError),

  /// Connection error.
  #[error(transparent)]
  Connection(#[from] ConnectionError),

  /// Stream error.
  #[error(transparent)]
  Stream(#[from] StreamError),

  /// IO error.
  #[error(transparent)]
  IO(#[from] std::io::Error),

  /// Timeout.
  #[error("timeout")]
  Timeout,

  /// Closed.
  #[error("endpoint closed")]
  Closed,
}

impl QuicError for S2nError {
  fn is_remote_failure(&self) -> bool {
    match self {
      Self::Validation(_) => false,
      Self::Connection(err) => match err {
        ConnectionError::Closed { .. } => false,
        ConnectionError::Transport { .. } => true,
        ConnectionError::Application { .. } => true,
        ConnectionError::StatelessReset { .. } => true,
        ConnectionError::IdleTimerExpired { .. } => false,
        ConnectionError::NoValidPath { .. } => true,
        ConnectionError::StreamIdExhausted { .. } => false,
        ConnectionError::MaxHandshakeDurationExceeded { .. } => true,
        ConnectionError::ImmediateClose { .. } => false,
        ConnectionError::EndpointClosing { .. } => false,
        ConnectionError::Unspecified { .. } => false,
        _ => false,
      },
      Self::Closed => false,
      Self::IO(_) => true,
      Self::Stream(err) => match err {
        StreamError::InvalidStream { .. } => false,
        StreamError::StreamReset { .. } => true,
        StreamError::SendAfterFinish { .. } => false,
        StreamError::MaxStreamDataSizeExceeded { .. } => false,
        StreamError::ConnectionError { .. } => true,
        StreamError::NonReadable { .. } => true,
        StreamError::NonWritable { .. } => false,
        StreamError::SendingBlocked { .. } => false,
        StreamError::NonEmptyOutput { .. } => false,
        _ => false,
      },
      Self::Timeout => true,
    }
  }
}