grpc 0.6.2

Rust implementation of gRPC
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

use std::error::Error as StdError;
use std::fmt;
use std::io;

use futures;

use metadata;

use httpbis;

use protobuf_lib::ProtobufError;

#[derive(Debug)]
pub struct GrpcMessageError {
    pub grpc_status: i32,

    /// Content of `grpc-message` header
    pub grpc_message: String,
}

#[derive(Debug)]
pub enum Error {
    Io(io::Error),
    Http(httpbis::Error),
    GrpcMessage(GrpcMessageError),
    Canceled(futures::Canceled),
    MetadataDecode(metadata::MetadataDecodeError),
    Protobuf(ProtobufError),
    Panic(String),
    Other(&'static str),
}

fn _assert_debug<D: ::std::fmt::Debug>(_: &D) {}

fn _assert_grpc_error_debug(e: &Error) {
    _assert_debug(e);
}

impl StdError for Error {
    fn description(&self) -> &str {
        match self {
            &Error::Io(ref err) => err.description(),
            &Error::Http(ref err) => err.description(),
            &Error::GrpcMessage(ref err) => &err.grpc_message,
            &Error::MetadataDecode(..) => "metadata decode error",
            &Error::Protobuf(ref err) => err.description(),
            &Error::Canceled(..) => "canceled",
            &Error::Panic(ref message) => &message,
            &Error::Other(ref message) => message,
        }
    }
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            &Error::Io(ref err) => write!(f, "io error: {}", err.description()),
            &Error::Http(ref err) => write!(f, "http error: {}", err.description()),
            &Error::GrpcMessage(ref err) => write!(f, "grpc message error: {}", err.grpc_message),
            &Error::MetadataDecode(..) => write!(f, "metadata decode error"),
            &Error::Protobuf(ref err) => write!(f, "protobuf error: {}", err.description()),
            &Error::Canceled(..) => write!(f, "canceled"),
            &Error::Panic(ref message) => write!(f, "panic: {}", message),
            &Error::Other(ref message) => write!(f, "other error: {}", message),
        }
    }
}

impl From<io::Error> for Error {
    fn from(err: io::Error) -> Self {
        Error::Io(err)
    }
}

impl From<httpbis::Error> for Error {
    fn from(err: httpbis::Error) -> Self {
        Error::Http(err)
    }
}

impl From<ProtobufError> for Error {
    fn from(err: ProtobufError) -> Self {
        Error::Protobuf(err)
    }
}

impl From<futures::Canceled> for Error {
    fn from(err: futures::Canceled) -> Self {
        Error::Canceled(err)
    }
}

impl From<Error> for io::Error {
    fn from(err: Error) -> io::Error {
        match err {
            Error::Io(e) => e,
            _ => io::Error::new(io::ErrorKind::Other, err),
        }
    }
}

impl From<metadata::MetadataDecodeError> for Error {
    fn from(de: metadata::MetadataDecodeError) -> Self {
        Error::MetadataDecode(de)
    }
}

impl From<Error> for httpbis::Error {
    fn from(_err: Error) -> httpbis::Error {
        httpbis::Error::Other("grpc error") // TODO: preserve
    }
}