rymder 0.8.0

Unofficial agones client SDK
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

pub type Result<T> = std::result::Result<T, Error>;

#[derive(Debug)]
pub enum Error {
    HealthPingConnectionFailure(String),
    TimedOut(tokio::time::error::Elapsed),
    InvalidUri(http::uri::InvalidUri),
    Rpc(tonic::Status),
    Transport(tonic::transport::Error),
    ParseInteger(std::num::ParseIntError),
    UnknownState(String),
    InvalidIp {
        ip_str: String,
        err: std::net::AddrParseError,
    },
    InvalidComponentRange(time::error::ComponentRange),
}

impl std::error::Error for Error {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        Some(match self {
            Self::HealthPingConnectionFailure(_) | Self::UnknownState(_) => return None,
            Self::TimedOut(elapsed) => elapsed,
            Self::InvalidUri(invalid) => invalid,
            Self::Rpc(status) => status,
            Self::Transport(transport) => transport,
            Self::ParseInteger(parse) => parse,
            Self::InvalidIp { err, .. } => err,
            Self::InvalidComponentRange(_err) => return None,
        })
    }
}

use std::fmt;

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::HealthPingConnectionFailure(inner) => {
                write!(f, "health ping connection failure: `{}`", inner)
            }
            Self::TimedOut(elapsed) => write!(f, "{}", elapsed),
            Self::InvalidUri(invalid) => write!(f, "failed to parse connection uri: `{}`", invalid),
            Self::Rpc(status) => write!(f, "rpc failure: `{}`", status),
            Self::Transport(transport) => write!(f, "transport failure: `{}`", transport),
            Self::ParseInteger(parse) => write!(f, "failed to parse integer: `{}`", parse),
            Self::UnknownState(us) => write!(f, "received an unknown state '{}' from agones", us),
            Self::InvalidIp { ip_str, err } => {
                write!(f, "failed to parse ip '{}': {}", ip_str, err)
            }
            Self::InvalidComponentRange(cr) => {
                write!(f, "invalid component range: {}", cr)
            }
        }
    }
}

impl From<tokio::time::error::Elapsed> for Error {
    #[inline]
    fn from(e: tokio::time::error::Elapsed) -> Self {
        Self::TimedOut(e)
    }
}

impl From<http::uri::InvalidUri> for Error {
    #[inline]
    fn from(e: http::uri::InvalidUri) -> Self {
        Self::InvalidUri(e)
    }
}

impl From<tonic::Status> for Error {
    #[inline]
    fn from(e: tonic::Status) -> Self {
        Self::Rpc(e)
    }
}

impl From<tonic::transport::Error> for Error {
    #[inline]
    fn from(e: tonic::transport::Error) -> Self {
        Self::Transport(e)
    }
}

impl From<time::error::ComponentRange> for Error {
    #[inline]
    fn from(e: time::error::ComponentRange) -> Self {
        Self::InvalidComponentRange(e)
    }
}